Attachment #1630 for bug #2862

View | Details | Raw Unified | Return to bug 2862
Collapse All | Expand All

Lines 149-158 Link Here

(-)Makefile.PL (-14 / +28 lines)
149	my @datafiles = map { s,^rules/,,; $_ } (<rules/*.cf>);	149	my @datafiles = map { s,^rules/,,; $_ } (<rules/*.cf>);
150	my $datafiles = join(' ', (grep { /^[0-6][0-9]_/ } @datafiles), qw(user_prefs.template triplets.txt languages));	150	my $datafiles = join(' ', (grep { /^[0-6][0-9]_/ } @datafiles), qw(user_prefs.template triplets.txt languages));
151		151
152	# Only build spamd and spamc on non-Windows platforms	152	# Only build spamd on non-Windows platforms
153	my @SPAMD_EXE_FILES = ();	153	my @SPAMD_EXE_FILES = ();
154	if (!RUNNING_ON_WINDOWS) {	154	if (!RUNNING_ON_WINDOWS) {
155	@SPAMD_EXE_FILES = ('spamd/spamc$(EXE_EXT)', 'spamd/spamd');	155	@SPAMD_EXE_FILES = ('spamd/spamc$(EXE_EXT)', 'spamd/spamd');
		156	} else {
		157	@SPAMD_EXE_FILES = ('spamd/spamc$(EXE_EXT)');
156	}	158	}
157		159
158	# See lib/ExtUtils/MakeMaker.pm for details of how to influence	160	# See lib/ExtUtils/MakeMaker.pm for details of how to influence
Lines 208-214 Link Here
208	'spamd/libspamc.so', 'spamd/libsslspamc.so',	210	'spamd/libspamc.so', 'spamd/libsslspamc.so',
209	'spamd/binaries.mk', 'spamd/config.h', 'spamd/config.status',	211	'spamd/binaries.mk', 'spamd/config.h', 'spamd/config.status',
210	'spamd/config.cache', 'spamd/config.log', 'spamd/autom4te.cache',	212	'spamd/config.cache', 'spamd/config.log', 'spamd/autom4te.cache',
211	'qmail/qmail-spamc',	213	'qmail/qmail-spamc', 'spamd/.o', 'spamd/.obj',
212	't/do_net', 't/log',	214	't/do_net', 't/log',
213	)	215	)
214	},	216	},
Lines 847-852 Link Here
847	}	848	}
848	}	849	}
849		850
		851	push(@code, "PREPROCESS = \$(PERL) build/preprocessor");
		852
		853	my($repository);
		854	$repository = uc($SELF->{INSTALLDIRS}) \|\| 'SITE';
		855
		856	foreach my $macro (qw(PREFIX SYSCONFDIR)) {
		857	push(@code, macro_def('I_' . $macro,
		858	macro_ref($repository . $macro)));
		859	}
		860
850	clean_MY_globals($self);	861	clean_MY_globals($self);
851	return join("\n", @code);	862	return join("\n", @code);
852	}	863	}
Lines 859-868 Link Here
859	my($repository);	870	my($repository);
860	$repository = uc($SELF->{INSTALLDIRS}) \|\| 'SITE';	871	$repository = uc($SELF->{INSTALLDIRS}) \|\| 'SITE';
861		872
862	foreach my $macro (qw(PREFIX SYSCONFDIR)) {
863	push(@code, macro_def('I_' . $macro,
864	macro_ref($repository . $macro)));
865	}
866	foreach my $macro (qw(DATA CONF LIB)) {	873	foreach my $macro (qw(DATA CONF LIB)) {
867	push(@code, macro_def('I_' . $macro . 'DIR',	874	push(@code, macro_def('I_' . $macro . 'DIR',
868	macro_ref('INSTALL' . repository($repository) . $macro)));	875	macro_ref('INSTALL' . repository($repository) . $macro)));
Lines 881-888 Link Here
881		888
882	$code .= <<' EOD';	889	$code .= <<' EOD';
883		890
884	PREPROCESS = $(PERL) build/preprocessor
885
886	FIXVARS = -Mvars \	891	FIXVARS = -Mvars \
887	-DVERSION="$(VERSION)" \	892	-DVERSION="$(VERSION)" \
888	-DPREFIX="$(I_PREFIX)" \	893	-DPREFIX="$(I_PREFIX)" \
Lines 911-934 Link Here
911	spamd/libspamc.so: spamd/binaries.mk $(SPAMC_SOURCES)	916	spamd/libspamc.so: spamd/binaries.mk $(SPAMC_SOURCES)
912	$(MAKE) -f spamd/binaries.mk $@	917	$(MAKE) -f spamd/binaries.mk $@
913		918
914	spamd/libspamc.dll: spamd/binaries.mk $(SPAMC_SOURCES)
915	$(MAKE) -f spamd/binaries.mk $@
916
917	spamd/spamc$(EXE_EXT): spamd/binaries.mk $(SPAMC_SOURCES)	919	spamd/spamc$(EXE_EXT): spamd/binaries.mk $(SPAMC_SOURCES)
918	$(MAKE) -f spamd/binaries.mk $@	920	$(MAKE) -f spamd/binaries.mk $@
919		921
920	spamd/libsslspamc.so: spamd/binaries.mk $(SPAMC_SOURCES)	922	spamd/libsslspamc.so: spamd/binaries.mk $(SPAMC_SOURCES)
921	$(MAKE) -f spamd/binaries.mk $@	923	$(MAKE) -f spamd/binaries.mk $@
922		924
923	spamd/libsslspamc.dll: spamd/binaries.mk $(SPAMC_SOURCES)
924	$(MAKE) -f spamd/binaries.mk $@
925
926	qmail/qmail-spamc: spamd/binaries.mk $(SPAMC_SOURCES)	925	qmail/qmail-spamc: spamd/binaries.mk $(SPAMC_SOURCES)
927	$(MAKE) -f spamd/binaries.mk $@	926	$(MAKE) -f spamd/binaries.mk $@
		927	EOD
928		928
		929	if (!($^O =~ /^(?:mswin\|dos\|os2)/oi)) {
		930	$code .= <<' EOD';
929	spamd/binaries.mk: spamd/configure	931	spamd/binaries.mk: spamd/configure
930	cd spamd; ./configure --prefix="$(I_PREFIX)" --sysconfdir="$(I_SYSCONFDIR)" --datadir="$(I_DATADIR)" --enable-ssl="$(ENABLE_SSL)"	932	cd spamd; ./configure --prefix="$(I_PREFIX)" --sysconfdir="$(I_SYSCONFDIR)" --datadir="$(I_DATADIR)" --enable-ssl="$(ENABLE_SSL)"
		933	EOD
931		934
		935	} else {
		936	$code .= <<' EOD';
		937	spamd/binaries.mk: spamd/win32.config spamd/win32.mak
		938	$(PERL) -MFile::SPec -MFile::Copy \
		939	-e "copy(q{spamd/win32.config}, q{spamd/config.h}); copy(q{spamd/win32.mak}, q{spamd/binaries.mk});"
		940	EOD
		941
		942	}
		943
		944	$code .= <<' EOD';
932	conf__install:	945	conf__install:
933	-$(MKPATH) $(B_CONFDIR)	946	-$(MKPATH) $(B_CONFDIR)
934	$(PERL) -MFile::Spec -MFile::Copy \	947	$(PERL) -MFile::Spec -MFile::Copy \




#include "libspamc.h"
#include "utils.h"

#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#ifdef _WIN32
/* simple macro that works for single strings without %m */
#define syslog(x, y) fprintf(stderr, #y "\n")
#define strcasecmp stricmp
#define sleep Sleep
#else
#include <syslog.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/un.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#endif

#ifdef HAVE_SYSEXITS_H
#include <sysexits.h>

	}

