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.14 2002/03/09 02:45:34 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
#include <io.h>
#endif
#ifndef _MSC
#include <dirent.h>
#endif
#include <assert.h>

int blockrequest(BUFFER *message);

#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);
    }
    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);
    }
    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 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(msg, f);
    fclose(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
  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
  return (0);
}

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

  d = opendir(POOLDIR);
  if (d != NULL)
    for (;;) {
      e = readdir(d);
      if (e == NULL)
        break;
      if (e->d_name[0] == 'p') {
        if (stat(e->d_name, &sb) == 0 &&
            time(NULL) - sb.st_mtime > PACKETEXP) {
          errlog(NOTICE, "Expiring partial message %s.\n",
                 e->d_name);
          strncpy(path, POOLDIR, PATHMAX);
          strncat(path, DIRSEPSTR, PATHMAX);
          strncat(path, e->d_name, PATHMAX);
          unlink(path);
        }
      }
    }
  closedir(d);
}

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

  /* mailbox is "|program", "user@host", "stdout" 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(message, NULL, content);
  isloop:
    buf_free(field);
    buf_free(content);
  } 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;
  char line[LINELEN];
  LOCK *i;

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

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