tpool.c - mixmaster - mixmaster 3.0 patched for libressl
(HTM) git clone git://parazyd.org/mixmaster.git
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
---
tpool.c (22338B)
---
1 /* Mixmaster version 3.0 -- (C) 1999 - 2006 Anonymizer Inc. and others.
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 Send messages from pool
9 $Id: pool.c 934 2006-06-24 13:40:39Z rabbi $ */
10
11 #include "mix3.h"
12 #include <stdlib.h>
13 #include <string.h>
14 #include <ctype.h>
15 #include <sys/types.h>
16 #include <time.h>
17 #ifdef POSIX
18 #include <unistd.h>
19 #else /* end of POSIX */
20 #include <io.h>
21 #endif /* else if not POSIX */
22 #ifndef _MSC
23 #include <dirent.h>
24 #endif /* not _MSC */
25 #include <assert.h>
26 #include <sys/stat.h>
27 #include <sys/types.h>
28
29 #ifdef USE_PCRE
30 #include "pcre.h"
31 #endif /* USE_PCRE */
32
33 int msg_send(char *name);
34
35 int mix_send(void)
36 {
37 return (mix_regular(FORCE_POOL));
38 }
39
40 /* Message pool: Unix DOS
41 * latent messages: l* *.lat
42 * pooled messages: m* *.msg
43 * messages to be sent: s* *.snd
44 * temporary files: t* *.tmp
45 * files in user editor: x*
46 * incoming mail: i* *.inf
47 * partial messages: p* p*.*
48 * error messages: e* *.err
49 * outgoing messages: out *.txt (to be used by external program)
50 */
51
52 static int is(char *path, char *type)
53 {
54 #ifdef SHORTNAMES
55 int s;
56
57 s = strlen(path);
58 if (s <= 4)
59 return 0;
60 return (path[s - 4] == '.' && streq(path + s - 3, type));
61 #else /* end of SHORTNAMES */
62 return (path[0] == type[0]);
63 #endif /* else if not SHORTNAMES */
64 }
65
66 static void mv(char *name, char *newtype)
67 {
68 char old[PATHMAX], new[PATHMAX];
69
70 sprintf(old, "%s%c%s", POOLDIR, DIRSEP, name);
71 #ifdef SHORTNAMES
72 assert(strlen(name) > 4);
73 strcpy(name + strlen(name) - 3, newtype);
74 #else /* end of SHORTNAMES */
75 name[0] = newtype[0];
76 #endif /* else if not SHORTNAMES */
77 sprintf(new, "%s%c%s", POOLDIR, DIRSEP, name);
78 rename(old, new);
79 }
80
81 int latent_read(void)
82 {
83 char path[PATHMAX];
84 DIR *d;
85 FILE *f;
86 struct dirent *e;
87 int size = 0;
88 long now, then;
89
90 now = time(NULL);
91 d = opendir(POOLDIR);
92 if (d != NULL)
93 for (;;) {
94 e = readdir(d);
95 if (e == NULL)
96 break;
97 if (is(e->d_name, "lat")) {
98 sprintf(path, "%s%c%s", POOLDIR, DIRSEP, e->d_name);
99 f = fopen(path, "rb");
100 if (f != NULL) {
101 fscanf(f, "%*d %ld\n", &then);
102 fclose(f);
103 if (now > then)
104 mv(e->d_name, "msg");
105 }
106 }
107 }
108 closedir(d);
109 return (size);
110 }
111
112 int infile_read(void)
113 {
114 char path[PATHMAX];
115 BUFFER *msg;
116 DIR *d;
117 FILE *f;
118 struct dirent *e;
119 int size = 0;
120
121 msg = buf_new();
122 d = opendir(POOLDIR);
123 if (d != NULL)
124 for (;;) {
125 e = readdir(d);
126 if (e == NULL)
127 break;
128 if (is(e->d_name, "inf")) {
129 mv(e->d_name, "tmp");
130 sprintf(path, "%s%c%s", POOLDIR, DIRSEP, e->d_name);
131 f = fopen(path, "rb");
132 if (f != NULL) {
133 buf_clear(msg);
134 buf_read(msg, f);
135 fclose(f);
136 unlink(path);
137 mix_decrypt(msg);
138 }
139 }
140 }
141 closedir(d);
142 buf_free(msg);
143 return (size);
144 }
145
146 int mailin_maildir_one(char *dir)
147 /** Read mails from one directory
148 This function reads all files from the directory passed and passes
149 them on to mix_decrypt(). Each file is unlinked when its is read.
150
151 @param dir The directory in which files are to be read. No path finding
152 voodoo is done to the path; It's passed it opendir() as is.
153 @author PP
154 @return Number of files read
155 */
156 {
157 BUFFER *msg;
158 DIR *d;
159 FILE *f;
160 struct dirent *e;
161 int size = 0;
162 char path[PATHMAX];
163
164 msg = buf_new();
165 d = opendir(dir);
166 if (d != NULL)
167 for (;;) {
168 e = readdir(d);
169 if (e == NULL)
170 break;
171 if (e->d_name[0] != '.') {
172 sprintf(path, "%s%c%s", dir, DIRSEP, e->d_name);
173 path[PATHMAX-1]='\0';
174 f = fopen(path, "rb");
175 if (f != NULL) {
176 buf_clear(msg);
177 buf_read(msg, f);
178 fclose(f);
179 unlink(path);
180 mix_decrypt(msg);
181 size++;
182 }
183 }
184 }
185 closedir(d);
186 buf_free(msg);
187 return (size);
188 }
189
190 int mailin_maildir(char *maildir)
191 /** Read mails from a mail folder in Maildir format
192 Reads all files from the Maildir using mailin_maildir_one().
193 All mails are removed after this function returns.
194
195 @param maildir The Maildir to open. mixfile() is called to normalize the path.
196 @author PP
197 @return 0
198 */
199 {
200 char normalized[PATHMAX];
201 char path[PATHMAX];
202
203 mixfile(normalized, maildir);
204 sprintf(path, "%s%c%s", normalized, DIRSEP, "new");
205 path[PATHMAX-1]='\0';
206 mailin_maildir_one(path);
207 sprintf(path, "%s%c%s", normalized, DIRSEP, "cur");
208 path[PATHMAX-1]='\0';
209 mailin_maildir_one(path);
210 return (0);
211 }
212
213 int mailin_mbox(char *path)
214 /** Read mails from a mail folder in mbox format
215 Reads all messages from the mbox filder passes as an argument. Mails are
216 handed over to mix_decrypt. After all mails have been read the mailbox
217 is truncated to zero size i.e. all mails are deleted. The mbox is
218 locked using lock() and unlock() during this operation.
219
220 @param maildir Path to the mbox mail folder.
221 @author PP
222 @return 0 on sucess, other on error
223 */
224 {
225 char line[LINELEN];
226 FILE *f;
227 int state, eof;
228 BUFFER *msg;
229 int err=0;
230
231 msg = buf_new();
232
233 f = mix_openfile(path, "r+");
234 if (f != NULL) {
235 if (lock(f) != 0) {
236 /* Locking failed */
237 err = 1;
238 goto end;
239 }
240 /* State machine
241 * 1 - Look for the first ^From_ line
242 * 2 - add messages as they come
243 */
244 state = 1;
245 eof = 0;
246 for(;;) {
247 if (fgets(line, sizeof(line), f) == NULL)
248 eof = 1;
249
250 switch (state) {
251 case 1:
252 /* Initial state - Looking for first appearance of From_ */
253 if (eof)
254 goto end_state;
255 if (strleft(line, "From ")) {
256 #if 0
257 buf_appends(msg, line);
258 #endif /* 0 */
259 state = 2;
260 break;
261 };
262 break;
263 case 2:
264 /* Within one mail - Adding lines to mail until we encounter another From_ or eof */
265 if (eof || strleft(line, "From ")) {
266 mix_decrypt(msg);
267 buf_clear(msg);
268 }
269 if (eof)
270 goto end_state;
271 if (!strleft(line, "From "))
272 buf_appends(msg, line);
273 break;
274 default:
275 assert(0);
276 err=1;
277 goto end_state;
278 }
279 }
280 end_state:
281 #ifndef WIN32
282 rewind(f);
283 ftruncate(fileno(f), 0);
284 #else /* end of not WIN32 */
285 chsize(fileno(f), 0);
286 #endif /* else if WIN32 */
287 unlock(f);
288 fclose(f);
289 }
290 end:
291 buf_free(msg);
292 return (err);
293 }
294
295 /** Process MAILIN if applicable
296 If MAILIN is defined this function calls either mailin_maildir() or
297 mailin_mbox() depending on whether the last character of MAILIN
298 is DIRSEP.
299
300 @param mailbox Path to the mbox or Maildir mail folder.
301 @author PP
302 @return 0 on sucess, other on error
303 */
304 int mailin(char *mailbox)
305 {
306 if (mailbox != NULL && (strcmp(mailbox, "") != 0))
307 if (mailbox[strlen(mailbox)-1] == DIRSEP)
308 return mailin_maildir(mailbox);
309 else
310 return mailin_mbox(mailbox);
311 else
312 return 0;
313 };
314
315 int pool_add(BUFFER *msg, char *type)
316 {
317 char path[PATHMAX], pathtmp[PATHMAX];
318 FILE *f;
319 int err = -1;
320
321 f = pool_new(type, pathtmp, path);
322 if (f != NULL) {
323 err = buf_write(msg, f);
324 fclose(f);
325 }
326 if (err == 0) {
327 rename(pathtmp, path);
328 errlog(DEBUGINFO, "Added %s file to pool.\n", type);
329 }
330 return (err);
331
332 }
333
334 FILE *pool_new(char *type, char *tmpname, char *path)
335 {
336 FILE *f;
337 struct stat buf;
338 int err;
339
340 assert(strlen(type) == 3);
341 #ifdef SHORTNAMES
342 sprintf(tmpname, "%s%c%02x%02x%02x%02x.tmp", POOLDIR, DIRSEP, rnd_byte(), rnd_byte(),
343 rnd_byte(), rnd_byte());
344 strcpy(path, tmpname);
345 memcpy(path + strlen(path) - 3, type, 3);
346 #else /* end of SHORTNAMES */
347 sprintf(tmpname, "%s%ct%02x%02x%02x%02x%02x%02x%01x", POOLDIR, DIRSEP, rnd_byte(),
348 rnd_byte(), rnd_byte(), rnd_byte(), rnd_byte(),
349 rnd_byte(), rnd_byte() & 15);
350 strcpy(path, tmpname);
351 strrchr(path, DIRSEP)[1] = type[0];
352 #endif /* else if not SHORTNAMES */
353 err = stat(tmpname, &buf);
354 if (err == 0)
355 errlog(WARNING, "Overwriting file %s\n", tmpname);
356 f = fopen(tmpname, "wb");
357 if (f == NULL)
358 errlog(ERRORMSG, "Error creating temporary file %s\n", tmpname);
359 return (f);
360 }
361
362 int pool_read(BUFFER *pool)
363 {
364 DIR *d;
365 struct dirent *e;
366 int size = 0;
367
368 d = opendir(POOLDIR);
369 if (d != NULL) {
370 for (;;) {
371 e = readdir(d);
372 if (e == NULL)
373 break;
374 if (is(e->d_name, "msg")) {
375 if (pool != NULL) {
376 buf_appends(pool, e->d_name);
377 buf_appendc(pool, 0);
378 }
379 size++;
380 }
381 }
382 closedir(d);
383 } else
384 errlog(WARNING, "Error reading pool dir %s\n", POOLDIR);
385 return (size);
386 }
387
388 void pool_dosend(void)
389 {
390 DIR *d;
391 struct dirent *e;
392 char path[PATHMAX];
393
394 d = opendir(POOLDIR);
395 if (d != NULL) {
396 for (;;) {
397 e = readdir(d);
398 if (e == NULL)
399 break;
400 if (is(e->d_name, "snd")) {
401 sendmail_begin();
402 mv(e->d_name, "tmp");
403 sprintf(path, "%s%c%s", POOLDIR, DIRSEP, e->d_name);
404 if (msg_send(path) == 1)
405 mv(e->d_name, "err");
406 }
407 }
408 closedir(d);
409 } else
410 errlog(WARNING, "Error reading pool dir %s\n", POOLDIR);
411 sendmail_end();
412 }
413
414 int process_mailin()
415 {
416 mailin(MAILIN);
417 infile_read();
418 return(0);
419 }
420
421 int create_dummy_mailout()
422 {
423 while (rnd_number(100) < OUTDUMMYP) {
424 errlog(DEBUGINFO, "Generating dummy message with outgoing mail.\n");
425 if (mix_encrypt(MSG_NULL, NULL, NULL, 1, NULL) == -1)
426 return -1;
427 }
428 return 0;
429 }
430
431 int pool_send(void)
432 {
433 int size, max, i, r;
434 BUFFER *pool;
435 long int *ptr;
436
437 create_dummy_mailout();
438
439 latent_read();
440 pool = buf_new();
441 size = pool_read(pool);
442 if (size <= POOLSIZE)
443 goto end;
444
445 ptr = malloc(size * sizeof(long int));
446
447 if (ptr == NULL)
448 goto end;
449 for (i = 0; i < size; i++) {
450 ptr[i] = pool->ptr;
451 buf_getline(pool, NULL);
452 }
453
454 max = size * RATE / 100; /* send no more than RATE % of the messages */
455 if (max < 0)
456 max = 1;
457
458 for (i = 0; i < size - POOLSIZE && i < max; i++) {
459 do
460 r = rnd_number(size); /* chose a new random message */
461 while (is(pool->data + ptr[r], "snd"));
462 mv(pool->data + ptr[r], "snd");
463 }
464 stats_out(size - --i);
465 pool_dosend();
466 free(ptr);
467
468 end:
469 buf_free(pool);
470 return (size);
471 }
472
473 int msg_send(char *name)
474 {
475 FILE *f;
476 int type = -1;
477 BUFFER *m, *addr;
478 int err = 0;
479 char line[LINELEN];
480 int userfrom = 0;
481
482 m = buf_new();
483 addr = buf_new();
484 if ((f = fopen(name, "rb")) == NULL) {
485 err = -1;
486 goto end;
487 }
488 fscanf(f, "%d %*d\n", &type);
489 if (type == INTERMEDIATE) {
490 fgets(line, sizeof(line), f);
491 buf_sets(addr, line);
492 buf_chop(addr);
493 err = buf_read(m, f);
494 if (err == -1)
495 goto end;
496 err = mix_armor(m);
497 if (err == -1)
498 goto end;
499 err = sendmail(m, REMAILERADDR, addr);
500 stats_log(3);
501 } else if (type == MSG_MAIL || type == MSG_POST) {
502 err = buf_read(m, f);
503 if (err == -1)
504 goto end;
505 if (MIDDLEMAN && ! allowmessage(m)) {
506 mix2_encrypt(type, m, FORWARDTO, 1, 1, NULL);
507 stats_log(6);
508 } else {
509 err = filtermsg(m);
510 if (err == 1)
511 userfrom = 1, err = 0;
512 if (err != -1) {
513 /* message has recipients */
514 errlog(DEBUGINFO, "Sending message (%ld bytes)\n", m->length);
515
516 if (type == MSG_MAIL) {
517 err = sendmail(m, userfrom ? NULL : ANONNAME, NULL);
518 stats_log(4);
519 } else if (type == MSG_POST) {
520 if (strchr(NEWS, '@') && !strchr(NEWS, ' ')) {
521 errlog(LOG, "Mailing article to %s.\n", NEWS);
522 buf_sets(addr, NEWS);
523 err = sendmail(m, userfrom ? NULL : ANONNAME, addr);
524 } else if (NEWS[0] != '\0') {
525 FILE *f;
526
527 f = openpipe(NEWS);
528 if (f == NULL)
529 goto end;
530 errlog(LOG, "Posting article.\n");
531 if (!userfrom)
532 fprintf(f, "From: %s\n", ANONNAME);
533 if (ORGANIZATION[0] != '\0')
534 fprintf(f, "Organization: %s\n", ORGANIZATION);
535 buf_write(m, f);
536 closepipe(f);
537 } else
538 errlog(NOTICE, "Rejecting news article.\n");
539 stats_log(5);
540 }
541 } else
542 errlog(ERRORMSG, "Bad message file.\n");
543 }
544 }
545 end:
546 if (f != NULL)
547 fclose(f);
548 if (err != 1) /* problem sending mail */
549 unlink(name);
550 buf_free(m);
551 buf_free(addr);
552 return (err);
553 }
554
555 int allowmessage(BUFFER *in)
556 /* Only called if remailer is middleman. Checks whether all Recipient
557 * addresses are in dest.allow. If yes return 1; 0 otherwhise
558 */
559 {
560 BUFFER *out, *allow, *allow2, *line, *line2;
561 int err=1;
562 FILE *f;
563
564 allow = buf_new();
565 allow2 = buf_new();
566 out = buf_new();
567 line = buf_new();
568 line2 = buf_new();
569
570 f = mix_openfile(DESTALLOW, "r");
571 if (f != NULL) {
572 buf_read(allow, f);
573 fclose(f);
574 }
575 f = mix_openfile(DESTALLOW2, "r");
576 if (f != NULL) {
577 buf_read(allow2, f);
578 fclose(f);
579 buf_cat(allow, allow2);
580 }
581
582 /* Do header lines */
583 while (buf_getline(in, line) == 0) {
584 for (;;) {
585 buf_lookahead(in, line2);
586 if (!bufleft(line2, " ") && !bufleft(line2, "\t"))
587 break;
588 buf_getline(in, line2);
589 buf_cat(line, line2);
590 }
591
592 if (bufileft(line, "to:") || bufileft(line, "cc:") ||
593 bufileft(line, "bcc:") || bufileft(line, "newsgroups:"))
594 if (! doallow(line, allow))
595 err = 0;
596
597 if (line->length > 0) {
598 if (!buffind(line, ":"))
599 buf_appends(out, "X-Invalid: ");
600 buf_cat(out, line);
601 buf_nl(out);
602 }
603 }
604 buf_nl(out);
605
606 /* Rest of the message */
607 buf_append(out, in->data + in->ptr, in->length - in->ptr);
608
609 buf_move(in, out);
610 buf_free(out);
611 buf_free(allow);
612 buf_free(allow2);
613 buf_free(line);
614 buf_free(line2);
615 return (err);
616 }
617
618 int doallow(BUFFER *line, BUFFER *filter)
619 /* line is a To, CC or BCC line.
620 * problem is: there may be multiple addresses in one header
621 * line but we only want to allow if _all_ are allowed
622 *
623 * So to not send direct if we do not want, we _never_ send
624 * direct if there is more than one address: This is
625 * assumed to be the case when there is a
626 * comma in the header line.
627 *
628 * this should probably be rewritten somehwhen. therefore: FIXME
629 *
630 * returns: 1 if allowed
631 * 0 if message should be send indirectly
632 */
633 {
634 if (strchr( line->data, ',')) return 0;
635 return doblock(line, filter, 0);
636 }
637
638 int filtermsg(BUFFER *in)
639 {
640 BUFFER *out, *line, *line2, *mboundary, *block, *filter, *mid;
641 FILE *f;
642 int from = 0, dest = 0;
643 int inbinary = 0, inpgp = 0, l = 80;
644 int err = -1;
645
646 line = buf_new();
647 line2 = buf_new();
648 filter = buf_new();
649 mid = buf_new();
650 mboundary = buf_new();
651 out = buf_new();
652 block = NULL;
653
654 if (SIZELIMIT > 0 && in->length > SIZELIMIT * 1024) {
655 errlog(NOTICE, "Message rejected: %ld bytes\n", in->length);
656 goto end;
657 }
658
659 block = readdestblk( );
660 if ( !block ) block = buf_new( );
661
662 f = mix_openfile(HDRFILTER, "r");
663 if (f != NULL) {
664 buf_read(filter, f);
665 fclose(f);
666 }
667
668 f = mix_openfile(DISCLAIMFILE, "r");
669 if (f != NULL) {
670 buf_read(out, f);
671 fclose(f);
672 } else {
673 if (strfind(DISCLAIMER, "%s"))
674 buf_appendf(out, DISCLAIMER, COMPLAINTS);
675 else
676 buf_appends(out, DISCLAIMER);
677 }
678
679 while (buf_getline(in, line) == 0) {
680 for (;;) {
681 buf_lookahead(in, line2);
682 if (!bufleft(line2, " ") && !bufleft(line2, "\t"))
683 break;
684 buf_getline(in, line2);
685 buf_cat(line, line2);
686 }
687
688 if (bufileft(line, "to:") || bufileft(line, "cc:") ||
689 bufileft(line, "bcc:") || bufileft(line, "newsgroups:"))
690 if (doblock(line, block, 1) == 0)
691 dest++;
692 if (doblock(line, filter, 1) == -1)
693 goto end;
694 if (bufileft(line, "from:"))
695 from = 1;
696
697 if (bufileft(line, "content-type:") && bufileft(line, "multipart"))
698 get_parameter(line, "boundary", mboundary);
699
700 if (line->length > 0) {
701 if (!buffind(line, ":"))
702 buf_appends(out, "X-Invalid: ");
703 buf_cat(out, line);
704 buf_nl(out);
705 }
706 }
707
708 if (MID[0] != '\0' && tolower(MID[0]) != 'n') {
709 char txt[LINELEN];
710
711 digestmem_md5(in->data + in->ptr, in->length - in->ptr, mid);
712 id_encode(mid->data, txt);
713
714 if (MID[0] == '@')
715 strcatn(txt, MID, sizeof(txt));
716 else {
717 if (strchr(REMAILERADDR, '@'))
718 strcatn(txt, strchr(REMAILERADDR, '@'), sizeof(txt));
719 else if (strchr(COMPLAINTS, '@'))
720 strcatn(txt, strchr(COMPLAINTS, '@'), sizeof(txt));
721 }
722 buf_appendf(out, "Message-ID: <%s>\n", txt);
723 }
724 buf_nl(out);
725
726 if (from) {
727 /* prepend Sender line to message header */
728 buf_setf(line, "Sender: %s\n", ANONNAME);
729 buf_cat(line, out);
730 buf_move(out, line);
731
732 f = mix_openfile(FROMDSCLFILE, "r");
733 if (f != NULL) {
734 buf_read(out, f);
735 fclose(f);
736 } else
737 buf_appends(out, FROMDISCLAIMER);
738 }
739
740 #if 0
741 buf_append(out, in->data + in->ptr, in->length - in->ptr);
742 #endif /* 0 */
743 while (buf_getline(in, line) != -1) {
744 if (boundary(line, mboundary)) {
745 buf_cat(out, line);
746 buf_nl(out);
747 while (buf_getline(in, line) == 0) { /* MIME body part header */
748 err = doblock(line, filter, 1);
749 if (err == -1)
750 goto end;
751 buf_cat(out, line);
752 buf_nl(out);
753 }
754 }
755 if (BINFILTER && l > 20 && line->length == l &&
756 (bufleft(line, "M") || !buffind(line, " ")))
757 inbinary++;
758 else
759 inbinary = 0, l = line->length;
760 if (bufileft(line, begin_pgp) || bufileft(line, begin_key))
761 inpgp = 1;
762 if (bufileft(line, end_pgp) || bufileft(line, end_key))
763 inpgp = 0;
764 if (inbinary < 10 || inpgp) {
765 buf_cat(out, line);
766 buf_nl(out);
767 } else if (inbinary == 10) {
768 errlog(NOTICE, "Binary message detected.\n");
769 if (BINFILTER > 1) {
770 err = -1;
771 goto end;
772 }
773 buf_appends(out, BINDISCLAIMER);
774 buf_nl(out);
775 }
776 }
777
778 f = mix_openfile(MSGFOOTERFILE, "r");
779 if (f != NULL) {
780 buf_read(out, f);
781 fclose(f);
782 } else
783 buf_appends(out, MSGFOOTER);
784
785 /* return 1 for user supplied From line */
786 err = from;
787 if (dest == 0)
788 err = -1;
789
790 end:
791 buf_move(in, out);
792 buf_free(out);
793 buf_free(line);
794 buf_free(line2);
795 if (block) buf_free(block);
796 buf_free(filter);
797 buf_free(mid);
798 buf_free(mboundary);
799 return (err);
800 }
801
802 BUFFER *readdestblk( )
803 {
804 char *destblklst = (char *)malloc( strlen( DESTBLOCK )+1 );
805 char *destblk = NULL;
806 FILE *f;
807 BUFFER *addresses;
808 BUFFER *temp;
809 int err = 1;
810
811 addresses = buf_new( );
812 temp = buf_new( );
813
814 strcpy( destblklst, DESTBLOCK );
815
816 while ( (destblk = strtok( destblk ? NULL : destblklst, " " )) )
817 {
818 if ( (f = mix_openfile( destblk, "r" )) )
819 {
820 if ( !buf_read( temp, f ) )
821 {
822 buf_cat( addresses, temp );
823 err = 0;
824 }
825 fclose( f );
826 }
827 }
828
829 free( destblklst );
830 buf_free( temp );
831
832 if ( err ) { buf_free( addresses ); return NULL; }
833 else return addresses;
834 }
835
836 int doblock(BUFFER *line, BUFFER *filter, int logandreset)
837 /* logandreset is usually 0
838 * it is only set to 1 when called from doallow
839 * which only checks whether messages are allowed to
840 * be sent directly
841 */
842 {
843 int block = 0;
844 BUFFER *pattern, *result;
845 char *t;
846 #ifdef USE_PCRE
847 int errptr, match;
848 const char *error;
849 pcre *compiled;
850 int ovector[21];
851 char *newstr;
852 #endif /* USE_PCRE */
853
854 pattern = buf_new();
855 result = buf_new();
856 assert(filter != NULL);
857
858 buf_rewind(filter);
859 while (buf_getline(filter, pattern) != -1)
860 if (pattern->length > 0 && !bufleft(pattern, "#")) {
861 if (bufleft(pattern, "/") && (t = strchr(pattern->data + 1, '/'))
862 != NULL) {
863 #ifdef USE_PCRE
864 *t = '\0';
865 compiled = pcre_compile(pattern->data + 1, PCRE_CASELESS,
866 &error, &errptr
867 #ifndef USE_PCRE_OLD
868 ,NULL
869 #endif /* not USE_PCRE_OLD */
870 );
871 if (compiled) {
872 match = pcre_exec(compiled, NULL, line->data,
873 line->length,
874 #if (PCRE_MAJOR == 2 && PCRE_MINOR >= 06)
875 0,
876 #endif /* (PCRE_MAJOR == 2 && PCRE_MINOR >= 06) */
877 #if (PCRE_MAJOR >= 3)
878 0,
879 #endif /* (PCRE_MAJOR >= 3) */
880 0, ovector, sizeof(ovector) / sizeof(int));
881 free(compiled);
882
883 if (match < -1) {
884 *t = '/';
885 errlog(ERRORMSG, "Bad regexp %b\n", pattern);
886 }
887 else if (match >= 0) {
888 /* "/pattern/q" kills the entire message */
889 if (logandreset
890 && strlen(pattern->data + 1) + 1 < pattern->length
891 && pattern->data[pattern->length - 1] == 'q') {
892 *t = '/';
893 errlog(NOTICE,
894 "Message rejected: %b matches %b.\n", line, pattern);
895 block = -1;
896 break;
897 }
898 if (strlen(pattern->data + 1) + 1 < pattern->length
899 && pattern->data[pattern->length - 1] == '/') {
900 pattern->data[pattern->length - 1] = '\0';
901 newstr = pattern->data + strlen(pattern->data) + 1;
902 buf_reset(result);
903 buf_append(result, line->data, ovector[0]);
904 while (strchr(newstr, '$')) {
905 strchr(newstr, '$')[0] = '\0';
906 buf_appends(result, newstr);
907 newstr += strlen(newstr) + 1;
908 if (*newstr >= '1' && *newstr <= '9')
909 buf_append(result, line->data +
910 ovector[2 * (*newstr - '0')],
911 ovector[2 * (*newstr - '0') + 1] -
912 ovector[2 * (*newstr - '0')]);
913 newstr++;
914 }
915 buf_appends(result, newstr);
916 buf_appends(result, line->data + ovector[1]);
917 buf_clear(line);
918 buf_appends(line, result->data);
919 } else {
920 block = 1;
921 *t = '/';
922 if (logandreset)
923 errlog(NOTICE, "Blocked header line: %b matches %b.\n",
924 line, pattern);
925 }
926 }
927 } else {
928 *t = '/';
929 errlog(ERRORMSG, "Bad regexp %b\n", pattern);
930 }
931 #else /* end of USE_PCRE */
932 errlog(ERRORMSG, "No regexp support! Ignoring %b\n", pattern);
933 #endif /* else if not USE_PCRE */
934 } else if (bufifind(line, pattern->data)) {
935 if (logandreset )
936 errlog(NOTICE, "Blocked header line: %b matches %b.\n",
937 line, pattern);
938 block = 1;
939 }
940 }
941
942 if (logandreset && (block == 1))
943 buf_reset(line);
944
945 buf_free(pattern);
946 buf_free(result);
947 return (block);
948 }
949
950 int mix_armor(BUFFER *in)
951 {
952 BUFFER *out, *md;
953
954 md = buf_new();
955 out = buf_new();
956
957 if (in->length != 20480)
958 return (-1);
959
960 buf_sets(out, "\n::\n");
961 buf_appends(out, remailer_type);
962 buf_appends(out, VERSION);
963 buf_nl(out);
964 buf_nl(out);
965 buf_appends(out, begin_remailer);
966 buf_nl(out);
967 buf_appends(out, "20480\n");
968 digest_md5(in, md);
969 encode(md, 0);
970 buf_cat(out, md);
971 buf_nl(out);
972 encode(in, 40);
973 buf_cat(out, in);
974 buf_appends(out, end_remailer);
975 buf_nl(out);
976
977 buf_move(in, out);
978 buf_free(out);
979 buf_free(md);
980 return (0);
981 }