#ifdef DO_CONNECT_DEBUG_SYSLOGS
#ifndef _WIN32
	syslog (DEBUG_LEVEL, "dbg: create socket(%s)", typename);
#else
	fprintf (stderr, "dbg: create socket(%s)\n", typename);
#endif
#endif

	if ( (*psock = socket(type, SOCK_STREAM, proto))
#ifndef _WIN32
         < 0
#else
         == INVALID_SOCKET
#endif
         ) {
	int	origerr;

		/*--------------------------------------------------------

		 * this is pretty much fatal. Translate the error reason
		 * into something the user can understand.
		 */
#ifndef _WIN32
		origerr = errno;    /* take a copy before syslog() */

		syslog (LOG_ERR, "socket(%s) to spamd failed: %m", typename);
#else
      origerr = WSAGetLastError();
      printf ("socket(%s) to spamd failed: %d\n", typename, origerr);
#endif

		switch (origerr)
		{

		if ( type == PF_INET
		 &&  setsockopt(*psock, 0, TCP_NODELAY, &one, sizeof one) != 0 )
		{
          int origerrno;
#ifndef _WIN32
          origerr = errno;
#else
          origerrno = WSAGetLastError();
#endif
			switch(origerr)
			{
			  case EBADF:
			  case ENOTSOCK:
			  case ENOPROTOOPT:
			  case EFAULT:
#ifndef _WIN32
				syslog(LOG_ERR,
				   "setsockopt(TCP_NODELAY) failed: %m");
#else
				fprintf(stderr,
				   "setsockopt(TCP_NODELAY) failed: %d\n", origerr));
#endif
				closesocket (*psock);
				return EX_SOFTWARE;

			  default:

static int
try_to_connect_unix (struct transport *tp, int *sockptr)
{
#ifndef _WIN32
int mysock, status, origerr;
struct sockaddr_un addrbuf;
int ret;


	syslog(LOG_ERR, "connect(AF_UNIX) to spamd %s failed: %m",
		addrbuf.sun_path);
	closesocket(mysock);
	close(mysock);

	return translate_connect_errno(origerr);
#else
    return EX_OSERR;
#endif
}

/*

#ifdef DO_CONNECT_DEBUG_SYSLOGS
	for (numloops = 0; numloops < tp->nhosts; numloops++)
	{
#ifndef _WIN32
		syslog(LOG_ERR,
			"dbg: %d/%d: %s",
#else
		fprintf(stderr,
			"dbg: %d/%d: %s\n",
#endif
			numloops+1, tp->nhosts, inet_ntoa(tp->hosts[numloops]));
	}
#endif

		ipaddr = inet_ntoa(addrbuf.sin_addr);

#ifdef DO_CONNECT_DEBUG_SYSLOGS
#ifndef _WIN32
		syslog(DEBUG_LEVEL,
			"dbg: connect(AF_INET) to spamd at %s (try #%d of %d)",
#else
		fprintf(stderr,
			"dbg: connect(AF_INET) to spamd at %s (try #%d of %d\)\n",
#endif
			ipaddr,
			numloops+1,
			MAX_CONNECT_RETRIES);


		if (status != 0)
		{
#ifndef _WIN32
          origerr = errno;
			syslog (LOG_ERR,
			"connect(AF_INET) to spamd at %s failed, retrying (#%d of %d): %m",
				ipaddr, numloops+1, MAX_CONNECT_RETRIES);
#else
          origerr = WSAGetLastError();
          fprintf (stderr,
                  "connect(AF_INET) to spamd at %s failed, retrying (#%d of %d): %d\n",
                  ipaddr, numloops+1, MAX_CONNECT_RETRIES, origerr);
#endif
          closesocket(mysock);

			sleep(CONNECT_RETRY_SLEEP);
		}
		else
		{
#ifdef DO_CONNECT_DEBUG_SYSLOGS
#ifndef _WIN32
			syslog(DEBUG_LEVEL,
				"dbg: connect(AF_INET) to spamd at %s done",
				ipaddr);
#else
			fprintf(stderr,
				"dbg: connect(AF_INET) to spamd at %s done\n",
				ipaddr);
#endif
#endif
			*sockptr = mysock;


		}
	}

#ifndef _WIN32
	syslog (LOG_ERR,
		"connection attempt to spamd aborted after %d retries",
#else
	fprintf(stderr,
		"connection attempt to spamd aborted after %d retries\n",
#endif
		MAX_CONNECT_RETRIES);

	return translate_connect_errno(origerr);

message_read_raw(int fd, struct message *m){
    clear_message(m);
    if((m->raw=malloc(m->max_len+1))==NULL) return EX_OSERR;
    m->raw_len=full_read(fd, 1, m->raw, m->max_len+1, m->max_len+1);
    if(m->raw_len<=0){
        free(m->raw); m->raw=NULL; m->raw_len=0;
        return EX_IOERR;

    if((m->raw=malloc(m->max_len+1))==NULL) return EX_OSERR;

    /* Find the DATA line */
    m->raw_len=full_read(fd, 1, m->raw, m->max_len+1, m->max_len+1);
    if(m->raw_len<=0){
        free(m->raw); m->raw=NULL; m->raw_len=0;
        return EX_IOERR;

        return message_read_bsmtp(fd, m);

      default:
#ifndef _WIN32
        syslog(LOG_ERR, "message_read: Unknown mode %d",
#else
        fprintf(stderr, "message_read: Unknown mode %d\n",
#endif
			flags&SPAMC_MODE_MASK);
        return EX_USAGE;
    }
}


    if (m->priv->flags&SPAMC_CHECK_ONLY) {
	if(m->is_spam==EX_ISSPAM || m->is_spam==EX_NOTSPAM){
	    return full_write(fd, 1, m->out, m->out_len);

	} else {
#ifndef _WIN32
	    syslog(LOG_ERR, "oops! SPAMC_CHECK_ONLY is_spam: %d", m->is_spam);
#else
	    fprintf(stderr, "oops! SPAMC_CHECK_ONLY is_spam: %d\n", m->is_spam);
#endif
	    return -1;
	}
    }

    /* else we're not in CHECK_ONLY mode */
    switch(m->type){
      case MESSAGE_NONE:
        syslog(LOG_ERR, "Cannot write this message, it's MESSAGE_NONE!");
        return -1;

      case MESSAGE_ERROR:
        return full_write(fd, 1, m->raw, m->raw_len);

      case MESSAGE_RAW:
        return full_write(fd, 1, m->out, m->out_len);

      case MESSAGE_BSMTP:
        total=full_write(fd, 1, m->pre, m->pre_len);
        for(i=0; i<m->out_len; ){
	    jlimit = (off_t) (sizeof(buffer)/sizeof(*buffer)-4);
            for(j=0; i < (off_t) m->out_len &&

                    buffer[j++]=m->out[i++];
                }
            }
            total+=full_write(fd, 1, buffer, j);
        }
        return total+full_write(fd, 1, m->post, m->post_len);

      default:
#ifndef _WIN32
        syslog(LOG_ERR, "Unknown message type %d", m->type);
#else
        fprintf(stderr, "Unknown message type %d\n", m->type);
#endif
        return -1;
    }
}

    if(m!=NULL && m->type!=MESSAGE_NONE) {
        message_write(out_fd, m);
    }
    while((bytes=full_read(in_fd, 1, buf, 8192, 8192))>0){
        if (bytes!=full_write(out_fd, 1, buf, bytes)) {
#ifndef _WIN32
            syslog(LOG_ERR, "oops! message_dump of %d returned different", bytes);
#else
            fprintf(stderr, "oops! message_dump of %d returned different\n", bytes);
#endif
        }
    }
}

	if(flags&SPAMC_USE_SSL) {
	  bytesread = ssl_timeout_read (ssl, buf+len, 1);
	} else {
	  bytesread = fd_timeout_read (sock, 0, buf+len, 1);
	}

        if(buf[len]=='\n') {

        }
    }

