Mix/Src/rem.c

/* Mixmaster version 3  --  (C) 1999 Anonymizer Inc.

   Mixmaster may be redistributed and modified under certain conditions.
   This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   ANY KIND, either express or implied. See the file COPYRIGHT for
   details.

   Process remailer messages
   $Id: rem.c,v 1.28 2002/09/18 23:26:17 rabbi Exp $ */


#include "mix3.h"
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef POSIX
#include <unistd.h>
#else /* end of POSIX */
#include <io.h>
#endif /* else if not POSIX */
#ifndef _MSC
#include <dirent.h>
#endif /* not _MSC */
#include <assert.h>

int blockrequest(BUFFER *message);
int create_dummy_mailin();

#define REQUESTHELP  100
#define REQUESTSTATS 101
#define REQUESTKEY   200
#define REQUESTCONF  201
#define REQUESTOPKEY 202
#define BLOCKREQUEST 666
#define DISABLED      99

#define CPUNKMSG 1
#define MIXMSG 2

int mix_decrypt(BUFFER *message)
{
  int type = 0;
  BUFFER *field, *content;
  BUFFER *to, *subject, *replyto, *reply;
  FILE *f;
  BUFFER *block;
  int err = 0;
  int quoted_printable = 0;     /* is this message quoted printable encoded */

  mix_init(NULL);
  field = buf_new();
  content = buf_new();
  to = buf_new();
  replyto = buf_new();
  reply = buf_new();
  block = buf_new();
  subject = buf_new();
  buf_sets(subject, "Subject: Re: your mail");

  buf_rewind(message);

  f = mix_openfile(SOURCEBLOCK, "r");
  if (f != NULL) {
    buf_read(block, f);
    fclose(f);
  }
  for (;;) {
    err = buf_getheader(message, field, content);
    if (err == 1) {
      /* "::" marks for additional header lines */
      while (buf_lookahead(message, field) == 1)
        buf_getheader(message, field, content);
      if (isline(field, HDRMARK))
        continue;
      else
        goto hdrend;
    }
    if (err == -1)
      goto hdrend;

    if ((bufieq(field, "from") || bufieq(field, "sender") || bufieq(field,"received")) &&
       doblock(content, block, 1) != 0)
      goto end;

    if (bufieq(field, "to"))
      buf_cat(to, content);
    else if (bufieq(field, "from") && replyto->length == 0)
      /* reply to From address if no Reply-To header present */
      buf_set(replyto, content);
    else if (bufieq(field, "reply-to"))
      buf_set(replyto, content);
    else if (MIX && bufieq(field, "remailer-type") &&
             bufileft(content, "mixmaster"))
      type = MIXMSG;
    else if (bufieq(field, "subject")) {
      if (bufieq(content, "help") || bufieq(content, "remailer-help"))
        type = REQUESTHELP;
      else if (bufieq(content, "remailer-stats"))
        type = REQUESTSTATS;
      else if (bufieq(content, "remailer-key"))
        type = REQUESTKEY;
      else if (bufieq(content, "remailer-adminkey"))
        type = REQUESTOPKEY;
      else if (bufieq(content, "remailer-conf"))
        type = REQUESTCONF;
      else if (bufileft(content, "destination-block"))
        type = BLOCKREQUEST;
      else {
        buf_sets(subject, "Subject: ");
        if (!bufileft(content, "re:"))
          buf_appends(subject, "Re: ");
        buf_cat(subject, content);
      }
    } else if (bufieq(field, "test-to") || bufieq(field, "encrypted") ||
               bufieq(field, "anon-to") ||
               bufieq(field, "request-remailing-to") ||
               bufieq(field, "remail-to") || bufieq(field, "anon-post-to") ||
               bufieq(field, "post-to") || bufieq(field, "anon-send-to") ||
               bufieq(field, "send-to") || bufieq(field, "remix-to") ||
               bufieq(field, "encrypt-to"))
      type = CPUNKMSG;
    else if (bufieq(field, "content-transfer-encoding")
             && bufieq(content, "quoted-printable")) {
      quoted_printable = 1;
    }
      
  }
hdrend:
  if (quoted_printable)
    qp_decode_message(message);

  if (type > 0 && REMAIL == 0)
    type = DISABLED;
  switch (type) {
  case REQUESTHELP:
    if (sendinfofile(HELPFILE, NULL, replyto, NULL) == -1)
      errlog(WARNING, "No help file available.\n");
    break;
  case REQUESTKEY:
    err = key(reply);
    if (err == 0)
      err = sendmail(reply, REMAILERNAME, replyto);
    break;
  case REQUESTOPKEY:
    err = adminkey(reply);
    if (err == 0)
      err = sendmail(reply, REMAILERNAME, replyto);
    break;
  case REQUESTSTATS:
    err = stats(reply);
    if (err == 0)
      err = sendmail(reply, REMAILERNAME, replyto);
    break;
  case REQUESTCONF:
    err = conf(reply);
    if (err == 0)
      err = sendmail(reply, REMAILERNAME, replyto);
    break;
  case CPUNKMSG:
    err = t1_decrypt(message);
    if (err != 0) {
      errlog(LOG, "Invalid type 1 message from %b\n", replyto);
      sendinfofile(USAGEFILE, USAGELOG, replyto, NULL);
      logmail(err == -2 ? MAILUSAGE : MAILERROR, message);
    } else
      create_dummy_mailin();
    break;
  case MIXMSG:
    err = t2_decrypt(message);
    if (err == -1) {
      errlog(LOG, "Invalid type 2 message from %b\n", replyto);
      sendinfofile(USAGEFILE, USAGELOG, replyto, NULL);
      logmail(MAILERROR, message);
    } else
      create_dummy_mailin();
    break;
  case BLOCKREQUEST:
    blockrequest(message);
    logmail(MAILBLOCK, message);
    break;
  case DISABLED:
    errlog(ERRORMSG, "Remailer is disabled.\n");
    buf_sets(reply, "Subject: remailer error\n\nThe remailer is disabled.\n");
    sendmail(reply, REMAILERNAME, replyto);
    logmail(MAILERROR, message);
    break;
  default:
    if (strifind
        (replyto->data, "mailer-daemon")) {
      errlog(LOG, "Bounce mail from %b\n", replyto);
      logmail(MAILBOUNCE, message);
    } else if (bufifind(to, REMAILERADDR) && blockrequest(message))
      logmail(MAILBLOCK, message);
    else if (!AUTOREPLY)
      logmail(MAILBOX, message);
    else if (bufifind(to, REMAILERADDR)) {
      errlog(LOG, "Non-remailer message from %b\n", replyto);
      sendinfofile(USAGEFILE, USAGELOG, replyto, NULL);
      logmail(MAILUSAGE, message);
    } else if (bufifind(to, COMPLAINTS)) {
      errlog(WARNING, "Abuse complaint from %b\n", replyto);
      sendinfofile(ABUSEFILE, NULL, replyto, subject);
      logmail(MAILABUSE, message);
    } else if (ANONADDR[0] && bufifind(to, ANONADDR)) {
      errlog(LOG, "Reply to anonymous message from %b\n", replyto);
      sendinfofile(REPLYFILE, NULL, replyto, subject);
      logmail(MAILANON, message);
    } else {
      errlog(DEBUGINFO, "Mail from %b\n", replyto);
      logmail(MAILBOX, message);
    }
    err = 1;
  }
end:
  buf_free(field);
  buf_free(content);
  buf_free(to);
  buf_free(replyto);
  buf_free(reply);
  buf_free(block);
  buf_free(subject);
  return (err);
}

