Add commented-out example of CSA check to the default configuration.
[exim.git] / src / src / spam.c
1 /* $Cambridge: exim/src/src/spam.c,v 1.5 2005/04/27 10:00:18 ph10 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003-???? */
8 /* License: GPL */
9
10 /* Code for calling spamassassin's spamd. Called from acl.c. */
11
12 #include "exim.h"
13 #ifdef WITH_CONTENT_SCAN
14 #include "spam.h"
15
16 uschar spam_score_buffer[16];
17 uschar spam_score_int_buffer[16];
18 uschar spam_bar_buffer[128];
19 uschar spam_report_buffer[32600];
20 uschar prev_user_name[128] = "";
21 int spam_ok = 0;
22 int spam_rc = 0;
23
24 int spam(uschar **listptr) {
25   int sep = 0;
26   uschar *list = *listptr;
27   uschar *user_name;
28   uschar user_name_buffer[128];
29   unsigned long mbox_size;
30   FILE *mbox_file;
31   int spamd_sock;
32   uschar spamd_buffer[32600];
33   int i, j, offset, result;
34   uschar spamd_version[8];
35   uschar spamd_score_char;
36   double spamd_threshold, spamd_score;
37   int spamd_report_offset;
38   uschar *p,*q;
39   int override = 0;
40   time_t start;
41   size_t read, wrote;
42   struct sockaddr_un server;
43   struct pollfd pollfd;
44
45   /* find the username from the option list */
46   if ((user_name = string_nextinlist(&list, &sep,
47                                      user_name_buffer,
48                                      sizeof(user_name_buffer))) == NULL) {
49     /* no username given, this means no scanning should be done */
50     return FAIL;
51   };
52
53   /* if username is "0" or "false", do not scan */
54   if ( (Ustrcmp(user_name,"0") == 0) ||
55        (strcmpic(user_name,US"false") == 0) ) {
56     return FAIL;
57   };
58
59   /* if there is an additional option, check if it is "true" */
60   if (strcmpic(list,US"true") == 0) {
61     /* in that case, always return true later */
62     override = 1;
63   };
64
65   /* if we scanned for this username last time, just return */
66   if ( spam_ok && ( Ustrcmp(prev_user_name, user_name) == 0 ) ) {
67     if (override)
68       return OK;
69     else
70       return spam_rc;
71   };
72
73   /* make sure the eml mbox file is spooled up */
74   mbox_file = spool_mbox(&mbox_size);
75
76   if (mbox_file == NULL) {
77     /* error while spooling */
78     log_write(0, LOG_MAIN|LOG_PANIC,
79            "spam acl condition: error while creating mbox spool file");
80     return DEFER;
81   };
82
83   start = time(NULL);
84   /* socket does not start with '/' -> network socket */
85   if (*spamd_address != '/') {
86     time_t now = time(NULL);
87     int num_servers = 0;
88     int current_server = 0;
89     int start_server = 0;
90     uschar *address = NULL;
91     uschar *spamd_address_list_ptr = spamd_address;
92     uschar address_buffer[256];
93     spamd_address_container * spamd_address_vector[32];
94
95     /* Check how many spamd servers we have
96        and register their addresses */
97     while ((address = string_nextinlist(&spamd_address_list_ptr, &sep,
98                                         address_buffer,
99                                         sizeof(address_buffer))) != NULL) {
100
101       spamd_address_container *this_spamd =
102         (spamd_address_container *)store_get(sizeof(spamd_address_container));
103
104       /* grok spamd address and port */
105       if( sscanf(CS address, "%s %u", this_spamd->tcp_addr, &(this_spamd->tcp_port)) != 2 ) {
106         log_write(0, LOG_MAIN,
107           "spam acl condition: warning - invalid spamd address: '%s'", address);
108         continue;
109       };
110
111       spamd_address_vector[num_servers] = this_spamd;
112       num_servers++;
113       if (num_servers > 31)
114         break;
115     };
116
117     /* check if we have at least one server */
118     if (!num_servers) {
119       log_write(0, LOG_MAIN|LOG_PANIC,
120          "spam acl condition: no useable spamd server addresses in spamd_address configuration option.");
121       fclose(mbox_file);
122       return DEFER;
123     };
124
125     current_server = start_server = (int)now % num_servers;
126
127     while (1) {
128
129       debug_printf("trying server %s, port %u\n",
130                    spamd_address_vector[current_server]->tcp_addr,
131                    spamd_address_vector[current_server]->tcp_port);
132
133       /* contact a spamd */
134       if ( (spamd_sock = ip_socket(SOCK_STREAM, AF_INET)) < 0) {
135         log_write(0, LOG_MAIN|LOG_PANIC,
136            "spam acl condition: error creating IP socket for spamd");
137         fclose(mbox_file);
138         return DEFER;
139       };
140
141       if (ip_connect( spamd_sock,
142                       AF_INET,
143                       spamd_address_vector[current_server]->tcp_addr,
144                       spamd_address_vector[current_server]->tcp_port,
145                       5 ) > -1) {
146         /* connection OK */
147         break;
148       };
149
150       log_write(0, LOG_MAIN|LOG_PANIC,
151          "spam acl condition: warning - spamd connection to %s, port %u failed: %s",
152          spamd_address_vector[current_server]->tcp_addr,
153          spamd_address_vector[current_server]->tcp_port,
154          strerror(errno));
155       current_server++;
156       if (current_server >= num_servers)
157         current_server = 0;
158       if (current_server == start_server) {
159         log_write(0, LOG_MAIN|LOG_PANIC, "spam acl condition: all spamd servers failed");
160         fclose(mbox_file);
161         close(spamd_sock);
162         return DEFER;
163       };
164     };
165
166   }
167   else {
168     /* open the local socket */
169
170     if ((spamd_sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
171       log_write(0, LOG_MAIN|LOG_PANIC,
172                 "malware acl condition: spamd: unable to acquire socket (%s)",
173                 strerror(errno));
174       fclose(mbox_file);
175       return DEFER;
176     }
177
178     server.sun_family = AF_UNIX;
179     Ustrcpy(server.sun_path, spamd_address);
180
181     if (connect(spamd_sock, (struct sockaddr *) &server, sizeof(struct sockaddr_un)) < 0) {
182       log_write(0, LOG_MAIN|LOG_PANIC,
183                 "malware acl condition: spamd: unable to connect to UNIX socket %s (%s)",
184                 spamd_address, strerror(errno) );
185       fclose(mbox_file);
186       close(spamd_sock);
187       return DEFER;
188     }
189
190   }
191
192   /* now we are connected to spamd on spamd_sock */
193   snprintf(CS spamd_buffer,
194            sizeof(spamd_buffer),
195            "REPORT SPAMC/1.2\r\nUser: %s\r\nContent-length: %ld\r\n\r\n",
196            user_name,
197            mbox_size);
198
199   /* send our request */
200   if (send(spamd_sock, spamd_buffer, Ustrlen(spamd_buffer), 0) < 0) {
201     close(spamd_sock);
202     log_write(0, LOG_MAIN|LOG_PANIC,
203          "spam acl condition: spamd send failed: %s", strerror(errno));
204     fclose(mbox_file);
205     close(spamd_sock);
206     return DEFER;
207   };
208
209   /* now send the file */
210   /* spamd sometimes accepts conections but doesn't read data off
211    * the connection.  We make the file descriptor non-blocking so
212    * that the write will only write sufficient data without blocking
213    * and we poll the desciptor to make sure that we can write without
214    * blocking.  Short writes are gracefully handled and if the whole
215    * trasaction takes too long it is aborted.
216    */
217   pollfd.fd = spamd_sock;
218   pollfd.events = POLLOUT;
219   fcntl(spamd_sock, F_SETFL, O_NONBLOCK);
220   do {
221     read = fread(spamd_buffer,1,sizeof(spamd_buffer),mbox_file);
222     if (read > 0) {
223       offset = 0;
224 again:
225       result = poll(&pollfd, 1, 1000);
226       if (result == -1 && errno == EINTR)
227         continue;
228       else if (result < 1) {
229         if (result == -1)
230           log_write(0, LOG_MAIN|LOG_PANIC,
231             "spam acl condition: %s on spamd socket", strerror(errno));
232         else {
233           if (time(NULL) - start < SPAMD_TIMEOUT)
234           goto again;
235           log_write(0, LOG_MAIN|LOG_PANIC,
236             "spam acl condition: timed out writing spamd socket");
237         }
238         close(spamd_sock);
239         fclose(mbox_file);
240         return DEFER;
241       }
242       wrote = send(spamd_sock,spamd_buffer + offset,read - offset,0);
243       if (offset + wrote != read) {
244         offset += wrote;
245         goto again;
246       }
247     }
248   }
249   while (!feof(mbox_file) && !ferror(mbox_file));
250   if (ferror(mbox_file)) {
251     log_write(0, LOG_MAIN|LOG_PANIC,
252       "spam acl condition: error reading spool file: %s", strerror(errno));
253     close(spamd_sock);
254     fclose(mbox_file);
255     return DEFER;
256   }
257
258   fclose(mbox_file);
259
260   /* we're done sending, close socket for writing */
261   shutdown(spamd_sock,SHUT_WR);
262
263   /* read spamd response using what's left of the timeout.
264    */
265   memset(spamd_buffer, 0, sizeof(spamd_buffer));
266   offset = 0;
267   while((i = ip_recv(spamd_sock,
268                      spamd_buffer + offset,
269                      sizeof(spamd_buffer) - offset - 1,
270                      SPAMD_TIMEOUT - time(NULL) + start)) > 0 ) {
271     offset += i;
272   }
273
274   /* error handling */
275   if((i <= 0) && (errno != 0)) {
276     log_write(0, LOG_MAIN|LOG_PANIC,
277          "spam acl condition: error reading from spamd socket: %s", strerror(errno));
278     close(spamd_sock);
279     return DEFER;
280   }
281
282   /* reading done */
283   close(spamd_sock);
284
285   /* dig in the spamd output and put the report in a multiline header, if requested */
286   if( sscanf(CS spamd_buffer,"SPAMD/%s 0 EX_OK\r\nContent-length: %*u\r\n\r\n%lf/%lf\r\n%n",
287              spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3 ) {
288
289     /* try to fall back to pre-2.50 spamd output */
290     if( sscanf(CS spamd_buffer,"SPAMD/%s 0 EX_OK\r\nSpam: %*s ; %lf / %lf\r\n\r\n%n",
291                spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3 ) {
292       log_write(0, LOG_MAIN|LOG_PANIC,
293          "spam acl condition: cannot parse spamd output");
294       return DEFER;
295     };
296   };
297
298   /* Create report. Since this is a multiline string,
299   we must hack it into shape first */
300   p = &spamd_buffer[spamd_report_offset];
301   q = spam_report_buffer;
302   while (*p != '\0') {
303     /* skip \r */
304     if (*p == '\r') {
305       p++;
306       continue;
307     };
308     *q = *p;
309     q++;
310     if (*p == '\n') {
311       *q = '\t';
312       q++;
313       /* eat whitespace */
314       while( (*p <= ' ') && (*p != '\0') ) {
315         p++;
316       };
317       p--;
318     };
319     p++;
320   };
321   /* NULL-terminate */
322   *q = '\0';
323   q--;
324   /* cut off trailing leftovers */
325   while (*q <= ' ') {
326     *q = '\0';
327     q--;
328   };
329   spam_report = spam_report_buffer;
330
331   /* create spam bar */
332   spamd_score_char = spamd_score > 0 ? '+' : '-';
333   j = abs((int)(spamd_score));
334   i = 0;
335   if( j != 0 ) {
336     while((i < j) && (i <= MAX_SPAM_BAR_CHARS))
337        spam_bar_buffer[i++] = spamd_score_char;
338   }
339   else{
340     spam_bar_buffer[0] = '/';
341     i = 1;
342   }
343   spam_bar_buffer[i] = '\0';
344   spam_bar = spam_bar_buffer;
345
346   /* create "float" spam score */
347   snprintf(CS spam_score_buffer, sizeof(spam_score_buffer),"%.1f", spamd_score);
348   spam_score = spam_score_buffer;
349
350   /* create "int" spam score */
351   j = (int)((spamd_score + 0.001)*10);
352   snprintf(CS spam_score_int_buffer, sizeof(spam_score_int_buffer), "%d", j);
353   spam_score_int = spam_score_int_buffer;
354
355   /* compare threshold against score */
356   if (spamd_score >= spamd_threshold) {
357     /* spam as determined by user's threshold */
358     spam_rc = OK;
359   }
360   else {
361     /* not spam */
362     spam_rc = FAIL;
363   };
364
365   /* remember user name and "been here" for it */
366   Ustrcpy(prev_user_name, user_name);
367   spam_ok = 1;
368
369   if (override) {
370     /* always return OK, no matter what the score */
371     return OK;
372   }
373   else {
374     return spam_rc;
375   };
376 }
377
378 #endif