#ifndef _WIN32
    syslog(LOG_ERR, "spamd responded with line of %d bytes, dying", len);
#else
    fprintf(stderr, "spamd responded with line of %d bytes, dying\n", len);
#endif
    failureval = EX_TOOBIG;

failure:

	m->score = _locale_safe_string_to_float (s_str, 20);
	m->threshold = _locale_safe_string_to_float (t_str, 20);

	/* set bounds on these to ensure no buffer overflow in the sprintf */
	if (m->score > 1e10)
	  m->score = 1e10;
	else if (m->score < -1e10)
	  m->score = -1e10;
	if (m->threshold > 1e10)
	  m->threshold = 1e10;
	else if (m->threshold < -1e10)
	  m->threshold = -1e10;

	/* Format is "Spam: x; y / x" */
	m->is_spam=strcasecmp("true", is_spam) == 0 ? EX_ISSPAM: EX_NOTSPAM;

	if(flags&SPAMC_CHECK_ONLY) {
	    m->out_len=sprintf (m->out,
			"%.1f/%.1f\n", m->score, m->threshold);
	}
	else if ((flags & SPAMC_REPORT_IFSPAM && m->is_spam == EX_ISSPAM)
		|| (flags & SPAMC_REPORT))
	{
	    m->out_len=sprintf (m->out,
			"%.1f/%.1f\n", m->score, m->threshold);
	}
	return EX_OK;

    } else if(sscanf(buf, "Content-length: %d", &m->content_length) == 1) {
	if (m->content_length < 0) {
#ifndef _WIN32
	    syslog(LOG_ERR, "spamd responded with bad Content-length '%s'", buf);
#else
	    fprintf(stderr, "spamd responded with bad Content-length '%s'\n", buf);
#endif
	    return EX_PROTOCOL;
	}
	return EX_OK;
    }

#ifndef _WIN32
    syslog(LOG_ERR, "spamd responded with bad header '%s'", buf);
#else
    fprintf(stderr, "spamd responded with bad header '%s'\n", buf);