int create_dummy_mailin()
{
  while (rnd_number(100) < INDUMMYP) {
    errlog(DEBUGINFO, "Generating dummy message with incoming mail.\n");
    if (mix_encrypt(MSG_NULL, NULL, NULL, 1, NULL) == -1)
      return -1;
  }
  return 0;
}

int t2_decrypt(BUFFER *in)
{
  int err = 0;
  BUFFER *msg;

  msg = buf_new();
  do {
    err = mix_dearmor(in, msg);
    if (err != -1) {
      if (v3_magic(msg->data))
        err = mix3_decrypt(msg);
      else
        err = mix2_decrypt(msg);
    }
  }
  while (in->ptr + 1000 < in->length);  /* accept several packets in one message */

  buf_free(msg);
  return (err);
}

int mix_pool(BUFFER *msg, int type, long latent)
{
  char path[PATHMAX], pathtmp[PATHMAX];
  FILE *f;
  int err = -1;

  f = pool_new(latent > 0 ? "lat" : "msg", pathtmp, path);
  if (f != NULL) {
    if (latent > 0)
      fprintf(f, "%d %ld\n", type, latent + time(NULL));
    else
      fprintf(f, "%d 0\n", type);
    err = buf_write_sync(msg, f);
  }
  if (err == 0) {
    rename(pathtmp, path);
    errlog(DEBUGINFO, "Added message to pool.\n");
  }
  return (err);
}

int pool_packetfile(char *fname, BUFFER *mid, int packetnum)
     /* create a filename */
{
#ifdef SHORTNAMES
  sprintf(fname, "%s%cp%02x%02x%02x%01x.%02x", POOLDIR, DIRSEP,
          mid->data[0], mid->data[1], mid->data[2], mid->data[3] & 15,
          packetnum);
#else /* end of SHORTNAMES */
  sprintf(fname, "%s%cp%02x%02x%02x%02x%02x%02x%01x", POOLDIR, DIRSEP,
          packetnum, mid->data[0], mid->data[1], mid->data[2], mid->data[3],
          mid->data[4], mid->data[5] & 15);
#endif /* else if not SHORTNAMES */
  return (0);
}

