src/plugins/spamassassin/libspamc.c

   1 /*
   2  * This code is copyright 2001 by Craig Hughes
   3  * Portions copyright 2002 by Brad Jorsch
   4  * It is licensed under the same license as Perl itself.  The text of this
   5  * license is included in the SpamAssassin distribution in the file named
   6  * "License".
   7  */
   8
   9 #include "config.h"
  10 #include "libspamc.h"
  11 #include "utils.h"
  12
  13 #include <unistd.h>
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <syslog.h>
  18 #include <sys/types.h>
  19 #include <sys/socket.h>
  20 #include <netinet/in.h>
  21 #include <netinet/tcp.h>
  22 #include <arpa/inet.h>
  23
  24 #ifdef HAVE_SYSEXITS_H
  25 #include <sysexits.h>
  26 #endif
  27 #ifdef HAVE_ERRNO_H
  28 #include <errno.h>
  29 #endif
  30 #ifdef HAVE_SYS_ERRNO_H
  31 #include <sys/errno.h>
  32 #endif
  33 #ifdef HAVE_TIME_H
  34 #include <time.h>
  35 #endif
  36 #ifdef HAVE_SYS_TIME_H
  37 #include <sys/time.h>
  38 #endif
  39
  40 #define MAX_CONNECT_RETRIES 3
  41 #define CONNECT_RETRY_SLEEP 1
  42
  43 /* RedHat 5.2 doesn't define Shutdown 2nd Parameter Constants */
  44 /* KAM 12-4-01 */
  45 #ifndef HAVE_SHUT_RD
  46 #define SHUT_RD (0)   /* No more receptions.  */
  47 #define SHUT_WR (1)   /* No more transmissions.  */
  48 #define SHUT_RDWR (2) /* No more receptions or transmissions.  */
  49 #endif
  50
  51 #ifndef HAVE_H_ERRNO
  52 #define h_errno errno
  53 #endif
  54
  55 #ifndef HAVE_OPTARG
  56 extern char *optarg;
  57 #endif
  58
  59 #ifndef HAVE_INADDR_NONE
  60 #define INADDR_NONE             ((in_addr_t) 0xffffffff)
  61 #endif
  62
  63 /* jm: turned off for now, it should not be necessary. */
  64 #undef USE_TCP_NODELAY
  65
  66 #ifndef HAVE_EX__MAX
  67 /* jm: very conservative figure, should be well out of range on almost all NIXes */
  68 #define EX__MAX 200
  69 #endif
  70
  71 #undef DO_CONNECT_DEBUG_SYSLOGS
  72 /* or #define DO_CONNECT_DEBUG_SYSLOGS 1 */
  73
  74 static const int ESC_PASSTHROUGHRAW = EX__MAX+666;
  75
  76 /* set EXPANSION_ALLOWANCE to something more than might be
  77    added to a message in X-headers and the report template */
  78 static const int EXPANSION_ALLOWANCE = 16384;
  79
  80 /* set NUM_CHECK_BYTES to number of bytes that have to match at beginning and end
  81    of the data streams before and after processing by spamd
  82    Aug  7 2002 jm: no longer seems to be used
  83    static const int NUM_CHECK_BYTES = 32;
  84  */
  85
  86 /* Set the protocol version that this spamc speaks */
  87 static const char *PROTOCOL_VERSION="SPAMC/1.3";
  88
  89 int libspamc_timeout = 0;
  90
  91 static int
  92 try_to_connect (const struct sockaddr *argaddr, struct hostent *hent,
  93                 int hent_port, int *sockptr)
  94 {
  95 #ifdef USE_TCP_NODELAY
  96   int value;
  97 #endif
  98   int mysock = -1;
  99   int status = -1;
 100   int origerr;
 101   int numloops;
 102   int hostnum = 0;
 103   struct sockaddr_in addrbuf, *addr;
 104   struct in_addr inaddrlist[256];
 105
 106 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 107   int dbgiter; char dbgbuf[2048]; int dbgbuflen = 0;
 108 #endif
 109
 110   /* NOTE: do not call syslog() (unless you are about to return) before
 111    * we take a copy of the h_addr_list.
 112    */
 113
 114   /* only one set of connection targets can be used.  assert this */
 115   if (argaddr == NULL && hent == NULL) {
 116       syslog (LOG_ERR, "oops! both NULL in try_to_connect");
 117       return EX_SOFTWARE;
 118   } else if (argaddr != NULL && hent != NULL) {
 119       syslog (LOG_ERR, "oops! both non-NULL in try_to_connect");
 120       return EX_SOFTWARE;
 121   }
 122
 123   /* take a copy of the h_addr_list part of the struct hostent */
 124   if (hent != NULL) {
 125     memset (inaddrlist, 0, sizeof(inaddrlist));
 126
 127     for (hostnum=0; hent->h_addr_list[hostnum] != 0; hostnum++) {
 128
 129 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 130       dbgbuflen += snprintf (dbgbuf+dbgbuflen, 2047-dbgbuflen,
 131                   "[%d %lx: %d.%d.%d.%d]",
 132                   hostnum, hent->h_addr_list[hostnum],
 133                   hent->h_addr_list[hostnum][0],
 134                   hent->h_addr_list[hostnum][1],
 135                   hent->h_addr_list[hostnum][2],
 136                   hent->h_addr_list[hostnum][3]);
 137 #endif
 138
 139       if (hostnum > 255) {
 140         syslog (LOG_ERR, "too many address in hostent (%d), ignoring others",
 141                             hostnum);
 142         break;
 143       }
 144
 145       if (hent->h_addr_list[hostnum] == NULL) {
 146         /* shouldn't happen */
 147         syslog (LOG_ERR, "hent->h_addr_list[hostnum] == NULL! foo!");
 148         return EX_SOFTWARE;
 149       }
 150
 151 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 152       dbgbuflen += snprintf (dbgbuf+dbgbuflen, 2047-dbgbuflen,
 153                   "[%d: %d.%d.%d.%d] ", sizeof (struct in_addr),
 154                   hent->h_addr_list[hostnum][0],
 155                   hent->h_addr_list[hostnum][1],
 156                   hent->h_addr_list[hostnum][2],
 157                   hent->h_addr_list[hostnum][3]);
 158 #endif
 159
 160       memcpy ((void *) &(inaddrlist[hostnum]),
 161                 (void *) hent->h_addr_list[hostnum],
 162                 sizeof (struct in_addr));
 163     }
 164
 165 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 166       syslog (LOG_DEBUG, "dbg: %d %s", hostnum, dbgbuf); dbgbuflen = 0;
 167 #endif
 168   }
 169
 170
 171 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 172     for (dbgiter = 0; dbgiter < hostnum; dbgiter++) {
 173       syslog (LOG_DEBUG, "dbg: host addr %d/%d = %lx at %lx", dbgiter, hostnum,
 174                   inaddrlist[dbgiter].s_addr, &(inaddrlist[dbgiter]));
 175     }
 176 #endif
 177
 178   hent = NULL; /* cannot use hent after this point, syslog() may overwrite it */
 179
 180 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 181   syslog (LOG_DEBUG, "dbg: socket");
 182 #endif
 183
 184   if(-1 == (mysock = socket(PF_INET,SOCK_STREAM,0)))
 185   {
 186     origerr = errno;    /* take a copy before syslog() */
 187     syslog (LOG_ERR, "socket() to spamd failed: %m");
 188     switch(origerr)
 189     {
 190     case EPROTONOSUPPORT:
 191     case EINVAL:
 192       return EX_SOFTWARE;
 193     case EACCES:
 194       return EX_NOPERM;
 195     case ENFILE:
 196     case EMFILE:
 197     case ENOBUFS:
 198     case ENOMEM:
 199       return EX_OSERR;
 200     default:
 201       return EX_SOFTWARE;
 202     }
 203   }
 204
 205 #ifdef USE_TCP_NODELAY
 206   /* TODO: should this be up above the connect()? */
 207   value = 1;            /* make this explicit! */
 208   if(-1 == setsockopt(mysock,0,TCP_NODELAY,&value,sizeof(value)))
 209   {
 210     switch(errno)
 211     {
 212     case EBADF:
 213     case ENOTSOCK:
 214     case ENOPROTOOPT:
 215     case EFAULT:
 216       syslog (LOG_ERR, "setsockopt() to spamd failed: %m");
 217       close (mysock);
 218       return EX_SOFTWARE;
 219
 220     default:
 221       break;            /* ignored */
 222     }
 223   }
 224 #endif
 225
 226   for (numloops=0; numloops < MAX_CONNECT_RETRIES; numloops++) {
 227
 228 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 229       syslog (LOG_DEBUG, "dbg: connect() to spamd %d", numloops);
 230 #endif
 231
 232     if (argaddr != NULL) {
 233       addr = (struct sockaddr_in *) argaddr;     /* use the one provided */
 234
 235 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 236         syslog (LOG_DEBUG, "dbg: using argaddr");
 237 #endif
 238
 239     } else {
 240       /* cycle through the addrs in hent */
 241       memset(&addrbuf, 0, sizeof(addrbuf));
 242       addrbuf.sin_family=AF_INET;
 243       addrbuf.sin_port=htons(hent_port);
 244
 245       if (sizeof(addrbuf.sin_addr) != sizeof(struct in_addr)) { /* shouldn't happen */
 246         syslog (LOG_ERR,
 247                 "foo! sizeof(sockaddr.sin_addr) != sizeof(struct in_addr)");
 248         return EX_SOFTWARE;
 249       }
 250
 251 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 252         syslog (LOG_DEBUG, "dbg: cpy addr %d/%d at %lx",
 253                 numloops%hostnum, hostnum, &(inaddrlist[numloops % hostnum]));
 254 #endif
 255
 256       memcpy (&addrbuf.sin_addr, &(inaddrlist[numloops % hostnum]),
 257                         sizeof(addrbuf.sin_addr));
 258       addr = &addrbuf;
 259
 260 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 261         syslog (LOG_DEBUG, "dbg: conn addr %d/%d = %lx",
 262             numloops%hostnum, hostnum, addrbuf.sin_addr.s_addr);
 263 #endif
 264
 265     }
 266
 267 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 268     syslog (LOG_DEBUG, "dbg: connect() to spamd at %s",
 269                 inet_ntoa(((struct sockaddr_in *)addr)->sin_addr));
 270 #endif
 271     status = connect(mysock,(const struct sockaddr *) addr, sizeof(*addr));
 272
 273 #ifdef DO_CONNECT_DEBUG_SYSLOGS
 274       syslog (LOG_DEBUG, "dbg: connect() to spamd at %s done",
 275           inet_ntoa(((struct sockaddr_in *)addr)->sin_addr));
 276 #endif
 277
 278     if (status < 0)
 279     {
 280       origerr = errno;        /* take a copy before syslog() */
 281       syslog (LOG_ERR, "connect() to spamd at %s failed, retrying (%d/%d): %m",
 282                         inet_ntoa(((struct sockaddr_in *)addr)->sin_addr),
 283                         numloops+1, MAX_CONNECT_RETRIES);
 284       sleep(CONNECT_RETRY_SLEEP);
 285
 286     } else {
 287       *sockptr = mysock;
 288       return EX_OK;
 289     }
 290   }
 291
 292   /* failed, even with a few retries */
 293   close (mysock);
 294   syslog (LOG_ERR, "connection attempt to spamd aborted after %d retries",
 295        MAX_CONNECT_RETRIES);
 296
 297   switch(origerr)
 298   {
 299    case EBADF:
 300    case EFAULT:
 301    case ENOTSOCK:
 302    case EISCONN:
 303    case EADDRINUSE:
 304    case EINPROGRESS:
 305    case EALREADY:
 306    case EAFNOSUPPORT:
 307      return EX_SOFTWARE;
 308    case ECONNREFUSED:
 309    case ETIMEDOUT:
 310    case ENETUNREACH:
 311      return EX_UNAVAILABLE;
 312    case EACCES:
 313      return EX_NOPERM;
 314    default:
 315      return EX_SOFTWARE;
 316   }
 317 }
 318
 319 /* Aug 14, 2002 bj: Reworked things. Now we have message_read, message_write,
 320  * message_dump, lookup_host, message_filter, and message_process, and a bunch
 321  * of helper functions.
 322  */
 323
 324 static void clear_message(struct message *m){
 325     m->type=MESSAGE_NONE;
 326     m->raw=NULL; m->raw_len=0;
 327     m->pre=NULL; m->pre_len=0;
 328     m->msg=NULL; m->msg_len=0;
 329     m->post=NULL; m->post_len=0;
 330     m->is_spam=EX_TOOBIG;
 331     m->score=0.0; m->threshold=0.0;
 332     m->out=NULL; m->out_len=0;
 333     m->content_length=-1;
 334 }
 335
 336 static int
 337 message_read_raw(int fd, struct message *m){
 338     clear_message(m);
 339     if((m->raw=malloc(m->max_len+1))==NULL) return EX_OSERR;
 340     m->raw_len=full_read(fd, (unsigned char *) m->raw, m->max_len+1, m->max_len+1);
 341     if(m->raw_len<=0){
 342         free(m->raw); m->raw=NULL; m->raw_len=0;
 343         return EX_IOERR;
 344     }
 345     m->type=MESSAGE_ERROR;
 346     if(m->raw_len>m->max_len) return EX_TOOBIG;
 347     m->type=MESSAGE_RAW;
 348     m->msg=m->raw;
 349     m->msg_len=m->raw_len;
 350     m->out=m->msg;
 351     m->out_len=m->msg_len;
 352     return EX_OK;
 353 }
 354
 355 static int message_read_bsmtp(int fd, struct message *m){
 356     off_t i, j;
 357     char prev;
 358
 359     clear_message(m);
 360     if((m->raw=malloc(m->max_len+1))==NULL) return EX_OSERR;
 361
 362     /* Find the DATA line */
 363     m->raw_len=full_read(fd, (unsigned char *) m->raw, m->max_len+1, m->max_len+1);
 364     if(m->raw_len<=0){
 365         free(m->raw); m->raw=NULL; m->raw_len=0;
 366         return EX_IOERR;
 367     }
 368     m->type=MESSAGE_ERROR;
 369     if(m->raw_len>m->max_len) return EX_TOOBIG;
 370     m->pre=m->raw;
 371     for(i=0; i<m->raw_len-6; i++){
 372         if((m->raw[i]=='\n') &&
 373            (m->raw[i+1]=='D' || m->raw[i+1]=='d') &&
 374            (m->raw[i+2]=='A' || m->raw[i+2]=='a') &&
 375            (m->raw[i+3]=='T' || m->raw[i+3]=='t') &&
 376            (m->raw[i+4]=='A' || m->raw[i+4]=='a') &&
 377            ((m->raw[i+5]=='\r' && m->raw[i+6]=='\n') || m->raw[i+5]=='\n')){
 378             /* Found it! */
 379             i+=6;
 380             if(m->raw[i-1]=='\r') i++;
 381             m->pre_len=i;
 382             m->msg=m->raw+i;
 383             m->msg_len=m->raw_len-i;
 384             break;
 385         }
 386     }
 387     if(m->msg==NULL) return EX_DATAERR;
 388
 389     /* Find the end-of-DATA line */
 390     prev='\n';
 391     for(i=j=0; i<m->msg_len; i++){
 392         if(prev=='\n' && m->msg[i]=='.'){
 393             /* Dot at the beginning of a line */
 394             if((m->msg[i+1]=='\r' && m->msg[i+2]=='\n') || m->msg[i+1]=='\n'){
 395                 /* Lone dot! That's all, folks */
 396                 m->post=m->msg+i;
 397                 m->post_len=m->msg_len-i;
 398                 m->msg_len=j;
 399                 break;
 400             } else if(m->msg[i+1]=='.'){
 401                 /* Escaping dot, eliminate. */
 402                 prev='.';
 403                 continue;
 404             } /* Else an ordinary dot, drop down to ordinary char handler */
 405         }
 406         prev=m->msg[i];
 407         m->msg[j++]=m->msg[i];
 408     }
 409
 410     m->type=MESSAGE_BSMTP;
 411     m->out=m->msg;
 412     m->out_len=m->msg_len;
 413     return EX_OK;
 414 }
 415
 416 int message_read(int fd, int flags, struct message *m){
 417     libspamc_timeout = 0;
 418
 419     switch(flags&SPAMC_MODE_MASK){
 420       case SPAMC_RAW_MODE:
 421         return message_read_raw(fd, m);
 422
 423       case SPAMC_BSMTP_MODE:
 424         return message_read_bsmtp(fd, m);
 425
 426       default:
 427         syslog(LOG_ERR, "message_read: Unknown mode %d\n", flags&SPAMC_MODE_MASK);
 428         return EX_USAGE;
 429     }
 430 }
 431
 432 long message_write(int fd, struct message *m){
 433     long total=0;
 434     off_t i, j;
 435     off_t jlimit;
 436     char buffer[1024];
 437
 438     /* if we're to output a message, m->is_spam will be EX_OUTPUTMESSAGE */
 439     if(m->is_spam==EX_ISSPAM || m->is_spam==EX_NOTSPAM){
 440         return full_write(fd, (unsigned char *) m->out, m->out_len);
 441     }
 442
 443     if (m->is_spam != EX_OUTPUTMESSAGE && m->is_spam != EX_TOOBIG) {
 444       syslog(LOG_ERR,
 445             "Cannot write this message, is_spam = %d!\n", m->is_spam);
 446       return -1;
 447     }
 448
 449     switch(m->type){
 450       case MESSAGE_NONE:
 451         syslog(LOG_ERR, "Cannot write this message, it's MESSAGE_NONE!\n");
 452         return -1;
 453
 454       case MESSAGE_ERROR:
 455         return full_write(fd, (unsigned char *) m->raw, m->raw_len);
 456
 457       case MESSAGE_RAW:
 458         return full_write(fd, (unsigned char *) m->out, m->out_len);
 459
 460       case MESSAGE_BSMTP:
 461         total=full_write(fd, (unsigned char *) m->pre, m->pre_len);
 462         for(i=0; i<m->out_len; ){
 463             jlimit = (off_t) (sizeof(buffer)/sizeof(*buffer)-4);
 464             for(j=0; i < (off_t) m->out_len &&
 465                                 j < jlimit;)
 466             {
 467                 if(i+1<m->out_len && m->out[i]=='\n' && m->out[i+1]=='.'){
 468                     if (j > jlimit - 4) {
 469                         break;          /* avoid overflow */
 470                     }
 471                     buffer[j++]=m->out[i++];
 472                     buffer[j++]=m->out[i++];
 473                     buffer[j++]='.';
 474                 } else {
 475                     buffer[j++]=m->out[i++];
 476                 }
 477             }
 478             total+=full_write(fd, (unsigned char *) buffer, j);
 479         }
 480         return total+full_write(fd, (unsigned char *) m->post, m->post_len);
 481
 482       default:
 483         syslog(LOG_ERR, "Unknown message type %d\n", m->type);
 484         return -1;
 485     }
 486 }
 487
 488 void message_dump(int in_fd, int out_fd, struct message *m){
 489     char buf[8196];
 490     int bytes;
 491
 492     if(m!=NULL && m->type!=MESSAGE_NONE) {
 493         message_write(out_fd, m);
 494     }
 495     while((bytes=full_read(in_fd, (unsigned char *) buf, 8192, 8192))>0){
 496         if (bytes!=full_write(out_fd, (unsigned char *) buf, bytes)) {
 497             syslog(LOG_ERR, "oops! message_dump of %d returned different", bytes);
 498         }
 499     }
 500 }
 501
 502 static int
 503 _spamc_read_full_line (struct message *m, int flags, SSL *ssl, int sock,
 504                 char *buf, int *lenp, int bufsiz)
 505 {
 506     int failureval;
 507     int bytesread = 0;
 508     int len;
 509
 510     /* Now, read from spamd */
 511     for(len=0; len<bufsiz-1; len++) {
 512         if(flags&SPAMC_USE_SSL) {
 513           bytesread = ssl_timeout_read (ssl, buf+len, 1);
 514         } else {
 515           bytesread = fd_timeout_read (sock, buf+len, 1);
 516         }
 517
 518         if(buf[len]=='\n') {
 519             buf[len]='\0';
 520             if (len > 0 && buf[len-1] == '\r') {
 521                 len--;
 522                 buf[len]='\0';
 523             }
 524             *lenp = len;
 525             return EX_OK;
 526         }
 527
 528         if(bytesread<=0){
 529             failureval = EX_IOERR; goto failure;
 530         }
 531     }
 532
 533     syslog(LOG_ERR, "spamd responded with line of %d bytes, dying", len);
 534     failureval = EX_TOOBIG;
 535
 536 failure:
 537     return failureval;
 538 }
 539
 540 /*
 541  * May  7 2003 jm: using %f is bad where LC_NUMERIC is "," in the locale.
 542  * work around using our own locale-independent float-parser code.
 543  */
 544 static float
 545 _locale_safe_string_to_float (char *buf, int siz)
 546 {
 547   int is_neg;
 548   char *cp, *dot;
 549   int divider;
 550   float ret, postdot;
 551
 552   buf[siz-1] = '\0';    /* ensure termination */
 553
 554   /* ok, let's illustrate using "100.033" as an example... */
 555
 556   is_neg = 0;
 557   if (*buf == '-') { is_neg = 1; }
 558
 559   ret = (float) (strtol (buf, &dot, 10));
 560   if (dot == NULL) { return 0.0; }
 561   if (dot != NULL && *dot != '.') { return ret; }
 562
 563   /* ex: ret == 100.0 */
 564
 565   cp = (dot + 1);
 566   postdot = (float) (strtol (cp, NULL, 10));
 567   if (postdot == 0.0) { return ret; }
 568
 569   /* ex: postdot == 33.0, cp="033" */
 570
 571   /* now count the number of decimal places and figure out what power of 10 to use */
 572   divider = 1;
 573   while (*cp != '\0') {
 574     divider *= 10; cp++;
 575   }
 576
 577   /* ex:
 578    * cp="033", divider=1
 579    * cp="33", divider=10
 580    * cp="3", divider=100
 581    * cp="", divider=1000
 582    */
 583
 584   if (is_neg) {
 585     ret -= (postdot / ((float) divider));
 586   } else {
 587     ret += (postdot / ((float) divider));
 588   }
 589   /* ex: ret == 100.033, tada! ... hopefully */
 590
 591   return ret;
 592 }
 593
 594 static int
 595 _handle_spamd_header (struct message *m, int flags, char *buf, int len)
 596 {
 597     char is_spam[6];
 598     char s_str[20], t_str[20];
 599
 600     /* Feb 12 2003 jm: actually, I think sccanf is working fine here ;)
 601      * let's stick with it for this parser.
 602      * May  7 2003 jm: using %f is bad where LC_NUMERIC is "," in the locale.
 603      * work around using our own locale-independent float-parser code.
 604      */
 605     if (sscanf(buf, "Spam: %5s ; %20s / %20s", is_spam, s_str, t_str) == 3)
 606     {
 607         m->score = _locale_safe_string_to_float (s_str, 20);
 608         m->threshold = _locale_safe_string_to_float (t_str, 20);
 609
 610         /* Format is "Spam: x; y / x" */
 611         m->is_spam=strcasecmp("true", is_spam) == 0 ? EX_ISSPAM: EX_NOTSPAM;
 612
 613         if(flags&SPAMC_CHECK_ONLY) {
 614             m->out_len=snprintf (m->out, m->max_len+EXPANSION_ALLOWANCE,
 615                         "%.1f/%.1f\n", m->score, m->threshold);
 616         }
 617         return EX_OK;
 618
 619     } else if(sscanf(buf, "Content-length: %d", &m->content_length) == 1) {
 620         if (m->content_length < 0) {
 621             syslog(LOG_ERR, "spamd responded with bad Content-length '%s'", buf);
 622             return EX_PROTOCOL;
 623         }
 624         return EX_OK;
 625     }
 626
 627     syslog(LOG_ERR, "spamd responded with bad header '%s'", buf);
 628     return EX_PROTOCOL;
 629 }
 630
 631 static int _message_filter(const struct sockaddr *addr,
 632                 const struct hostent *hent, int hent_port, char *username,
 633                 int flags, struct message *m)
 634 {
 635     char buf[8192];
 636     int bufsiz = (sizeof(buf) / sizeof(*buf)) - 4; /* bit of breathing room */
 637     int len, i;
 638     int sock = -1;
 639     char versbuf[20];
 640     float version;
 641     int response;
 642     int failureval;
 643     SSL_CTX* ctx;
 644     SSL* ssl;
 645     SSL_METHOD *meth;
 646
 647     if (flags&SPAMC_USE_SSL) {
 648 #ifdef SPAMC_SSL
 649       SSLeay_add_ssl_algorithms();
 650       meth = SSLv2_client_method();
 651       SSL_load_error_strings();
 652       ctx = SSL_CTX_new(meth);
 653 #else
 654       (void) ssl; (void) meth; (void) ctx;      /* avoid "unused" warnings */
 655       syslog(LOG_ERR, "spamc not built with SSL support");
 656       return EX_SOFTWARE;
 657 #endif
 658     }
 659
 660     m->is_spam=EX_TOOBIG;
 661     if((m->out=malloc(m->max_len+EXPANSION_ALLOWANCE+1))==NULL){
 662         failureval = EX_OSERR; goto failure;
 663     }
 664     m->out_len=0;
 665
 666
 667     /* Build spamd protocol header */
 668     if(flags & SPAMC_CHECK_ONLY)
 669       len=snprintf(buf, bufsiz, "CHECK %s\r\n", PROTOCOL_VERSION);
 670     else if(flags & SPAMC_REPORT_IFSPAM)
 671       len=snprintf(buf, bufsiz, "REPORT_IFSPAM %s\r\n", PROTOCOL_VERSION);
 672     else if(flags & SPAMC_REPORT)
 673       len=snprintf(buf, bufsiz, "REPORT %s\r\n", PROTOCOL_VERSION);
 674     else if(flags & SPAMC_SYMBOLS)
 675       len=snprintf(buf, bufsiz, "SYMBOLS %s\r\n", PROTOCOL_VERSION);
 676     else
 677       len=snprintf(buf, bufsiz, "PROCESS %s\r\n", PROTOCOL_VERSION);
 678
 679     if(len<0 || len >= bufsiz){ free(m->out); m->out=m->msg; m->out_len=m->msg_len; return EX_OSERR; }
 680     if(username!=NULL){
 681         len+=i=snprintf(buf+len, bufsiz-len, "User: %s\r\n", username);
 682         if(i<0 || len >= bufsiz){ free(m->out); m->out=m->msg; m->out_len=m->msg_len; return EX_OSERR; }
 683     }
 684     len+=i=snprintf(buf+len, bufsiz-len, "Content-length: %d\r\n", m->msg_len);
 685     if(i<0 || len >= bufsiz){ free(m->out); m->out=m->msg; m->out_len=m->msg_len; return EX_OSERR; }
 686     len+=i=snprintf(buf+len, bufsiz-len, "\r\n");
 687     if(i<0 || len >= bufsiz){ free(m->out); m->out=m->msg; m->out_len=m->msg_len; return EX_OSERR; }
 688
 689     libspamc_timeout = m->timeout;
 690
 691     if((i=try_to_connect(addr, (struct hostent *) hent,
 692                         hent_port, &sock)) != EX_OK)
 693     {
 694         free(m->out); m->out=m->msg; m->out_len=m->msg_len;
 695         return i;
 696     }
 697
 698     if(flags&SPAMC_USE_SSL) {
 699 #ifdef SPAMC_SSL
 700       ssl = SSL_new(ctx);
 701       SSL_set_fd(ssl, sock);
 702       SSL_connect(ssl);
 703 #endif
 704     }
 705
 706     /* Send to spamd */
 707     if(flags&SPAMC_USE_SSL) {
 708 #ifdef SPAMC_SSL
 709       SSL_write(ssl, buf, len);
 710       SSL_write(ssl, m->msg, m->msg_len);
 711 #endif
 712     } else {
 713       full_write(sock, (unsigned char *) buf, len);
 714       full_write(sock, (unsigned char *) m->msg, m->msg_len);
 715       shutdown(sock, SHUT_WR);
 716     }
 717
 718     /* ok, now read and parse it.  SPAMD/1.2 line first... */
 719     failureval = _spamc_read_full_line (m, flags, ssl, sock, buf, &len, bufsiz);
 720     if (failureval != EX_OK) { goto failure; }
 721
 722     if(sscanf(buf, "SPAMD/%s %d %*s", versbuf, &response)!=2) {
 723         syslog(LOG_ERR, "spamd responded with bad string '%s'", buf);
 724         failureval = EX_PROTOCOL; goto failure;
 725     }
 726
 727     version = _locale_safe_string_to_float (versbuf, 20);
 728     if (version < 1.0) {
 729         syslog(LOG_ERR, "spamd responded with bad version string '%s'", versbuf);
 730         failureval = EX_PROTOCOL; goto failure;
 731     }
 732
 733     m->score = 0;
 734     m->threshold = 0;
 735     m->is_spam = EX_TOOBIG;
 736     while (1) {
 737         failureval = _spamc_read_full_line (m, flags, ssl, sock, buf, &len, bufsiz);
 738         if (failureval != EX_OK) { goto failure; }
 739
 740         if (len == 0 && buf[0] == '\0') {
 741             break;      /* end of headers */
 742         }
 743
 744         if (_handle_spamd_header(m, flags, buf, len) < 0) {
 745             failureval = EX_PROTOCOL; goto failure;
 746         }
 747     }
 748
 749     len = 0;            /* overwrite those headers */
 750
 751     if (flags&SPAMC_CHECK_ONLY) {
 752       close(sock); sock = -1;
 753       if (m->is_spam == EX_TOOBIG) {
 754             /* We should have gotten headers back... Damnit. */
 755             failureval = EX_PROTOCOL; goto failure;
 756       }
 757       return EX_OK;
 758     }
 759     else {
 760         m->is_spam=EX_OUTPUTMESSAGE;
 761         if (m->content_length < 0) {
 762             /* should have got a length too. */
 763             failureval = EX_PROTOCOL; goto failure;
 764         }
 765
 766         if (flags&SPAMC_USE_SSL) {
 767           len = ssl_timeout_read (ssl, m->out+m->out_len,
 768                      m->max_len+EXPANSION_ALLOWANCE+1-m->out_len);
 769         } else{
 770           len = full_read (sock, (unsigned char *) m->out+m->out_len,
 771                      m->max_len+EXPANSION_ALLOWANCE+1-m->out_len,
 772                      m->max_len+EXPANSION_ALLOWANCE+1-m->out_len);
 773         }
 774
 775
 776         if(len+m->out_len>m->max_len+EXPANSION_ALLOWANCE){
 777             failureval = EX_TOOBIG; goto failure;
 778         }
 779         m->out_len+=len;
 780
 781         shutdown(sock, SHUT_RD);
 782         close(sock); sock = -1;
 783     }
 784     libspamc_timeout = 0;
 785
 786     if(m->out_len!=m->content_length) {
 787         syslog(LOG_ERR, "failed sanity check, %d bytes claimed, %d bytes seen",
 788                                 m->content_length, m->out_len);
 789         failureval = EX_PROTOCOL; goto failure;
 790     }
 791
 792     return EX_OK;
 793
 794 failure:
 795     free(m->out); m->out=m->msg; m->out_len=m->msg_len;
 796     if (sock != -1) {
 797       close(sock);
 798     }
 799     libspamc_timeout = 0;
 800
 801     if(flags&SPAMC_USE_SSL) {
 802 #ifdef SPAMC_SSL
 803       SSL_free(ssl);
 804       SSL_CTX_free(ctx);
 805 #endif
 806     }
 807     return failureval;
 808 }
 809
 810 static int _lookup_host(const char *hostname, struct hostent *out_hent)
 811 {
 812     struct hostent *hent = NULL;
 813     int origherr;
 814
 815     /* no need to try using inet_addr(), gethostbyname() will do that */
 816
 817     if (NULL == (hent = gethostbyname(hostname))) {
 818         origherr = h_errno;     /* take a copy before syslog() */
 819         syslog (LOG_ERR, "gethostbyname(%s) failed: h_errno=%d",
 820                 hostname, origherr);
 821         switch(origherr)
 822         {
 823         case HOST_NOT_FOUND:
 824         case NO_ADDRESS:
 825         case NO_RECOVERY:
 826                   return EX_NOHOST;
 827         case TRY_AGAIN:
 828                   return EX_TEMPFAIL;
 829                 default:
 830                   return EX_OSERR;
 831         }
 832     }
 833
 834     memcpy (out_hent, hent, sizeof(struct hostent));
 835
 836     return EX_OK;
 837 }
 838
 839 int message_process(const char *hostname, int port, char *username, int max_size, int in_fd, int out_fd, const int flags){
 840     struct hostent hent;
 841     int ret;
 842     struct message m;
 843
 844     m.type=MESSAGE_NONE;
 845
 846     ret=lookup_host_for_failover(hostname, &hent);
 847     if(ret!=EX_OK) goto FAIL;
 848
 849     m.max_len=max_size;
 850     ret=message_read(in_fd, flags, &m);
 851     if(ret!=EX_OK) goto FAIL;
 852     ret=message_filter_with_failover(&hent, port, username, flags, &m);
 853     if(ret!=EX_OK) goto FAIL;
 854     if(message_write(out_fd, &m)<0) goto FAIL;
 855     if(m.is_spam!=EX_TOOBIG) {
 856        message_cleanup(&m);
 857        return m.is_spam;
 858     }
 859     message_cleanup(&m);
 860     return ret;
 861
 862 FAIL:
 863    if(flags&SPAMC_CHECK_ONLY){
 864        full_write(out_fd, (unsigned char *) "0/0\n", 4);
 865        message_cleanup(&m);
 866        return EX_NOTSPAM;
 867    } else {
 868        message_dump(in_fd, out_fd, &m);
 869        message_cleanup(&m);
 870        return ret;
 871     }
 872 }
 873
 874 void message_cleanup(struct message *m) {
 875    if (m->out != NULL && m->out != m->raw) free(m->out);
 876    if (m->raw != NULL) free(m->raw);
 877    clear_message(m);
 878 }
 879
 880 /* Aug 14, 2002 bj: Obsolete! */
 881 int process_message(const char *hostname, int port, char *username, int max_size, int in_fd, int out_fd, const int my_check_only, const int my_safe_fallback){
 882     int flags;
 883
 884     flags=SPAMC_RAW_MODE;
 885     if(my_check_only) flags|=SPAMC_CHECK_ONLY;
 886     if(my_safe_fallback) flags|=SPAMC_SAFE_FALLBACK;
 887
 888     return message_process(hostname, port, username, max_size, in_fd, out_fd, flags);
 889 }
 890
 891 /* public APIs, which call into the static code and enforce sockaddr-OR-hostent
 892  * conventions */
 893
 894 int lookup_host(const char *hostname, int port, struct sockaddr *out_addr)
 895 {
 896   struct sockaddr_in *addr = (struct sockaddr_in *)out_addr;
 897   struct hostent hent;
 898   int ret;
 899
 900   memset(&out_addr, 0, sizeof(out_addr));
 901   addr->sin_family=AF_INET;
 902   addr->sin_port=htons(port);
 903   ret = _lookup_host(hostname, &hent);
 904   memcpy (&(addr->sin_addr), hent.h_addr, sizeof(addr->sin_addr));
 905   return ret;
 906 }
 907
 908 int lookup_host_for_failover(const char *hostname, struct hostent *hent) {
 909   return _lookup_host(hostname, hent);
 910 }
 911
 912 int message_filter(const struct sockaddr *addr, char *username, int flags,
 913                 struct message *m)
 914 { return _message_filter (addr, NULL, 0, username, flags, m); }
 915
 916 int message_filter_with_failover (const struct hostent *hent, int port,
 917                 char *username, int flags, struct message *m)
 918 { return _message_filter (NULL, hent, port, username, flags, m); }
 919