#endif
    return EX_PROTOCOL;
}


    int response;
    int failureval;
    SSL_CTX* ctx;
    SSL* ssl = NULL;
    SSL_METHOD *meth;

    if (flags&SPAMC_USE_SSL) {


    /* Build spamd protocol header */
    if(flags & SPAMC_CHECK_ONLY) 
	  strcpy(buf, "CHECK ");
    else if(flags & SPAMC_REPORT_IFSPAM)
      strcpy(buf, "REPORT_IFSPAM ");
    else if(flags & SPAMC_REPORT) 
      strcpy(buf, "REPORT ");
    else if(flags & SPAMC_SYMBOLS) 
      strcpy(buf, "SYMBOLS ");
    else
      strcpy(buf, "PROCESS ");

    len = strlen(buf);
    if(len+strlen(PROTOCOL_VERSION)+2 >= bufsiz){ free(m->out); m->out=m->msg; m->out_len=m->msg_len; return EX_OSERR; }

    strcat(buf, PROTOCOL_VERSION);
    strcat(buf, "\r\n");
    len = strlen(buf);

    if(username!=NULL) {
      if (strlen(username)+8 >= (bufsiz - len)) { free(m->out); m->out=m->msg; m->out_len=m->msg_len; return EX_OSERR; }
      strcpy(buf+len, "User: ");
      strcat(buf+len, username);
      strcat(buf+len, "\r\n");
      len += strlen(buf+len);
    }
    if ((m->msg_len > 9999999) || ((len + 27) >= (bufsiz - len))) {
      free(m->out); m->out=m->msg; m->out_len=m->msg_len;
      return EX_OSERR;
    }
    len += sprintf(buf+len, "Content-length: %d\r\n\r\n", m->msg_len);

    libspamc_timeout = m->timeout;


    if ( rc != EX_OK )
    {
        free(m->out); m->out=m->msg; m->out_len=m->msg_len;
        return EX_OSERR;
    }

    if(flags&SPAMC_USE_SSL) {

      SSL_write(ssl, m->msg, m->msg_len);
#endif
    } else {
      full_write(sock, 0, buf, len);
      full_write(sock, 0, m->msg, m->msg_len);
      shutdown(sock, SHUT_WR);
    }


    if (failureval != EX_OK) { goto failure; }

    if(sscanf(buf, "SPAMD/%18s %d %*s", versbuf, &response)!=2) {
#ifndef _WIN32
	syslog(LOG_ERR, "spamd responded with bad string '%s'", buf);
#else
	fprintf(stderr, "spamd responded with bad string '%s'\n", buf);
#endif
	failureval = EX_PROTOCOL; goto failure;
    }

    versbuf[19] = '\0';
    version = _locale_safe_string_to_float (versbuf, 20);
    if (version < 1.0) {
#ifndef _WIN32
	syslog(LOG_ERR, "spamd responded with bad version string '%s'", versbuf);
#else
	fprintf(stderr, "spamd responded with bad version string '%s'\n", versbuf);
#endif
	failureval = EX_PROTOCOL; goto failure;
    }


    len = 0;		/* overwrite those headers */

    if (flags&SPAMC_CHECK_ONLY) {
	closesocket(sock); sock = -1;
	if (m->is_spam == EX_TOOBIG) {
	      /* We should have gotten headers back... Damnit. */
	      failureval = EX_PROTOCOL; goto failure;

		     m->max_len+EXPANSION_ALLOWANCE+1-m->out_len,
		     m->max_len+EXPANSION_ALLOWANCE+1-m->out_len);
	} else{
	  len = full_read (sock, 0, m->out+m->out_len,
		     m->max_len+EXPANSION_ALLOWANCE+1-m->out_len,
		     m->max_len+EXPANSION_ALLOWANCE+1-m->out_len);
	}

	m->out_len+=len;

	shutdown(sock, SHUT_RD);
	closesocket(sock); sock = -1;
    }
    libspamc_timeout = 0;

    if(m->out_len!=m->content_length) {
#ifndef _WIN32
        syslog(LOG_ERR, "failed sanity check, %d bytes claimed, %d bytes seen",
#else
        fprintf(stderr, "failed sanity check, %d bytes claimed, %d bytes seen\n",
#endif
				m->content_length, m->out_len);
	failureval = EX_PROTOCOL; goto failure;
    }

failure:
    free(m->out); m->out=m->msg; m->out_len=m->msg_len;
    if (sock != -1) {
      closesocket(sock);
    }
    libspamc_timeout = 0;



FAIL:
   if(flags&SPAMC_CHECK_ONLY){
       full_write(out_fd, 1, "0/0\n", 4);
       message_cleanup(&m);
       return EX_NOTSPAM;
   } else {

struct hostent *hp = 0;
char           **addrp;

#ifdef _WIN32
    // Start Winsock up
    WSADATA wsaData;
    int nCode;
    if ((nCode = WSAStartup(MAKEWORD(1, 1), &wsaData)) != 0) {
      printf("WSAStartup() returned error code %d\n", nCode);
      return EX_OSERR;
    }

#endif

	assert(tp != 0);

	switch ( tp->type )
	{
#ifndef _WIN32
	  case TRANSPORT_UNIX:
		assert(tp->socketpath != 0);
		return EX_OK;
#endif
	  case TRANSPORT_LOCALHOST:
		tp->hosts[0].s_addr = inet_addr("127.0.0.1");
		tp->nhosts          = 1;

		{
		int	origherr = h_errno;  /* take a copy before syslog() */

#ifndef _WIN32
			syslog (LOG_ERR, "gethostbyname(%s) failed: h_errno=%d",
#else
			fprintf (stderr, "gethostbyname(%s) failed: h_errno=%d\n",
#endif
				tp->hostname, origherr);
			switch (origherr)
			{

		for (addrp = hp->h_addr_list; *addrp; addrp++)
		{
			if (tp->nhosts >= TRANSPORT_MAX_HOSTS-1) {
#ifndef _WIN32
				syslog (LOG_ERR, "hit limit of %d hosts, ignoring remainder", TRANSPORT_MAX_HOSTS-1);
#else
				fprintf (stderr, "hit limit of %d hosts, ignoring remainder\n", TRANSPORT_MAX_HOSTS-1);
#endif
				break;
			}


  char inputstr[99], cmpbuf1[99], cmpbuf2[99];
  float output;

  /* sprintf instead of snprintf is safe here because it is only a controlled test */
  sprintf (inputstr, "%f", input);
  output = _locale_safe_string_to_float (inputstr, 99);
  if (input == output) { return; }

  /* could be a rounding error.  print as string and compare those */
  sprintf (cmpbuf1, "%f", input);
  sprintf (cmpbuf2, "%f", output);
  if (!strcmp (cmpbuf1, cmpbuf2)) { return; }

  printf ("FAIL: input=%f != output=%f\n", input, output);




#ifndef LIBSPAMC_H
#define LIBSPAMC_H 1

#ifdef _WIN32
#include <winsock.h>
#else
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#endif
#include <stdio.h>

#ifdef _WIN32
#define EX_OK        0
#define EX_USAGE        64
#define EX_DATAERR      65
#define EX_NOINPUT      66
#define EX_NOUSER       67
#define EX_NOHOST       68
#define EX_UNAVAILABLE  69
#define EX_SOFTWARE     70
#define EX_OSERR        71
#define EX_OSFILE       72
#define EX_CANTCREAT    73
#define EX_IOERR        74
#define EX_TEMPFAIL     75
#define EX_PROTOCOL     76
#define EX_NOPERM       77
#define EX_CONFIG       78

#define STDIN_FILENO 0
#define STDOUT_FILENO 1

#endif

#define EX_NOTSPAM		  0
#define EX_ISSPAM		  1

Lines 9-25 Link Here

(-)spamd/spamc.c (-24 / +57 lines)
9	#include "libspamc.h"	8	#include "libspamc.h"
10	#include "utils.h"	9	#include "utils.h"
11		10
12	#include <unistd.h>
13	#include <stdlib.h>	11	#include <stdlib.h>
14	#include <stdio.h>	12	#include <stdio.h>
15	#include <string.h>	13	#include <string.h>
		14	#ifdef _WIN32
		15	#define syslog(x, y) fprintf(stderr, #y "\n")
		16	#else
16	#include <syslog.h>	17	#include <syslog.h>
		18	#include <unistd.h>
		19	#include <netdb.h>
17	#include <sys/types.h>	20	#include <sys/types.h>
18	#include <sys/socket.h>	21	#include <sys/socket.h>
19	#include <netinet/in.h>	22	#include <netinet/in.h>
20	#include <netinet/tcp.h>	23	#include <netinet/tcp.h>
21	#include <netdb.h>
22	#include <arpa/inet.h>	24	#include <arpa/inet.h>
		25	#endif
23		26
24	#ifdef HAVE_SYSEXITS_H	27	#ifdef HAVE_SYSEXITS_H
25	#include <sysexits.h>	28	#include <sysexits.h>
Lines 48-60 Link Here
48	\|\| (defined(__sgi)) /* IRIX */ \	51	\|\| (defined(__sgi)) /* IRIX */ \
49	\|\| (defined(__osf__)) /* Digital UNIX */ \	52	\|\| (defined(__osf__)) /* Digital UNIX */ \
50	\|\| (defined(hpux) \|\| defined(__hpux)) /* HPUX */ \	53	\|\| (defined(hpux) \|\| defined(__hpux)) /* HPUX */ \
51	\|\| (defined(_WIN32) \|\| defined(__CYGWIN__)) /* CygWin, Win32 */	54	\|\| (defined(__CYGWIN__)) /* CygWin, Win32 */
52		55
53	extern int optind;	56	extern int optind;
54	extern char *optarg;	57	extern char *optarg;
55		58
56	#endif	59	#endif
57		60
		61	#ifdef _WIN32
		62	#include "getopt.h"
		63	char* __progname = "spamc";
		64	#endif
		65
		66
58	/* safe fallback defaults to on now - CRH */	67	/* safe fallback defaults to on now - CRH */
59	int flags = SPAMC_RAW_MODE \| SPAMC_SAFE_FALLBACK;	68	int flags = SPAMC_RAW_MODE \| SPAMC_SAFE_FALLBACK;
60		69
Lines 93-99 Link Here
93	{	102	{
94	int opt, i, j;	103	int opt, i, j;
95		104
96	while(-1 != (opt = getopt(argc,argv,"-BcrRd:e:fhyp:t:s:u:xSHU:")))	105	while(-1 != (opt = getopt(argc,argv,
		106	#ifndef _WIN32
		107	"-BcrRd:e:fhyp:t:s:u:xSHU:"
		108	#else
		109	"-BcrRd:fhyp:t:s:u:xSH"
		110	#endif
		111	)))
97	{	112	{
98	switch(opt)	113	switch(opt)
99	{	114	{
Lines 102-113 Link Here
102	flags \|= SPAMC_RANDOMIZE_HOSTS;	117	flags \|= SPAMC_RANDOMIZE_HOSTS;
103	break;	118	break;
104	}	119	}
		120	#ifndef _WIN32
105	case 'U':	121	case 'U':
106	{	122	{
107	ptrn->type = TRANSPORT_UNIX;	123	ptrn->type = TRANSPORT_UNIX;
108	ptrn->socketpath = optarg;	124	ptrn->socketpath = optarg;
109	break;	125	break;
110	}	126	}
		127	#endif
111	case 'B':	128	case 'B':
112	{	129	{
113	flags = (flags & ~SPAMC_MODE_MASK) \| SPAMC_BSMTP_MODE;	130	flags = (flags & ~SPAMC_MODE_MASK) \| SPAMC_BSMTP_MODE;
Lines 139-144 Link Here
139	ptrn->hostname = optarg; /* fix the ptr to point to this string */	156	ptrn->hostname = optarg; /* fix the ptr to point to this string */
140	break;	157	break;
141	}	158	}
		159	#ifndef _WIN32
142	case 'e':	160	case 'e':
143	{	161	{
144	if((exec_argv=malloc(sizeof(exec_argv)(argc-optind+2)))==NULL)	162	if((exec_argv=malloc(sizeof(exec_argv)(argc-optind+2)))==NULL)
Lines 149-154 Link Here
149	exec_argv[i]=NULL;	167	exec_argv[i]=NULL;
150	return EX_OK;	168	return EX_OK;
151	}	169	}
		170	#endif
152	case 'p':	171	case 'p':
153	{	172	{
154	ptrn->port = atoi(optarg);	173	ptrn->port = atoi(optarg);
Lines 190-195 Link Here
190	syslog (LOG_ERR, "invalid usage");	209	syslog (LOG_ERR, "invalid usage");
191	/* NOTE: falls through to usage case below... */	210	/* NOTE: falls through to usage case below... */
192	}	211	}
		212	#ifndef _WIN32
		213	case 'e':
		214	#endif
193	case 'h':	215	case 'h':
194	case 1:	216	case 1:
195	{	217	{
Lines 210-215 Link Here
210	*fd=STDOUT_FILENO;	232	*fd=STDOUT_FILENO;
211	return;	233	return;
212	}	234	}
		235	#ifndef _WIN32
213	if(pipe(fds)){	236	if(pipe(fds)){
214	syslog(LOG_ERR, "pipe creation failed: %m");	237	syslog(LOG_ERR, "pipe creation failed: %m");
215	exit(EX_OSERR);	238	exit(EX_OSERR);
Lines 237-242 Link Here
237	close(fds[0]); /* no point in leaving extra fds lying around */	260	close(fds[0]); /* no point in leaving extra fds lying around */
238	execv(exec_argv[0], exec_argv);	261	execv(exec_argv[0], exec_argv);
239	syslog(LOG_ERR, "exec failed: %m");	262	syslog(LOG_ERR, "exec failed: %m");
		263	#else
		264	fprintf(stderr, "exec failed: %d\n", errno);
		265	#endif
240	exit(EX_OSERR);	266	exit(EX_OSERR);
241	}	267	}
242		268
Lines 256-263 Link Here
256	do_libspamc_unit_tests();	282	do_libspamc_unit_tests();
257	#endif	283	#endif
258		284
		285	#ifndef _WIN32
259	openlog ("spamc", LOG_CONS\|LOG_PID, LOG_MAIL);	286	openlog ("spamc", LOG_CONS\|LOG_PID, LOG_MAIL);
260	signal (SIGPIPE, SIG_IGN);	287	signal (SIGPIPE, SIG_IGN);
		288	#endif
261		289
262	read_args(argc,argv, &max_size, &username, &trans);	290	read_args(argc,argv, &max_size, &username, &trans);
263		291
Lines 274-279 Link Here
274	* to our own buffer - then this won't arise as a problem.	302	* to our own buffer - then this won't arise as a problem.
275	*/	303	*/
276		304
		305	#ifndef _WIN32
277	if(NULL == username)	306	if(NULL == username)
278	{	307	{
279	static char userbuf[256];	308	static char userbuf[256];
Lines 289-294 Link Here
289	userbuf[sizeof userbuf - 1] = '\0';	318	userbuf[sizeof userbuf - 1] = '\0';
290	username = userbuf;	319	username = userbuf;
291	}	320	}
		321	#endif
292		322
293	if ((flags & SPAMC_RANDOMIZE_HOSTS) != 0) {	323	if ((flags & SPAMC_RANDOMIZE_HOSTS) != 0) {
294	/* we don't need strong randomness; this is just so we pick	324	/* we don't need strong randomness; this is just so we pick
Lines 304-360 Link Here
304	* we connect to the spam daemon. Mainly this involves lookup up the	334	* we connect to the spam daemon. Mainly this involves lookup up the
305	* hostname and getting the IP addresses to connect to.	335	* hostname and getting the IP addresses to connect to.
306	*/	336	*/
307	if ( (ret = transport_setup(&trans, flags)) != EX_OK )	337	if ( (ret = transport_setup(&trans, flags)) == EX_OK ) {
308	goto FAIL;
309
310
311	out_fd=-1;	338	out_fd=-1;
312	m.type = MESSAGE_NONE;	339	m.type = MESSAGE_NONE;
313	m.max_len = max_size;	340	m.max_len = max_size;
314	m.timeout = timeout;	341	m.timeout = timeout;
315		342
316	ret=message_read(STDIN_FILENO, flags, &m);	343	ret=message_read(STDIN_FILENO, flags, &m);
317	if(ret!=EX_OK) goto FAIL;	344	if(ret==EX_OK) {
318	ret=message_filter(&trans, username, flags, &m);	345	ret=message_filter(&trans, username, flags, &m);
319	if(ret!=EX_OK) goto FAIL;	346	if(ret==EX_OK) {
320	get_output_fd(&out_fd);	347	get_output_fd(&out_fd);
321		348
322	if(message_write(out_fd, &m)<0) {	349	if(message_write(out_fd, &m)>=0) {
323	goto FAIL;
324	}
325		350
326	result = m.is_spam;	351	result = m.is_spam;
327	if ((flags&SPAMC_CHECK_ONLY) && result != EX_TOOBIG) {	352	if ((flags&SPAMC_CHECK_ONLY) && result != EX_TOOBIG) {
328	message_cleanup (&m);	353	message_cleanup (&m);
329	return result;	354	ret = result;
330	} else {	355	} else {
331	message_cleanup (&m);	356	message_cleanup (&m);
		357	}
		358	#ifdef _WIN32
		359	WSACleanup();
		360	#endif
332	return ret;	361	return ret;
333	}	362	}
		363	}
		364	}
		365	}
334		366
335	FAIL:	367	FAIL:
336	get_output_fd(&out_fd);	368	get_output_fd(&out_fd);
337		369
338	result = m.is_spam;	370	result = m.is_spam;
339	if((flags&SPAMC_CHECK_ONLY) && result != EX_TOOBIG) {	371	if((flags&SPAMC_CHECK_ONLY) && result != EX_TOOBIG) {
340	/* probably, the write to stdout failed; we can still report exit code */	372	/* probably, the write to stdout failed; we can still report exit code */
341	message_cleanup (&m);	373	message_cleanup (&m);
342	return result;	374	ret = result;
343
344	} else if(flags&SPAMC_CHECK_ONLY \|\| flags&SPAMC_REPORT \|\| flags&SPAMC_REPORT_IFSPAM) {	375	} else if(flags&SPAMC_CHECK_ONLY \|\| flags&SPAMC_REPORT \|\| flags&SPAMC_REPORT_IFSPAM) {
345	full_write(out_fd, "0/0\n", 4);	376	full_write(out_fd, 1, "0/0\n", 4);
346	message_cleanup (&m);	377	message_cleanup (&m);
347	return EX_NOTSPAM;	378	ret = EX_NOTSPAM;
348
349	} else {	379	} else {
350	message_dump(STDIN_FILENO, out_fd, &m);	380	message_dump(STDIN_FILENO, out_fd, &m);
351	message_cleanup (&m);	381	message_cleanup (&m);
352	if (ret == EX_TOOBIG) {	382	if (ret == EX_TOOBIG) {
353	return 0;	383	ret = 0;
354	} else if (flags & SPAMC_SAFE_FALLBACK) {	384	} else if (flags & SPAMC_SAFE_FALLBACK) {
355	return EX_OK;	385	ret = EX_OK;
356	} else {
357	return ret;
358	}	386	}
359	}	387	}
		388	#ifdef _WIN32
		389	WSACleanup();
		390	#endif
		391	return ret;
360	}	392	}




  'ssl'                         => \$opt{'ssl'},
  'server-key=s'                => \$opt{'server-key'},
  'server-cert=s'               => \$opt{'server-cert'},
  'stdout=s'                    => \$opt{'stdout'},

  # will be stripped in future release
  'add-from!'          => sub { warn "The --add-from option has been removed\n" },


# Do whitelist later in tmp dir. Side effect: this will be done as -u user.

if (($log_facility ne 'stderr') && ($log_facility ne 'null')) {
  eval {
    setlogsock($log_socket);
    syslog('debug', "spamd starting");  # required to actually open the socket

  ) || die "Could not create INET socket: $! $@\n";
}

if ($opt{'daemonize'}) {
  daemonize();
} else {
    if (defined($opt{'stdout'})) {
      STDOUT->autoflush(1);
      STDERR->autoflush(1);
      open STDOUT,">$opt{'stdout'}" or die "Could not redirect STDOUT: $!\n";
      open STDERR,'>&STDOUT' or die "Can't duplicate stdout: $!\n";
  }
}

if(defined($opt{'pidfile'})) {
  open PIDF,">$opt{'pidfile'}" or warn "Can't write to PID file: $!";

Lines 6-17 Link Here

(-)spamd/utils.c (-13 / +47 lines)
6	* "License".	6	* "License".
7	*/	7	*/
8		8
		9	#ifndef _WIN32
9	#include <unistd.h>	10	#include <unistd.h>
		11	#include <sys/uio.h>
		12	#else
		13	typedef int ssize_t;
		14	#endif
10	#include <errno.h>	15	#include <errno.h>
11	#include <signal.h>	16	#include <signal.h>
12	#include <sys/types.h>	17	#include <sys/types.h>
13	#include <sys/uio.h>
14	#include <unistd.h>
15	#include <stdio.h>	18	#include <stdio.h>
16	#include "utils.h"	19	#include "utils.h"
17		20
Lines 25-31 Link Here
25	/* Apr 24, 2003 sjf: made full_read and full_write void* params */	28	/* Apr 24, 2003 sjf: made full_read and full_write void* params */
26		29
27	/* -------------------------------------------------------------------------- */	30	/* -------------------------------------------------------------------------- */
28		31	#ifndef _WIN32
29	typedef void sigfunc(int); /* for signal handlers */	32	typedef void sigfunc(int); /* for signal handlers */
30		33
31	sigfunc* sig_catch(int sig, void (*f)(int))	34	sigfunc* sig_catch(int sig, void (*f)(int))
Lines 41-63 Link Here
41	static void catch_alrm(int x) {	44	static void catch_alrm(int x) {
42	UNUSED_VARIABLE(x);	45	UNUSED_VARIABLE(x);
43	}	46	}
		47	#endif
44		48
45	ssize_t	49	ssize_t
46	fd_timeout_read (int fd, void *buf, size_t nbytes)	50	fd_timeout_read (int fd, char fdflag, void *buf, size_t nbytes)
47	{	51	{
48	ssize_t nred;	52	ssize_t nred;
		53	int origerr;
		54	#ifndef _WIN32
49	sigfunc* sig;	55	sigfunc* sig;
50		56
51	sig = sig_catch(SIGALRM, catch_alrm);	57	sig = sig_catch(SIGALRM, catch_alrm);
52	if (libspamc_timeout > 0) {	58	if (libspamc_timeout > 0) {
53	alarm(libspamc_timeout);	59	alarm(libspamc_timeout);
54	}	60	}
		61	#endif
55		62
56	do {	63	do {
		64	if (fdflag) {
57	nred = read (fd, buf, nbytes);	65	nred = read (fd, buf, nbytes);
58	} while(nred < 0 && errno == EAGAIN);	66	origerr = errno;
		67	} else {
		68	nred = recv (fd, buf, nbytes, 0);
		69	#ifndef _WIN32
		70	origerr = errno;
		71	#else
		72	origerr = WSAGetLastError();
		73	#endif
		74	}
		75	} while(nred < 0 && origerr == EWOULDBLOCK);
59		76
60	if(nred < 0 && errno == EINTR)	77	#ifndef _WIN32
		78	if(nred < 0 && origerr == EINTR)
61	errno = ETIMEDOUT;	79	errno = ETIMEDOUT;
62		80
63	if (libspamc_timeout > 0) {	81	if (libspamc_timeout > 0) {
Lines 66-71 Link Here
66		84
67	/* restore old signal handler */	85	/* restore old signal handler */
68	sig_catch(SIGALRM, sig);	86	sig_catch(SIGALRM, sig);
		87	#endif
69		88
70	return nred;	89	return nred;
71	}	90	}
Lines 74-80 Link Here
74	ssl_timeout_read (SSL ssl, void buf, int nbytes)	93	ssl_timeout_read (SSL ssl, void buf, int nbytes)
75	{	94	{
76	int nred;	95	int nred;
77	sigfunc* sig;
78		96
79	#ifndef SPAMC_SSL	97	#ifndef SPAMC_SSL
80	UNUSED_VARIABLE(ssl);	98	UNUSED_VARIABLE(ssl);
Lines 82-91 Link Here
82	UNUSED_VARIABLE(nbytes);	100	UNUSED_VARIABLE(nbytes);
83	#endif	101	#endif
84		102
		103	#ifndef _WIN32
		104	sigfunc* sig;
		105
85	sig = sig_catch(SIGALRM, catch_alrm);	106	sig = sig_catch(SIGALRM, catch_alrm);
86	if (libspamc_timeout > 0) {	107	if (libspamc_timeout > 0) {
87	alarm(libspamc_timeout);	108	alarm(libspamc_timeout);
88	}	109	}
		110	#endif
89		111
90	do {	112	do {
91	#ifdef SPAMC_SSL	113	#ifdef SPAMC_SSL
Lines 93-100 Link Here
93	#else	115	#else
94	nred = 0; /* never used */	116	nred = 0; /* never used */
95	#endif	117	#endif
96	} while(nred < 0 && errno == EAGAIN);	118	} while(nred < 0 && errno == EWOULDBLOCK);
97		119
		120	#ifndef _WIN32
98	if(nred < 0 && errno == EINTR)	121	if(nred < 0 && errno == EINTR)
99	errno = ETIMEDOUT;	122	errno = ETIMEDOUT;
100		123
Lines 104-109 Link Here
104		127
105	/* restore old signal handler */	128	/* restore old signal handler */
106	sig_catch(SIGALRM, sig);	129	sig_catch(SIGALRM, sig);
		130	#endif
107		131
108	return nred;	132	return nred;
109	}	133	}
Lines 111-124 Link Here
111	/* -------------------------------------------------------------------------- */	135	/* -------------------------------------------------------------------------- */
112		136
113	int	137	int
114	full_read (int fd, void *vbuf, int min, int len)	138	full_read (int fd, char fdflag, void *vbuf, int min, int len)
115	{	139	{
116	unsigned char buf = (unsigned char )vbuf;	140	unsigned char buf = (unsigned char )vbuf;
117	int total;	141	int total;
118	int thistime;	142	int thistime;
119		143
120	for (total = 0; total < min; ) {	144	for (total = 0; total < min; ) {
121	thistime = fd_timeout_read (fd, buf+total, len-total);	145	thistime = fd_timeout_read (fd, fdflag, buf+total, len-total);
122		146
123	if (thistime < 0) {	147	if (thistime < 0) {
124	return -1;	148	return -1;
Lines 156-172 Link Here
156	}	180	}
157		181
158	int	182	int
159	full_write (int fd, const void *vbuf, int len)	183	full_write (int fd, char fdflag, const void *vbuf, int len)
160	{	184	{
161	const unsigned char buf = (const unsigned char )vbuf;	185	const unsigned char buf = (const unsigned char )vbuf;
162	int total;	186	int total;
163	int thistime;	187	int thistime;
		188	int origerr;
164		189
165	for (total = 0; total < len; ) {	190	for (total = 0; total < len; ) {
		191	if (fdflag) {
166	thistime = write (fd, buf+total, len-total);	192	thistime = write (fd, buf+total, len-total);
167		193	origerr = errno;
		194	} else {
		195	thistime = send (fd, buf+total, len-total, 0);
		196	#ifndef _WIN32
		197	origerr = errno;
		198	#else
		199	origerr = WSAGetLastError();
		200	#endif
		201	}
168	if (thistime < 0) {	202	if (thistime < 0) {
169	if(EINTR == errno \|\| EAGAIN == errno) continue;	203	if(EINTR == origerr \|\| EWOULDBLOCK == origerr) continue;
170	return thistime; /* always an error for writes */	204	return thistime; /* always an error for writes */
171	}	205	}
172	total += thistime;	206	total += thistime;




typedef int	SSL_CTX;
typedef int	SSL_METHOD;
#endif
#ifdef _WIN32
#include <winsock.h>
typedef int ssize_t;
//
// BSD-compatible socket error codes for Win32
//

#define EWOULDBLOCK             WSAEWOULDBLOCK 
#define EINPROGRESS             WSAEINPROGRESS 
#define EALREADY                WSAEALREADY 
#define ENOTSOCK                WSAENOTSOCK 
#define EDESTADDRREQ            WSAEDESTADDRREQ 
#define EMSGSIZE                WSAEMSGSIZE 
#define EPROTOTYPE              WSAEPROTOTYPE 
#define ENOPROTOOPT             WSAENOPROTOOPT 
#define EPROTONOSUPPORT         WSAEPROTONOSUPPORT 
#define ESOCKTNOSUPPORT         WSAESOCKTNOSUPPORT 
#define EOPNOTSUPP              WSAEOPNOTSUPP 
#define EPFNOSUPPORT            WSAEPFNOSUPPORT 
#define EAFNOSUPPORT            WSAEAFNOSUPPORT 
#define EADDRINUSE              WSAEADDRINUSE 
#define EADDRNOTAVAIL           WSAEADDRNOTAVAIL 
#define ENETDOWN                WSAENETDOWN 
#define ENETUNREACH             WSAENETUNREACH 
#define ENETRESET               WSAENETRESET 
#define ECONNABORTED            WSAECONNABORTED 
#define ECONNRESET              WSAECONNRESET 
#define ENOBUFS                 WSAENOBUFS 
#define EISCONN                 WSAEISCONN 
#define ENOTCONN                WSAENOTCONN 
#define ESHUTDOWN               WSAESHUTDOWN 
#define ETOOMANYREFS            WSAETOOMANYREFS 
#define ETIMEDOUT               WSAETIMEDOUT 
#define ECONNREFUSED            WSAECONNREFUSED 
#define ELOOP                   WSAELOOP 
// #define ENAMETOOLONG            WSAENAMETOOLONG
#define EHOSTDOWN               WSAEHOSTDOWN 
#define EHOSTUNREACH            WSAEHOSTUNREACH 
// #define ENOTEMPTY               WSAENOTEMPTY
#define EPROCLIM                WSAEPROCLIM 
#define EUSERS                  WSAEUSERS 
#define EDQUOT                  WSAEDQUOT 
#define ESTALE                  WSAESTALE 
#define EREMOTE                 WSAEREMOTE 

// NOTE: these are not errno constants in UNIX!
#define HOST_NOT_FOUND          WSAHOST_NOT_FOUND 
#define TRY_AGAIN               WSATRY_AGAIN 
#define NO_RECOVERY             WSANO_RECOVERY 
#define NO_DATA                 WSANO_DATA 

#endif

ssize_t fd_timeout_read (int fd, char fdflag, void *, size_t );  
int ssl_timeout_read (SSL *ssl, void *, int );  

/* these are fd-only, no SSL support */
int full_read(int fd, char fdflag, void *buf, int min, int len);
int full_read_ssl(SSL *ssl, unsigned char *buf, int min, int len);
int full_write(int fd, char fdflag, const void *buf, int len);

#endif

Return to bug 2862

Lines 9-19 Link Here

(-)spamd/libspamc.h (-1 / +28 lines)
9	#ifndef LIBSPAMC_H	9	#ifndef LIBSPAMC_H
10	#define LIBSPAMC_H 1	10	#define LIBSPAMC_H 1
11		11
		12	#ifdef _WIN32
		13	#include <winsock.h>
		14	#else
		15	#include <netdb.h>
12	#include <sys/types.h>	16	#include <sys/types.h>
13	#include <sys/socket.h>	17	#include <sys/socket.h>
14	#include <netinet/in.h>	18	#include <netinet/in.h>
15	#include <netdb.h>	19	#endif
16	#include <stdio.h>	20	#include <stdio.h>
		21
		22	#ifdef _WIN32
		23	#define EX_OK 0
		24	#define EX_USAGE 64
		25	#define EX_DATAERR 65
		26	#define EX_NOINPUT 66
		27	#define EX_NOUSER 67
		28	#define EX_NOHOST 68
		29	#define EX_UNAVAILABLE 69
		30	#define EX_SOFTWARE 70
		31	#define EX_OSERR 71
		32	#define EX_OSFILE 72
		33	#define EX_CANTCREAT 73
		34	#define EX_IOERR 74
		35	#define EX_TEMPFAIL 75
		36	#define EX_PROTOCOL 76
		37	#define EX_NOPERM 77
		38	#define EX_CONFIG 78
		39
		40	#define STDIN_FILENO 0
		41	#define STDOUT_FILENO 1
		42
		43	#endif
17		44
18	#define EX_NOTSPAM 0	45	#define EX_NOTSPAM 0
19	#define EX_ISSPAM 1	46	#define EX_ISSPAM 1

Lines 141-146 Link Here

(-)spamd/spamd.raw (-2 / +12 lines)
141	'ssl' => \$opt{'ssl'},	141	'ssl' => \$opt{'ssl'},
142	'server-key=s' => \$opt{'server-key'},	142	'server-key=s' => \$opt{'server-key'},
143	'server-cert=s' => \$opt{'server-cert'},	143	'server-cert=s' => \$opt{'server-cert'},
		144	'stdout=s' => \$opt{'stdout'},
144		145
145	# will be stripped in future release	146	# will be stripped in future release
146	'add-from!' => sub { warn "The --add-from option has been removed\n" },	147	'add-from!' => sub { warn "The --add-from option has been removed\n" },
Lines 280-286 Link Here
280		281
281	# Do whitelist later in tmp dir. Side effect: this will be done as -u user.	282	# Do whitelist later in tmp dir. Side effect: this will be done as -u user.
282		283
283	if ($log_facility ne 'stderr') {	284	if (($log_facility ne 'stderr') && ($log_facility ne 'null')) {
284	eval {	285	eval {
285	setlogsock($log_socket);	286	setlogsock($log_socket);
286	syslog('debug', "spamd starting"); # required to actually open the socket	287	syslog('debug', "spamd starting"); # required to actually open the socket
Lines 377-383 Link Here
377	) \|\| die "Could not create INET socket: $! $@\n";	378	) \|\| die "Could not create INET socket: $! $@\n";
378	}	379	}
379		380
380	$opt{'daemonize'} and daemonize();	381	if ($opt{'daemonize'}) {
		382	daemonize();
		383	} else {
		384	if (defined($opt{'stdout'})) {
		385	STDOUT->autoflush(1);
		386	STDERR->autoflush(1);
		387	open STDOUT,">$opt{'stdout'}" or die "Could not redirect STDOUT: $!\n";
		388	open STDERR,'>&STDOUT' or die "Can't duplicate stdout: $!\n";
		389	}
		390	}
381		391
382	if(defined($opt{'pidfile'})) {	392	if(defined($opt{'pidfile'})) {
383	open PIDF,">$opt{'pidfile'}" or warn "Can't write to PID file: $!";	393	open PIDF,">$opt{'pidfile'}" or warn "Can't write to PID file: $!";

Lines 15-27 Link Here

(-)spamd/utils.h (-3 / +55 lines)
15	typedef int SSL_CTX;	15	typedef int SSL_CTX;
16	typedef int SSL_METHOD;	16	typedef int SSL_METHOD;
17	#endif	17	#endif
		18	#ifdef _WIN32
		19	#include <winsock.h>
		20	typedef int ssize_t;
		21	//
		22	// BSD-compatible socket error codes for Win32
		23	//
18		24
19	ssize_t fd_timeout_read (int fd, void *, size_t );	25	#define EWOULDBLOCK WSAEWOULDBLOCK
		26	#define EINPROGRESS WSAEINPROGRESS
		27	#define EALREADY WSAEALREADY
		28	#define ENOTSOCK WSAENOTSOCK
		29	#define EDESTADDRREQ WSAEDESTADDRREQ
		30	#define EMSGSIZE WSAEMSGSIZE
		31	#define EPROTOTYPE WSAEPROTOTYPE
		32	#define ENOPROTOOPT WSAENOPROTOOPT
		33	#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
		34	#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
		35	#define EOPNOTSUPP WSAEOPNOTSUPP
		36	#define EPFNOSUPPORT WSAEPFNOSUPPORT
		37	#define EAFNOSUPPORT WSAEAFNOSUPPORT
		38	#define EADDRINUSE WSAEADDRINUSE
		39	#define EADDRNOTAVAIL WSAEADDRNOTAVAIL
		40	#define ENETDOWN WSAENETDOWN
		41	#define ENETUNREACH WSAENETUNREACH
		42	#define ENETRESET WSAENETRESET
		43	#define ECONNABORTED WSAECONNABORTED
		44	#define ECONNRESET WSAECONNRESET
		45	#define ENOBUFS WSAENOBUFS
		46	#define EISCONN WSAEISCONN
		47	#define ENOTCONN WSAENOTCONN
		48	#define ESHUTDOWN WSAESHUTDOWN
		49	#define ETOOMANYREFS WSAETOOMANYREFS
		50	#define ETIMEDOUT WSAETIMEDOUT
		51	#define ECONNREFUSED WSAECONNREFUSED
		52	#define ELOOP WSAELOOP
		53	// #define ENAMETOOLONG WSAENAMETOOLONG
		54	#define EHOSTDOWN WSAEHOSTDOWN
		55	#define EHOSTUNREACH WSAEHOSTUNREACH
		56	// #define ENOTEMPTY WSAENOTEMPTY
		57	#define EPROCLIM WSAEPROCLIM
		58	#define EUSERS WSAEUSERS
		59	#define EDQUOT WSAEDQUOT
		60	#define ESTALE WSAESTALE
		61	#define EREMOTE WSAEREMOTE
		62
		63	// NOTE: these are not errno constants in UNIX!
		64	#define HOST_NOT_FOUND WSAHOST_NOT_FOUND
		65	#define TRY_AGAIN WSATRY_AGAIN
		66	#define NO_RECOVERY WSANO_RECOVERY
		67	#define NO_DATA WSANO_DATA
		68
		69	#endif
		70
		71	ssize_t fd_timeout_read (int fd, char fdflag, void *, size_t );
20	int ssl_timeout_read (SSL ssl, void , int );	72	int ssl_timeout_read (SSL ssl, void , int );
21		73
22	/* these are fd-only, no SSL support */	74	/* these are fd-only, no SSL support */
23	int full_read(int fd, void *buf, int min, int len);	75	int full_read(int fd, char fdflag, void *buf, int min, int len);
24	int full_read_ssl(SSL ssl, unsigned char buf, int min, int len);	76	int full_read_ssl(SSL ssl, unsigned char buf, int min, int len);
25	int full_write(int fd, const void *buf, int len);	77	int full_write(int fd, char fdflag, const void *buf, int len);
26		78
27	#endif	79	#endif