void pool_packetexp(void)
{
  char *path;
  DIR *d;
  struct dirent *e;
  struct stat sb;

  d = opendir(POOLDIR);
  errlog(NOTICE, "Checking for old parts.\n");
  if (d != NULL)
    for (;;) {
      e = readdir(d);
      if (e == NULL)
        break;
      if (e->d_name[0] == 'p' || e->d_name[0] == 'e' || e->d_name[0] == 't') {
        path=malloc(strlen(POOLDIR)+strlen(e->d_name)+strlen(DIRSEPSTR)+1);
        if (path) {
         strcpy(path, POOLDIR);
          strcat(path, DIRSEPSTR);
          strcat(path, e->d_name);
          if (stat(path, &sb) == 0 && time(NULL) - sb.st_mtime > PACKETEXP) {
             if (e->d_name[0] == 'p') {
                errlog(NOTICE, "Expiring incomplete partial message %s.\n",
                e->d_name);
             }
             else if (e->d_name[0] == 'e') {
                errlog(NOTICE, "Expiring old error message %s.\n",    
                e->d_name);     
             }
             else if (e->d_name[0] == 't') {
                errlog(NOTICE, "Expiring moldy temporary message %s.\n",
                e->d_name);
             }
             unlink(path);
          }
        free(path);
        }
      }
    }
  closedir(d);
}

void logmail(char *mailbox, BUFFER *message)
{
  time_t t;
  struct tm *tc;
  char line[LINELEN];

  /* mailbox is "|program", "user@host", "stdout", "Maildir/" or "filename" */
  buf_rewind(message);
  if (mailbox[0] == '\0')       /* default action */
    mailbox = MAILBOX;
  if (strieq(mailbox, "stdout"))
    buf_write(message, stdout);
  else if (mailbox[0] == '|') {
    FILE *p;

    errlog(DEBUGINFO, "Piping message to %s.\n", mailbox + 1);
    p = openpipe(mailbox + 1);
    if (p != NULL) {
      buf_write(message, p);
      closepipe(p);
    }
  } else if (strchr(mailbox, '@')) {
    BUFFER *field, *content;

    field = buf_new();
    content = buf_new();
    while (buf_getheader(message, field, content) == 0)
      if (bufieq(field, "x-loop") && bufifind(content, REMAILERADDR)) {
        errlog(WARNING, "Loop detected! Message not sent to %s.\n", mailbox);
        goto isloop;
      }
    buf_sets(content, mailbox);
    sendmail_loop(message, NULL, content);
  isloop:
    buf_free(field);
    buf_free(content);
  } else if (mailbox[strlen(mailbox)-1] == DIRSEP) {
    /* the user is requesting Maildir delivery */
    if(maildirWrite(mailbox, message, 1) != 0) {
      errlog(ERRORMSG, "Can't write to maildir %s\n", mailbox);
      return;
    }
  } else {
    FILE *mbox;

    mbox = mix_openfile(mailbox, "a");
    if (mbox == NULL) {
      errlog(ERRORMSG, "Can't write to mail folder %s\n", mailbox);
      return;
    }
    lock(mbox);
    if (!bufileft(message, "From ")) {
      t = time(NULL);
      tc = localtime(&t);
      strftime(line, LINELEN, "From Mixmaster %a %b %d %H:%M:%S %Y\n", tc);
      fprintf(mbox, line);
    }
    buf_write(message, mbox);
    fprintf(mbox, "\n");
    unlock(mbox);
    fclose(mbox);
  }
}

int blockrequest(BUFFER *message)
{
  int request = 0;
  BUFFER *from, *line, *field, *content, *addr;
  FILE *f;
  char *destblklst = (char *)malloc( strlen(DESTBLOCK)+1 );
  char *destblk;

  from = buf_new();
  line = buf_new();
  field = buf_new();
  content = buf_new();
  addr = buf_new();

  buf_rewind(message);
  while (buf_getheader(message, field, content) == 0)
    if (bufieq(field, "from"))
      buf_set(from, content);
    else if (bufieq(field, "subject"))
      buf_cat(message, content); 
   /* Append the subject to the message body so destination block requests 
      in the subject line work too (we process the body a few lines down) */
  while (buf_getline(message, line) != -1)
    if (bufifind(line, "destination-block")) {
      buf_clear(addr);
      request = 1;
      {
        int c = 0;

        while (!strileft(line->data + line->ptr, "block"))
          line->ptr++;
        while (c != ' ' && c != -1)
          c = tolower(buf_getc(line));
        while (c == ' ')
          c = buf_getc(line);
        if (c != -1)
          do {
            buf_appendc(addr, c);
            c = buf_getc(line);
          } while (c > ' ');
      }
      if (addr->length == 0) {
        rfc822_addr (from, addr);
        buf_chop(addr);
      }
      if (bufieq(addr, REMAILERADDR)) {
        errlog(LOG, "Ignoring blocking request for %b from %b.\n", addr, from);
        return (2);
      }
      if (buf_ieq(addr, from))
        errlog(NOTICE, "Blocking request for %b\n", addr);
      else
        errlog(NOTICE, "Blocking request for %b from %b\n", addr, from);
      if (AUTOBLOCK) {
        buf_clear(line);
        rfc822_addr(addr, line);
        if (line->length == 0) {
          errlog(LOG, "Nothing to block after rfc822_addr().\n");
        } else
          if (bufleft(line, "/")) {
            errlog(LOG, "Ignoring blocking request: %b is a regex.\n", addr);
          } else {
            if (strchr(line->data, '@') && strchr(strchr(line->data, '@'), '.')) {
              strcpy( destblklst, DESTBLOCK );
              destblk = strtok( destblklst, " " );
              f = mix_openfile( destblk, "a" );
              free( destblklst );
              if (f != NULL) {
                lock(f);

                buf_chop(line);
                sendinfofile(BLOCKFILE, NULL, line, NULL);
                if (line->length) {
                  fprintf(f, "%s\n", line->data);
                } else
                  errlog(NOTICE, "%b already blocked.\n", addr);
                unlock(f);
                fclose(f);
              } else
                errlog(ERRORMSG, "Can't write to %s.\n", DESTBLOCK);
            } else
              errlog(WARNING, "Invalid address not added to %s: %b\n", DESTBLOCK,
                     addr);
          }
      }
    }
  return (request);
}


int idexp(void)
{
  FILE *f;
  BUFFER *b;
  long now, then;
  LOCK *i;
  idlog_t idbuf;
  long fpi = sizeof(idlog_t), fpo = sizeof(idlog_t);

  if (IDEXP == 0)
    return (0);

  b = buf_new();
  f = mix_openfile(IDLOG, "rb+");
  if (f == NULL)
    return (-1);
  i = lockfile(IDLOG);
  now = time(NULL);
  if (fread(&idbuf, 1, sizeof(idlog_t), f) != sizeof(idlog_t)) { /* replace first line */
    fclose(f);
    unlockfile(i);
    return (-1);
  }
  then = idbuf.time;
  memset(idbuf.id,0,sizeof(idbuf.id));
  idbuf.time = now - IDEXP;
  fseek(f,0,SEEK_SET);
  fwrite(&idbuf,1,sizeof(idlog_t),f);
  fseek(f,fpi,SEEK_SET); /* this fseek does nothing, but MSVC CRT happilly reads past EOF (!!!) if we do not fseek here :-/ */
  while (fread(&idbuf, 1, sizeof(idlog_t), f) == sizeof(idlog_t)) {
    fpi+=sizeof(idlog_t);
    then = idbuf.time;
    if (now - then < IDEXP &&
      now - then > - SECONDSPERDAY * 180 )
      /* also expire packets that are dated more than half a year in the future.
       * That way we get rid of invalid packets introduced by the switch to a
       * binary id.log. */
    {
      fseek(f,fpo,SEEK_SET);
      fwrite(&idbuf,1,sizeof(idlog_t),f);
      fpo += sizeof(idlog_t);
      fseek(f,fpi,SEEK_SET);
    }
  }
#ifdef _MSC
    chsize(fileno(f),fpo);
#else /* end of _MSC */
    ftruncate(fileno(f),fpo);
#endif /* else if not _MSC */
  fclose(f);
  unlockfile(i);
  buf_free(b);
  return (0);
}
1	rabbi	1	/* Mixmaster version 3 -- (C) 1999 Anonymizer Inc.
2
3			Mixmaster may be redistributed and modified under certain conditions.
4			This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
5			ANY KIND, either express or implied. See the file COPYRIGHT for
6			details.
7
8			Process remailer messages
9	rabbi	262	$Id: rem.c,v 1.28 2002/09/18 23:26:17 rabbi Exp $ */
10	rabbi	1
11
12			#include "mix3.h"
13			#include <stdlib.h>
14			#include <string.h>
15			#include <time.h>
16			#include <ctype.h>
17			#include <sys/types.h>
18			#include <sys/stat.h>
19			#ifdef POSIX
20			#include <unistd.h>
21	rabbi	262	#else /* end of POSIX */
22	rabbi	1	#include <io.h>
23	rabbi	262	#endif /* else if not POSIX */
24	rabbi	1	#ifndef _MSC
25			#include <dirent.h>
26	rabbi	262	#endif /* not _MSC */
27	rabbi	1	#include <assert.h>
28
29			int blockrequest(BUFFER *message);
30	rabbi	218	int create_dummy_mailin();
31	rabbi	1
32			#define REQUESTHELP 100
33			#define REQUESTSTATS 101
34			#define REQUESTKEY 200
35			#define REQUESTCONF 201
36			#define REQUESTOPKEY 202
37			#define BLOCKREQUEST 666
38			#define DISABLED 99
39
40			#define CPUNKMSG 1
41			#define MIXMSG 2
42
43			int mix_decrypt(BUFFER *message)
44			{
45			int type = 0;
46			BUFFER field, content;
47			BUFFER to, subject, replyto, reply;
48			FILE *f;
49			BUFFER *block;
50			int err = 0;
51	rabbi	41	int quoted_printable = 0; /* is this message quoted printable encoded */
52	rabbi	1
53			mix_init(NULL);
54			field = buf_new();
55			content = buf_new();
56			to = buf_new();
57			replyto = buf_new();
58			reply = buf_new();
59			block = buf_new();
60			subject = buf_new();
61			buf_sets(subject, "Subject: Re: your mail");
62
63			buf_rewind(message);
64
65			f = mix_openfile(SOURCEBLOCK, "r");
66			if (f != NULL) {
67			buf_read(block, f);
68			fclose(f);
69			}
70			for (;;) {
71			err = buf_getheader(message, field, content);
72			if (err == 1) {
73			/* "::" marks for additional header lines */
74			while (buf_lookahead(message, field) == 1)
75			buf_getheader(message, field, content);
76			if (isline(field, HDRMARK))
77			continue;
78			else
79			goto hdrend;
80			}
81			if (err == -1)
82			goto hdrend;
83
84			if ((bufieq(field, "from") \|\| bufieq(field, "sender") \|\| bufieq(field,"received")) &&
85			doblock(content, block, 1) != 0)
86			goto end;
87
88			if (bufieq(field, "to"))
89			buf_cat(to, content);
90			else if (bufieq(field, "from") && replyto->length == 0)
91			/* reply to From address if no Reply-To header present */
92			buf_set(replyto, content);
93			else if (bufieq(field, "reply-to"))
94			buf_set(replyto, content);
95			else if (MIX && bufieq(field, "remailer-type") &&
96			bufileft(content, "mixmaster"))
97			type = MIXMSG;
98			else if (bufieq(field, "subject")) {
99			if (bufieq(content, "help") \|\| bufieq(content, "remailer-help"))
100			type = REQUESTHELP;
101			else if (bufieq(content, "remailer-stats"))
102			type = REQUESTSTATS;
103			else if (bufieq(content, "remailer-key"))
104			type = REQUESTKEY;
105			else if (bufieq(content, "remailer-adminkey"))
106			type = REQUESTOPKEY;
107			else if (bufieq(content, "remailer-conf"))
108			type = REQUESTCONF;
109			else if (bufileft(content, "destination-block"))
110			type = BLOCKREQUEST;
111			else {
112			buf_sets(subject, "Subject: ");
113			if (!bufileft(content, "re:"))
114			buf_appends(subject, "Re: ");
115			buf_cat(subject, content);
116			}
117			} else if (bufieq(field, "test-to") \|\| bufieq(field, "encrypted") \|\|
118			bufieq(field, "anon-to") \|\|
119			bufieq(field, "request-remailing-to") \|\|
120			bufieq(field, "remail-to") \|\| bufieq(field, "anon-post-to") \|\|
121			bufieq(field, "post-to") \|\| bufieq(field, "anon-send-to") \|\|
122	rabbi	62	bufieq(field, "send-to") \|\| bufieq(field, "remix-to") \|\|
123	weaselp	106	bufieq(field, "encrypt-to"))
124	rabbi	1	type = CPUNKMSG;
125	rabbi	41	else if (bufieq(field, "content-transfer-encoding")
126			&& bufieq(content, "quoted-printable")) {
127			quoted_printable = 1;
128			}
129
130	rabbi	1	}
131			hdrend:
132	rabbi	41	if (quoted_printable)
133			qp_decode_message(message);
134
135	rabbi	1	if (type > 0 && REMAIL == 0)
136			type = DISABLED;
137			switch (type) {
138			case REQUESTHELP:
139			if (sendinfofile(HELPFILE, NULL, replyto, NULL) == -1)
140			errlog(WARNING, "No help file available.\n");
141			break;
142			case REQUESTKEY:
143			err = key(reply);
144			if (err == 0)
145			err = sendmail(reply, REMAILERNAME, replyto);
146			break;
147			case REQUESTOPKEY:
148			err = adminkey(reply);
149			if (err == 0)
150			err = sendmail(reply, REMAILERNAME, replyto);
151			break;
152			case REQUESTSTATS:
153			err = stats(reply);
154			if (err == 0)
155			err = sendmail(reply, REMAILERNAME, replyto);
156			break;
157			case REQUESTCONF:
158			err = conf(reply);
159			if (err == 0)
160			err = sendmail(reply, REMAILERNAME, replyto);
161			break;
162			case CPUNKMSG:
163			err = t1_decrypt(message);
164			if (err != 0) {
165			errlog(LOG, "Invalid type 1 message from %b\n", replyto);
166			sendinfofile(USAGEFILE, USAGELOG, replyto, NULL);
167			logmail(err == -2 ? MAILUSAGE : MAILERROR, message);
168	rabbi	218	} else
169			create_dummy_mailin();
170	rabbi	1	break;
171			case MIXMSG:
172			err = t2_decrypt(message);
173			if (err == -1) {
174			errlog(LOG, "Invalid type 2 message from %b\n", replyto);
175			sendinfofile(USAGEFILE, USAGELOG, replyto, NULL);
176			logmail(MAILERROR, message);
177	rabbi	218	} else
178			create_dummy_mailin();
179	rabbi	1	break;
180			case BLOCKREQUEST:
181			blockrequest(message);
182			logmail(MAILBLOCK, message);
183			break;
184			case DISABLED:
185			errlog(ERRORMSG, "Remailer is disabled.\n");
186			buf_sets(reply, "Subject: remailer error\n\nThe remailer is disabled.\n");
187			sendmail(reply, REMAILERNAME, replyto);
188			logmail(MAILERROR, message);
189			break;
190			default:
191			if (strifind
192			(replyto->data, "mailer-daemon")) {
193			errlog(LOG, "Bounce mail from %b\n", replyto);
194			logmail(MAILBOUNCE, message);
195			} else if (bufifind(to, REMAILERADDR) && blockrequest(message))
196			logmail(MAILBLOCK, message);
197			else if (!AUTOREPLY)
198			logmail(MAILBOX, message);
199			else if (bufifind(to, REMAILERADDR)) {
200			errlog(LOG, "Non-remailer message from %b\n", replyto);
201			sendinfofile(USAGEFILE, USAGELOG, replyto, NULL);
202			logmail(MAILUSAGE, message);
203			} else if (bufifind(to, COMPLAINTS)) {
204			errlog(WARNING, "Abuse complaint from %b\n", replyto);
205			sendinfofile(ABUSEFILE, NULL, replyto, subject);
206			logmail(MAILABUSE, message);
207			} else if (ANONADDR[0] && bufifind(to, ANONADDR)) {
208			errlog(LOG, "Reply to anonymous message from %b\n", replyto);
209			sendinfofile(REPLYFILE, NULL, replyto, subject);
210			logmail(MAILANON, message);
211			} else {
212			errlog(DEBUGINFO, "Mail from %b\n", replyto);
213			logmail(MAILBOX, message);
214			}
215			err = 1;
216			}
217			end:
218			buf_free(field);
219			buf_free(content);
220			buf_free(to);
221			buf_free(replyto);
222			buf_free(reply);
223			buf_free(block);
224			buf_free(subject);
225			return (err);
226			}
227
228	rabbi	218	int create_dummy_mailin()
229			{
230	rabbi	220	while (rnd_number(100) < INDUMMYP) {
231	rabbi	218	errlog(DEBUGINFO, "Generating dummy message with incoming mail.\n");
232			if (mix_encrypt(MSG_NULL, NULL, NULL, 1, NULL) == -1)
233			return -1;
234			}
235			return 0;
236			}
237
238	rabbi	1	int t2_decrypt(BUFFER *in)
239			{
240			int err = 0;
241			BUFFER *msg;
242
243			msg = buf_new();
244			do {
245			err = mix_dearmor(in, msg);
246			if (err != -1) {
247			if (v3_magic(msg->data))
248			err = mix3_decrypt(msg);
249			else
250			err = mix2_decrypt(msg);
251			}
252			}
253			while (in->ptr + 1000 < in->length); /* accept several packets in one message */
254
255			buf_free(msg);
256			return (err);
257			}
258
259			int mix_pool(BUFFER *msg, int type, long latent)
260			{
261			char path[PATHMAX], pathtmp[PATHMAX];
262			FILE *f;
263			int err = -1;
264
265			f = pool_new(latent > 0 ? "lat" : "msg", pathtmp, path);
266			if (f != NULL) {
267			if (latent > 0)
268			fprintf(f, "%d %ld\n", type, latent + time(NULL));
269			else
270			fprintf(f, "%d 0\n", type);
271	weaselp	120	err = buf_write_sync(msg, f);
272	rabbi	1	}
273			if (err == 0) {
274			rename(pathtmp, path);
275			errlog(DEBUGINFO, "Added message to pool.\n");
276			}
277			return (err);
278			}
279
280			int pool_packetfile(char fname, BUFFER mid, int packetnum)
281			/* create a filename */
282			{
283			#ifdef SHORTNAMES
284	rabbi	11	sprintf(fname, "%s%cp%02x%02x%02x%01x.%02x", POOLDIR, DIRSEP,
285	rabbi	1	mid->data[0], mid->data[1], mid->data[2], mid->data[3] & 15,
286			packetnum);
287	rabbi	262	#else /* end of SHORTNAMES */
288	rabbi	11	sprintf(fname, "%s%cp%02x%02x%02x%02x%02x%02x%01x", POOLDIR, DIRSEP,
289	rabbi	1	packetnum, mid->data[0], mid->data[1], mid->data[2], mid->data[3],
290			mid->data[4], mid->data[5] & 15);
291	rabbi	262	#endif /* else if not SHORTNAMES */
292	rabbi	1	return (0);
293			}
294
295			void pool_packetexp(void)
296			{
297	rabbi	72	char *path;
298	rabbi	1	DIR *d;
299			struct dirent *e;
300			struct stat sb;
301
302			d = opendir(POOLDIR);
303	rabbi	72	errlog(NOTICE, "Checking for old parts.\n");
304	rabbi	1	if (d != NULL)
305			for (;;) {
306			e = readdir(d);
307			if (e == NULL)
308			break;
309	rabbi	217	if (e->d_name[0] == 'p' \|\| e->d_name[0] == 'e' \|\| e->d_name[0] == 't') {
310	rabbi	72	path=malloc(strlen(POOLDIR)+strlen(e->d_name)+strlen(DIRSEPSTR)+1);
311			if (path) {
312			strcpy(path, POOLDIR);
313			strcat(path, DIRSEPSTR);
314			strcat(path, e->d_name);
315	rabbi	217	if (stat(path, &sb) == 0 && time(NULL) - sb.st_mtime > PACKETEXP) {
316			if (e->d_name[0] == 'p') {
317	rabbi	221	errlog(NOTICE, "Expiring incomplete partial message %s.\n",
318	rabbi	217	e->d_name);
319			}
320			else if (e->d_name[0] == 'e') {
321	rabbi	221	errlog(NOTICE, "Expiring old error message %s.\n",
322	rabbi	217	e->d_name);
323			}
324			else if (e->d_name[0] == 't') {
325	rabbi	221	errlog(NOTICE, "Expiring moldy temporary message %s.\n",
326	rabbi	217	e->d_name);
327			}
328	rabbi	72	unlink(path);
329			}
330			free(path);
331	rabbi	1	}
332			}
333			}
334			closedir(d);
335			}
336
337			void logmail(char mailbox, BUFFER message)
338			{
339	rabbi	6	time_t t;
340			struct tm *tc;
341			char line[LINELEN];
342
343	weaselp	153	/* mailbox is "\|program", "user@host", "stdout", "Maildir/" or "filename" */
344	rabbi	1	buf_rewind(message);
345			if (mailbox[0] == '\0') /* default action */
346			mailbox = MAILBOX;
347			if (strieq(mailbox, "stdout"))
348			buf_write(message, stdout);
349			else if (mailbox[0] == '\|') {
350			FILE *p;
351
352	rabbi	66	errlog(DEBUGINFO, "Piping message to %s.\n", mailbox + 1);
353	rabbi	1	p = openpipe(mailbox + 1);
354			if (p != NULL) {
355			buf_write(message, p);
356			closepipe(p);
357			}
358			} else if (strchr(mailbox, '@')) {
359			BUFFER field, content;
360
361			field = buf_new();
362			content = buf_new();
363			while (buf_getheader(message, field, content) == 0)
364			if (bufieq(field, "x-loop") && bufifind(content, REMAILERADDR)) {
365			errlog(WARNING, "Loop detected! Message not sent to %s.\n", mailbox);
366			goto isloop;
367			}
368			buf_sets(content, mailbox);
369	weaselp	116	sendmail_loop(message, NULL, content);
370	rabbi	1	isloop:
371			buf_free(field);
372			buf_free(content);
373	weaselp	163	} else if (mailbox[strlen(mailbox)-1] == DIRSEP) {
374	weaselp	153	/* the user is requesting Maildir delivery */
375			if(maildirWrite(mailbox, message, 1) != 0) {
376			errlog(ERRORMSG, "Can't write to maildir %s\n", mailbox);
377			return;
378			}
379	rabbi	1	} else {
380			FILE *mbox;
381
382			mbox = mix_openfile(mailbox, "a");
383			if (mbox == NULL) {
384			errlog(ERRORMSG, "Can't write to mail folder %s\n", mailbox);
385			return;
386			}
387			lock(mbox);
388	rabbi	6	if (!bufileft(message, "From ")) {
389			t = time(NULL);
390			tc = localtime(&t);
391			strftime(line, LINELEN, "From Mixmaster %a %b %d %H:%M:%S %Y\n", tc);
392			fprintf(mbox, line);
393			}
394	rabbi	1	buf_write(message, mbox);
395			fprintf(mbox, "\n");
396			unlock(mbox);
397			fclose(mbox);
398			}
399			}
400
401			int blockrequest(BUFFER *message)
402			{
403	rabbi	59	int request = 0;
404	rabbi	1	BUFFER from, line, field, content, *addr;
405			FILE *f;
406			char destblklst = (char )malloc( strlen(DESTBLOCK)+1 );
407			char *destblk;
408
409			from = buf_new();
410			line = buf_new();
411			field = buf_new();
412			content = buf_new();
413			addr = buf_new();
414
415			buf_rewind(message);
416			while (buf_getheader(message, field, content) == 0)
417			if (bufieq(field, "from"))
418			buf_set(from, content);
419			else if (bufieq(field, "subject"))
420	rabbi	30	buf_cat(message, content);
421			/* Append the subject to the message body so destination block requests
422			in the subject line work too (we process the body a few lines down) */
423	rabbi	1	while (buf_getline(message, line) != -1)
424			if (bufifind(line, "destination-block")) {
425			buf_clear(addr);
426			request = 1;
427	rabbi	52	{
428	rabbi	1	int c = 0;
429
430			while (!strileft(line->data + line->ptr, "block"))
431			line->ptr++;
432	rabbi	52	while (c != ' ' && c != -1)
433	rabbi	1	c = tolower(buf_getc(line));
434			while (c == ' ')
435			c = buf_getc(line);
436	rabbi	52	if (c != -1)
437			do {
438			buf_appendc(addr, c);
439			c = buf_getc(line);
440			} while (c > ' ');
441	rabbi	48	}
442	rabbi	55	if (addr->length == 0) {
443	rabbi	54	rfc822_addr (from, addr);
444	rabbi	55	buf_chop(addr);
445			}
446	rabbi	1	if (bufieq(addr, REMAILERADDR)) {
447			errlog(LOG, "Ignoring blocking request for %b from %b.\n", addr, from);
448			return (2);
449			}
450			if (buf_ieq(addr, from))
451			errlog(NOTICE, "Blocking request for %b\n", addr);
452			else
453			errlog(NOTICE, "Blocking request for %b from %b\n", addr, from);
454			if (AUTOBLOCK) {
455			buf_clear(line);
456			rfc822_addr(addr, line);
457	rabbi	59	if (line->length == 0) {
458			errlog(LOG, "Nothing to block after rfc822_addr().\n");
459	rabbi	1	} else
460	rabbi	59	if (bufleft(line, "/")) {
461			errlog(LOG, "Ignoring blocking request: %b is a regex.\n", addr);
462			} else {
463			if (strchr(line->data, '@') && strchr(strchr(line->data, '@'), '.')) {
464			strcpy( destblklst, DESTBLOCK );
465			destblk = strtok( destblklst, " " );
466			f = mix_openfile( destblk, "a" );
467			free( destblklst );
468			if (f != NULL) {
469			lock(f);
470
471			buf_chop(line);
472			sendinfofile(BLOCKFILE, NULL, line, NULL);
473			if (line->length) {
474			fprintf(f, "%s\n", line->data);
475			} else
476			errlog(NOTICE, "%b already blocked.\n", addr);
477			unlock(f);
478			fclose(f);
479			} else
480			errlog(ERRORMSG, "Can't write to %s.\n", DESTBLOCK);
481			} else
482			errlog(WARNING, "Invalid address not added to %s: %b\n", DESTBLOCK,
483			addr);
484			}
485	rabbi	1	}
486			}
487			return (request);
488			}
489
490
491			int idexp(void)
492			{
493			FILE *f;
494			BUFFER *b;
495			long now, then;
496			LOCK *i;
497	rabbi	82	idlog_t idbuf;
498			long fpi = sizeof(idlog_t), fpo = sizeof(idlog_t);
499	rabbi	1
500			if (IDEXP == 0)
501			return (0);
502
503			b = buf_new();
504	rabbi	82	f = mix_openfile(IDLOG, "rb+");
505	rabbi	1	if (f == NULL)
506			return (-1);
507			i = lockfile(IDLOG);
508			now = time(NULL);
509	rabbi	82	if (fread(&idbuf, 1, sizeof(idlog_t), f) != sizeof(idlog_t)) { /* replace first line */
510			fclose(f);
511			unlockfile(i);
512			return (-1);
513			}
514			then = idbuf.time;
515			memset(idbuf.id,0,sizeof(idbuf.id));
516			idbuf.time = now - IDEXP;
517			fseek(f,0,SEEK_SET);
518			fwrite(&idbuf,1,sizeof(idlog_t),f);
519			fseek(f,fpi,SEEK_SET); /* this fseek does nothing, but MSVC CRT happilly reads past EOF (!!!) if we do not fseek here :-/ */
520			while (fread(&idbuf, 1, sizeof(idlog_t), f) == sizeof(idlog_t)) {
521			fpi+=sizeof(idlog_t);
522			then = idbuf.time;
523	weaselp	170	if (now - then < IDEXP &&
524			now - then > - SECONDSPERDAY * 180 )
525			/* also expire packets that are dated more than half a year in the future.
526			* That way we get rid of invalid packets introduced by the switch to a
527			* binary id.log. */
528	rabbi	82	{
529			fseek(f,fpo,SEEK_SET);
530			fwrite(&idbuf,1,sizeof(idlog_t),f);
531			fpo += sizeof(idlog_t);
532			fseek(f,fpi,SEEK_SET);
533			}
534	rabbi	1	}
535	rabbi	82	#ifdef _MSC
536			chsize(fileno(f),fpo);
537	rabbi	262	#else /* end of _MSC */
538	rabbi	82	ftruncate(fileno(f),fpo);
539	rabbi	262	#endif /* else if not _MSC */
540	rabbi	1	fclose(f);
541			unlockfile(i);
542	rabbi	73	buf_free(b);
543	rabbi	1	return (0);
544			}