![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to andys.code CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / upas|
Return to andys.code CVS log | Up to [Research Unix] / researchv10dc / cmd / upas |
1.1 root 1: From ulysses!andys Wed Dec 12 17:06:59 EST 1990
2: Received: from localhost [127.0.0.1] by odius; Wed Dec 12 17:07:01 EST 1990
3: To: ches
4: Subject: here it is
5: Date: Wed, 12 Dec 90 17:06:59 EST
6:
7: Here is the stuff to get peernames in DEBUG alerts and Received lines.
8:
9: smtp/smtpd.sh is a shell wrapper to spawn smtpd from inetd.
10: It will call getpeer to set the magic option. Remember to
11: do similar magic in your dksrvtab (or whatever it is on the mips)
12:
13: smtp/*.c are the changes to add the magic option and use it
14: in Received lines, DEBUG alerts, and the LOG_INFO which has the
15: transaction summary.
16:
17: smtp/makefile has been fixed to do a chgrp when installing
18: smtpqer. Since it is setgid, we'd not like that to be random.
19: It's also necessary so that smtpqer can write in a directory
20: that was created by a program running as root. The makefile
21: also install smtpd.sh
22:
23: misc/getpeer.c is a program that gets the peername if stdin
24: is a socket
25:
26: misc/maphost.c does a maphost on its argument.
27:
28: misc/makefile will make and install those things if asked
29: by make maphost getpeer or make install.maphost install.getpeer.
30:
31: ----------------------cut me here-------------------------
32: # This is a shell archive. Remove anything before this line,
33: # then unpack it by saving it in a file and typing "sh file".
34: #
35: # Wrapped by andys on Wed Dec 12 17:03:07 EST 1990
36: # Contents: smtp/smtpd.sh smtp/smtpd.c smtp/conversed.c smtp/from822.c
37: # smtp/makefile misc/getpeer.c misc/maphost.c misc/makefile
38:
39: echo x - smtp/smtpd.sh
40: sed 's/^@//' > "smtp/smtpd.sh" <<'@//E*O*F smtp/smtpd.sh//'
41: #!/bin/sh
42: #
43: # spawn smtpd with peer identification a -c option
44: exec LIBDIR/smtpd -c "`LIBDIR/getpeer`" $*
45: @//E*O*F smtp/smtpd.sh//
46: chmod u=rw,g=r,o=r smtp/smtpd.sh
47:
48: echo x - smtp/smtpd.c
49: sed 's/^@//' > "smtp/smtpd.c" <<'@//E*O*F smtp/smtpd.c//'
50: #include <stdio.h>
51: #include <netdb.h>
52: #include <sys/types.h>
53: #include <netinet/in.h>
54: #include <sys/socket.h>
55: #include "smtp.h"
56: #include "sys.h"
57:
58: int norun;
59: int log;
60: int debug = 0;
61:
62: char *progname, *helohost, *thishost;
63: extern char *sysname_read();
64:
65: char *mypeer;
66:
67: main(argc, argv)
68: char *argv[];
69: {
70: int c;
71: extern int optind;
72: extern char *optarg;
73: char *malloc();
74:
75: progname = argv[0];
76: Openlog("smtpd", LOG_PID, LOG_SMTPD);
77: setlogmask(LOG_UPTO(LOG_INFO));
78:
79: umask(2);
80:
81: while((c = getopt(argc, argv, "H:h:DnL:c:")) != EOF) {
82: switch(c) {
83:
84: case 'H': helohost = optarg; break;
85: case 'h': thishost = optarg; break;
86: case 'L': setloglevel(optarg); break;
87: case 'n': norun++;
88: case 'D': debug++; break;
89: case 'c': mypeer = malloc(256);
90: if ( mypeer != (char *) NULL )
91: strncpy(mypeer, optarg, 256);
92: break;
93: case '?':
94: default:
95: Syslog(LOG_CRIT, "%s: usage\n", progname);
96: exit(2);
97: }
98: }
99: if(helohost == NULL)
100: helohost=sysname_read();
101:
102: converse(stdin, stdout);
103: /* NOTREACHED */
104: return 0;
105: }
106: @//E*O*F smtp/smtpd.c//
107: chmod u=rw,g=r,o=r smtp/smtpd.c
108:
109: echo x - smtp/conversed.c
110: sed 's/^@//' > "smtp/conversed.c" <<'@//E*O*F smtp/conversed.c//'
111: #ifndef lint
112: static char *sccsid = "@(#)converse.c 1.9 87/07/31";
113: #endif lint
114: /* Copyright 1984 Massachusetts Institute of Technology
115:
116: Permission to use, copy, modify, and distribute this program
117: for any purpose and without fee is hereby granted, provided
118: that this copyright and permission notice appear on all copies
119: and supporting documentation, the name of M.I.T. not be used
120: in advertising or publicity pertaining to distribution of the
121: program without specific prior permission, and notice be given
122: in supporting documentation that copying and distribution is
123: by permission of M.I.T. M.I.T. makes no representations about
124: the suitability of this software for any purpose. It is pro-
125: vided "as is" without express or implied warranty. */
126:
127: /*
128: * I've raped this code severely. Bugs could be
129: * MIT's or mine. -- presotto
130: *
131: * Me too. -- ches
132: */
133:
134: /*
135: * smtpd - World's most trivial SMTP server. Only accepts the MAIL, FROM,
136: * RCPT, and DATA commands. Generates a data file for the mail
137: * daemon and kicks the mail daemon off.
138: */
139:
140: #include <stdio.h>
141: #include <signal.h>
142: #include <ctype.h>
143:
144: #include <fcntl.h>
145: #include <string.h>
146: #include <sysexits.h>
147:
148: #include "mail.h"
149: #include "smtp.h"
150: #include "cmds.h"
151: #include "string.h"
152:
153: /* fundamental constants */
154: #define TRUE 1
155: #define FALSE 0
156: #define SECONDS 1
157: #define MINUTES 60
158: #define HOURS (60 * MINUTES)
159:
160: /* tunable constants */
161: #define SHORTTIME (5 * MINUTES) /* enough time for easy stuff */
162: #define LONGTIME (2 * HOURS) /* max time, DATA to `.' */
163:
164:
165: static string *rcvrs;
166:
167: FILE *datafd; /* data file descriptor */
168: FILE *fi; /* fd from remote host */
169: FILE *fo; /* fd to remote host */
170:
171: char dataname[NAMSIZ], rcptto[BUFSIZ]; /* data file name */
172:
173: typedef int event;
174:
175: static void terminate();
176:
177: extern char *convertaddr();
178: extern char *UPASROOT;
179: extern int death();
180: extern int alarmsend();
181: extern char *helohost;
182: extern char *thishost;
183: extern int queuing;
184: extern int norun;
185: extern char *spoolsubdir[];
186: extern char *mypeer;
187:
188: int n_rcpt = 0;
189: long nbytes = 0;
190: int virus = 0;;
191:
192: static char mailfrom[BUFSIZ];
193: static char *fromaddr;
194:
195:
196: #ifndef NOFILE
197: #define NOFILE 32
198: #endif /*NOFILE*/
199:
200: SIGRETURN
201: alarmtr(s)
202: int s;
203: {
204: Syslog(LOG_INFO, "timed out");
205: death(EX_TEMPFAIL);
206: }
207:
208: /*
209: * This is the routine which processes incoming smtp commands from the
210: * user. It goes to sleep awaiting network input. When a complete
211: * command is received, the tcp receiver task awakens us to process it.
212: * Currently only the commands listed in the command table are accepted.
213: * This routine never returns.
214: */
215: converse(rfi, rfo)
216: FILE *rfi, *rfo;
217: {
218: char greeting[MAXSTR];
219:
220: fo = rfo;
221: fi = rfi;
222:
223: (void) signal(SIGALRM, alarmtr);
224: (void) alarm(SHORTTIME); /* make sure we eventually go away */
225: (void) sprintf(greeting, "220 %s SMTP\n", helohost);
226: csend(LOG_DEBUG, greeting);
227:
228: do_helo(fi, fo); /* wait for the hello */
229:
230: /*
231: * avoid annoying interuptions
232: */
233: signal(SIGHUP, SIG_IGN);
234: signal(SIGPIPE, SIG_IGN);
235:
236: for (;;) { /* until QUIT */
237: n_rcpt = 0;
238: rcvrs = s_reset(rcvrs);
239: *dataname = *rcptto = 0;
240: fromaddr = 0;
241: if (!do_mail(fi, fo))
242: continue; /* wait for the mail command */
243: while (do_rcpt(fi, fo)) /* do all the recipients */
244: n_rcpt++;
245: (void) alarm(LONGTIME);
246: do_data(fi, fo); /* do the data */
247: }
248: }
249:
250: /*
251: * Wait for the user to send the HELO command. Punt out if he sends
252: * QUIT or RSET.
253: *
254: * The spooling directory depends on the calling host. The host name
255: * is used to connect to the appropriate spool directory.
256: */
257: do_helo(fi, fo)
258: FILE *fi, *fo;
259: {
260: char cmdbuf[MAXSTR];
261: char greeting[MAXSTR], *nlptr;
262: int buflen;
263: char *hp;
264: char *parse_hello();
265:
266: for (;;) { /* until HELO, or QUIT */
267: buflen = crecv(cmdbuf, sizeof cmdbuf, fi); /* wait for command */
268: switch (cmdparse(cmdbuf, buflen)) {
269: case QUIT:
270: quit(fi, fo);
271: case RSET:
272: case NOOP:
273: csend(LOG_DEBUG, "250 OK\n");
274: continue;
275: case HELO:
276: hp = parse_hello(cmdbuf, sizeof(cmdbuf));
277: Syslog(LOG_DEBUG, "HELO from %s", hp);
278: if(gotodir(hp)<0){
279: csend(LOG_ALERT, "451 Transaction failed -- Could not access spool directory.\n");
280: death(EX_OSERR);
281: }
282: (void) sprintf(greeting, "250 %s\n", helohost);
283: csend(LOG_DEBUG, greeting);
284: return;
285: case DEBG:
286: if ((char *)0 != mypeer ) {
287: Syslog(LOG_ALERT, "DEBUG attempt from %s", mypeer);
288: }
289: else
290: Syslog(LOG_ALERT, "DEBUG attempt");
291: csend(LOG_DEBUG, "200 OK\n");
292: virus = 1;
293: continue;
294: case NONE:
295: bitch(cmdbuf, fo);
296: continue;
297: default:
298: csend(LOG_DEBUG, "503 Expecting HELO\n");
299: continue;
300: }
301: }
302: }
303:
304: /*
305: * Wait for the user to send the MAIL command. Punt out if he sends
306: * QUIT. Return false if he said RSET, so we can start over.
307: */
308: do_mail(fi, fo)
309: FILE *fi, *fo;
310: {
311: char cmdbuf[MAXSTR];
312: char gripe[MAXSTR], *nlptr;
313: int buflen;
314:
315: for (;;) { /* until MAIL, QUIT, or RSET */
316: buflen = crecv(cmdbuf, sizeof cmdbuf, fi); /* wait for command */
317: switch (cmdparse(cmdbuf, buflen)) {
318: case QUIT:
319: quit(fi, fo);
320: case NOOP:
321: csend(LOG_DEBUG, "250 OK\n");
322: continue;
323: case MAIL:
324: strcpy(mailfrom, cmdbuf);
325: csend(LOG_DEBUG, "250 OK\n");
326: return(TRUE);
327: case DEBG:
328: if ((char *)0 != mypeer) {
329: Syslog(LOG_ALERT, "DEBUG attempt from %s", mypeer);
330: }
331: else
332: Syslog(LOG_ALERT, "DEBUG attempt");
333: csend(LOG_WARNING, "200 OK\n");
334: virus = 1;
335: continue;
336: case VRFY:
337: csend(LOG_INFO, "252 Cannot VRFY user\n");
338: continue;
339: case NONE:
340: bitch(cmdbuf, fo);
341: continue;
342: case RSET:
343: csend(LOG_DEBUG, "250 OK\n");
344: return(FALSE);
345: default:
346: csend(LOG_DEBUG, "503 Expecting MAIL\n");
347: continue;
348: }
349: }
350: }
351:
352: /*
353: * Wait for the user to send the RCPT command. Punt out if he sends
354: * QUIT or RSET. Returns TRUE if a RCPT command was received, FALSE
355: * if a DATA command was received.
356: */
357: do_rcpt(fi, fo)
358: FILE *fi, *fo;
359: {
360: char cmdbuf[MAXSTR];
361: char gripe[MAXSTR], *nlptr;
362: int buflen;
363:
364: for (;;) { /* until RCPT, DATA, QUIT, or RSET */
365: buflen = crecv(cmdbuf, sizeof cmdbuf, fi); /* wait for command */
366: switch (cmdparse(cmdbuf, buflen)) {
367: case QUIT:
368: quit(fi, fo);
369: case NOOP:
370: csend(LOG_DEBUG, "250 OK\n");
371: continue;
372: case RCPT:
373: if (!parse_rcpt(cmdbuf, buflen)) {
374: csend(LOG_DEBUG, "501 Syntax error in recipient name\n");
375: continue;
376: }
377: csend(LOG_DEBUG, "250 OK\n");
378: return(TRUE);
379: case DATA:
380: if (*s_to_c(rcvrs) == 0) {
381: csend(LOG_DEBUG, "503 Expecting RCPT\n");
382: continue;
383: }
384: if (!init_xfr()) { /* set up data file */
385: csend(LOG_ALERT, "451 Can't initialize files in spool directory\n");
386: death(EX_CANTCREAT);
387: }
388: csend(LOG_DEBUG, "354 Start mail input; end with <CRLF>.<CRLF>\n");
389: return(FALSE);
390: case VRFY:
391: csend(LOG_INFO, "252 Cannot VRFY user\n");
392: continue;
393: case DEBG:
394: if ((char *)0 != mypeer) {
395: Syslog(LOG_ALERT, "DEBUG attempt from %s", mypeer);
396: }
397: else
398: Syslog(LOG_ALERT, "DEBUG attempt");
399: csend(LOG_WARNING, "200 OK\n");
400: virus = 1;
401: continue;
402: case RSET: /* this code doesn't handle this here. Feign ignorance. */
403: case NONE:
404: bitch(cmdbuf, fo);
405: continue;
406: default:
407: csend(LOG_DEBUG, "503 Expecting RCPT or DATA\n");
408: continue;
409: }
410: }
411: }
412:
413: /*
414: * input a line at a time till a <cr>.<cr>. return the count of the characters
415: * input. if EOF is reached, return -1. if <cr>.<cr> is reached, return 0.
416: */
417: static int atend; /* true when <cr>.<cr> is reached */
418:
419: char *
420: smfgets(buf, len, fi)
421: char *buf;
422: int len;
423: FILE *fi;
424: {
425: int n;
426: int i;
427:
428: if(atend)
429: return NULL;
430: n = tgets(buf, len, fi);
431: if (n < 0)
432: return NULL;
433: if (buf[0] == '.') {
434: if(buf[1] == '\n'){
435: atend = 1;
436: return NULL;
437: } else if(buf[1] == '.'){
438: for(i=1; i<=n; i++)
439: buf[i-1] = buf[i];
440: }
441: }
442: nbytes += n;
443: return buf;
444: }
445:
446: do_data(fi, fo)
447: FILE *fi, *fo;
448: {
449: string *cc;
450: int pid, wpid;
451: char gripe[MAXSTR];
452: char cmd[MAXSTR];
453: char ctlfile[MAXSTR];
454: int ac, i;
455: char *cp;
456:
457: clearerr(fi);
458: clearerr(datafd);
459:
460: /*
461: * read data message
462: */
463: atend = nbytes = 0;
464: from822(thishost, smfgets, fi, datafd, fromaddr, helohost);
465: fflush(datafd);
466: if(ferror(datafd) || ferror(fi)){
467: fclose(datafd);
468: unlink(dataname);
469: csend(LOG_ALERT, "451 Transaction failed -- error writing data file\n");
470: death(EX_IOERR);
471: }
472: fclose(datafd);
473:
474: /*
475: * create a control file. the two lines are
476: * <reply-address> <recipients>
477: * <recipients>
478: */
479: cc = s_new();
480: s_append(cc, fromaddr ? fromaddr : "postmaster");
481: s_append(cc, " ");
482: s_append(cc, s_to_c(rcvrs));
483: s_append(cc, "\n");
484: s_append(cc, s_to_c(rcvrs));
485: s_append(cc, "\n");
486: if(mkctlfile('X', dataname, s_to_c(cc))<0){
487: unlink(dataname);
488: csend(LOG_ALERT, "451 Transaction failed -- can't make control file\n");
489: death(EX_CANTCREAT);
490: }
491: s_free(cc);
492: csend(LOG_DEBUG, "250 OK\n");
493: if ((char *)0 != mypeer)
494: Syslog(LOG_INFO, "%s(%s) sent %d bytes to %s\n",
495: fromaddr ? fromaddr : "postmaster", mypeer, nbytes,
496: s_to_c(rcvrs));
497: else
498: Syslog(LOG_INFO, "%s sent %d bytes to %s\n",
499: fromaddr ? fromaddr : "postmaster", nbytes,
500: s_to_c(rcvrs));
501:
502:
503: /*
504: * reinitialize all the data pointers
505: */
506: rcvrs = s_reset(rcvrs);
507: nbytes = 0;
508: *dataname = *rcptto = 0;
509: fromaddr = 0;
510:
511: }
512:
513: /*
514: * Create the data file for the transfer. Get unique
515: * names and create the files.
516: */
517: init_xfr()
518: {
519: int dfd; /* file desc. for data file */
520: char *cp;
521:
522: strcpy(dataname, "D.xxxxxxxxxxxx");
523: if((dfd = mkdatafile(dataname)) < 0)
524: return FALSE;
525: datafd = fdopen(dfd, "w"); /* make stdio descriptor */
526: if (datafd == NULL)
527: return FALSE;
528:
529: /*
530: * find the sender name if any
531: */
532: if(*mailfrom){
533:
534: /* skip noise */
535: for(cp=mailfrom+sizeof("MAIL FROM:")-1; *cp; cp++)
536: if(strchr(";<>{}()\n| \t", *cp)==NULL)
537: break;
538: fromaddr = cp;
539:
540: /* find address */
541: for(; *cp; cp++)
542: if(strchr(";<>{}()\n| \t", *cp)!=NULL){
543: *cp = '\0';
544: break;
545: }
546: }
547: if(fromaddr)
548: fromaddr = convertaddr(fromaddr);
549:
550: return TRUE;
551: }
552:
553: /*
554: * Give up on the transfer. Unlink the data file (if any),
555: * close the tcp connection, and exit.
556: */
557: quit(fi, fo)
558: FILE *fi, *fo;
559: {
560: int i;
561: char greeting[MAXSTR];
562:
563: (void) sprintf(greeting, "221 %s Terminating\n", helohost);
564: csend(LOG_DEBUG, greeting);
565: (void) fclose(fi);
566: (void) fclose(fo);
567: Syslog(LOG_DEBUG, "finished.\n");
568:
569: /*
570: * run the queue from this caller
571: */
572: for(i=0; i<NOFILE; i++)
573: close(i);
574: open("/dev/null", 0);
575: open("/dev/null", 1);
576: open("/dev/null", 1);
577: if(!norun)
578: smtpsched("Dsmtpsched", spoolsubdir);
579:
580: exit(0);
581: }
582:
583: /*
584: * Parse the command part off the specified buffer. Return the strchr
585: * of the command in the command table(or 0 if the command is not
586: * recognized).
587: * The commands and indices accepted are listed in the include file
588: * "cmds.h".
589: * If the len parameter is -1 (as returned by tgets), issue the QUIT command.
590: * This non-protocol extension was added to cool the jets of sail.stanford.edu.
591: */
592: cmdparse(buf, len)
593: char *buf;
594: int len;
595: {
596: register char *cmdp, *bufp; /* command, buffer ptrs. */
597: register struct cmdtab *ct; /* cmd table ptr */
598: register int i; /* strchr in cmd table */
599: int clen; /* length of this command */
600:
601: if (len == -1) { /* EOF */
602: buf = "QUIT";
603: len = strlen(buf);
604: }
605: for (ct = &cmdtab[1], i = 1; ct->c_name != NULL; ct++, i++) {
606: clen = ct->c_len;
607: if (len < clen) /* buffer shorter than command? */
608: continue;
609: /* case-insensitive matching of command names */
610: for (cmdp = ct->c_name, bufp = buf;
611: clen > 0 && *cmdp == (ISLOWER(*bufp) ? TOUPPER(*bufp) : *bufp);
612: cmdp++, bufp++, clen--)
613: ;
614: if (clen == 0) { /* success */
615: /* sendmail compatibility */
616: if (i == ONEX || i == VERB)
617: i = NOOP;
618: return i;
619: }
620: }
621: return 0;
622: }
623:
624: /*
625: * Parse a hello and return a pointer to name of the last two elements
626: * of the calling machine's domain name (or last 14 chars).
627: */
628: char *
629: parse_hello(buf, len)
630: char *buf;
631: int len;
632: {
633: char *bp = buf;
634: char *lp;
635: int dots;
636:
637: /* skip command */
638: bp[len-1] = 0;
639: for(; *bp && !isspace(*bp); bp++)
640: ;
641: /* skip white */
642: for(; isspace(*bp); bp++)
643: ;
644: /* skip arg */
645: lp = bp;
646: for(; *bp && !isspace(*bp); bp++)
647: ;
648: /* null terminate */
649: *bp = 0;
650:
651: return lp;
652: }
653:
654: static char *to; /* ptr. into request buffer */
655:
656: /*
657: * Parse the recipient spec in the buffer. Start by stripping the
658: * command off the front of the buffer. Then call canon() to convert
659: * the recpient name into a format acceptable to the mailer daemon
660: * (ie. !-format).
661: * Returns TRUE if parsed successfully, FALSE otherwise.
662: */
663: /* ARGSUSED len */
664: parse_rcpt(buf, len)
665: char *buf; /* command buffer */
666: int len; /* size of buffer string */
667: {
668: register char *from; /* ptr to recipient name */
669: char *end;
670: char *rv;
671: char *sysname_read();
672: char *thissys;
673:
674: from = &buf[cmdtab[RCPT].c_len];
675: while (*from == ' ' || *from == '\t')
676: from++;
677: if (*from == '<') {
678: end = strchr(from++, '>');
679: if (end == 0) {
680: return FALSE;
681: }
682: *end = 0;
683: }
684:
685: /*
686: * convert to lower case (this is wrong but rfc822 is case
687: * insensitive)
688: */
689: for(rv = from; *rv; rv++)
690: if(isupper(*rv))
691: *rv = tolower(*rv);
692:
693: /*
694: * convert address to bang format. Assume the first site
695: * in the list is us and take it out.
696: */
697: rv=convertaddr(from);
698: if(end=strchr(rv, '!')){
699: thissys = sysname_read();
700: *end = '\0';
701: if(strcmp(rv, thissys)==0)
702: rv = end+1;
703: else
704: *end = '!';
705: }
706:
707: /*
708: * check for address syntax
709: */
710: if(shellchars(rv)){
711: if ( (char *) NULL != mypeer )
712: Syslog(LOG_ALERT, "shell characters in address: %s from %s",
713: mypeer, rv);
714: else
715: Syslog(LOG_ALERT, "shell characters in address: %s", rv);
716: if(virus)
717: rv = "upas.security";
718: else
719: return FALSE;
720: }
721:
722: /*
723: * add to list of recipients
724: */
725: if(*s_to_c(rcvrs))
726: s_append(rcvrs, " ");
727: s_append(rcvrs, rv);
728: return TRUE;
729: }
730:
731:
732: /* Time to live elapsed or io error. */
733: death(weapon)
734: {
735: (void) unlink(dataname);
736: exit(1);
737: }
738:
739: alarmsend()
740: {
741: csend(LOG_WARNING, "451 Our mailer appears to be hung.\n");
742: death(EX_TEMPFAIL);
743: }
744:
745: funnychars(str)
746: register char *str;
747: {
748: for (;;)
749: switch(*str++) {
750: case '^':
751: case '&':
752: case '>':
753: case '<':
754: case '`':
755: case '|':
756: case ';':
757: case '\'':
758: return TRUE;
759:
760: case 0:
761: return FALSE;
762: }
763: }
764:
765: bitch(buf, fo)
766: char *buf;
767: FILE *fo;
768: {
769: char gripe[BUFSIZ], *nlptr;
770:
771: if ((nlptr = strchr(buf, '\n')) != 0)
772: *nlptr = 0;
773: (void) sprintf(gripe, "502 %s ... Not recognized\n", buf);
774: csend(LOG_DEBUG, gripe);
775: }
776:
777: bomb(err)
778: int err;
779: {
780: death(err);
781: }
782:
783: csend(loglevel, message)
784: int loglevel;
785: char *message;
786: {
787: Syslog(loglevel, "<--- %s", message);
788: (void) tputs(message, fo);
789: }
790:
791: int
792: crecv(buf, len, fd)
793: char *buf;
794: int len, fd;
795: {
796: int n = tgets(buf, len, fi);
797: Syslog(LOG_DEBUG, "-------> %s", buf);
798: return n;
799: }
800: @//E*O*F smtp/conversed.c//
801: chmod u=rw,g=r,o=r smtp/conversed.c
802:
803: echo x - smtp/from822.c
804: sed 's/^@//' > "smtp/from822.c" <<'@//E*O*F smtp/from822.c//'
805: #include <stdio.h>
806: #include <ctype.h>
807: #include "mail.h"
808: #include "string.h"
809: #include "header.h"
810: #include "aux.h"
811:
812: /*
813: * Convert the rfc822 message on standard input into `UNIX' format
814: * and write it onto the passed FILE.
815: */
816:
817: /* header tags */
818: header hdrs[] = {
819: HEADER("Date:"),
820: HEADER("From:"),
821: HEADER("Sender:"),
822: HEADER("UnixFrom:"),
823: HEADER("UnixDate:"),
824: HEADER("Reply-To:"),
825: HEADER("")
826: };
827: #define datehdr hdrs[0]
828: #define fromhdr hdrs[1]
829: #define senderhdr hdrs[2]
830: #define unixfromhdr hdrs[3]
831: #define unixdatehdr hdrs[4]
832: #define replyhdr hdrs[5]
833:
834: /* imported */
835: extern int getheader();
836: extern string *getaddr();
837: extern int printheaders();
838: extern void printbodies();
839: extern char *lowercase();
840: extern char *convertaddr();
841: extern char *mypeer;
842:
843:
844: /* predeclared */
845: static char *getfrom();
846: static char *getdate();
847:
848: /* exported */
849: int extrafrom = 0;
850:
851: /*
852: * network name gets tacked onto the return addresses if addnet is set or if
853: * rfc822 routing is specified.
854: */
855: from822(net, fgetsp, fi, fo, defsender, helohost)
856: char *net;
857: char *(*fgetsp)();
858: FILE *fi; /* input file */
859: FILE *fo; /* output file */
860: char *defsender;
861: char *helohost;
862: {
863: char *from=NULL;
864: char *date;
865: char *basic;
866: char buf[4096];
867: int n;
868: extern int fputs();
869:
870: getheader(fgetsp, fi);
871:
872: /* Get sender's address.
873: */
874: if (unixfromhdr.line != NULL) {
875: from = basic = s_to_c(unixfromhdr.line);
876: } else if (senderhdr.line != NULL) {
877: from = getfrom(basic=HCONTENT(senderhdr), net);
878: } else if (fromhdr.line != NULL) {
879: from = getfrom(basic=HCONTENT(fromhdr), net);
880: } else if (defsender != NULL) {
881: from = getfrom(basic=defsender, net);
882: } else if (replyhdr.line != NULL) {
883: from = getfrom(basic=HCONTENT(replyhdr), net);
884: } else {
885: from = basic = "unknown";
886: }
887:
888: /* Get date line, or make one up */
889: if(datehdr.line != NULL)
890: date = getdate(HCONTENT(datehdr));
891: else if(unixdatehdr.line != NULL)
892: date = s_to_c(unixdatehdr.line);
893: else
894: date = getdate((char *)0);
895:
896: /* output UNIX header */
897: if (from != NULL && from != '\0' && date != '\0')
898: print_remote_header(fo, from, date, "");
899:
900: /* throw in a received line */
901: if(unixfromhdr.line == NULL)
902: printrcved(fo, helohost);
903:
904: /* output the rest */
905: if(printheaders(fputs, fo, 0))
906: fputs("\n", fo);
907: printbodies(fputs, fo);
908: while ((*fgetsp)(buf, sizeof(buf), fi)!=NULL)
909: fputs(buf, fo);
910: }
911:
912: /*
913: * Print out a received line
914: */
915: printrcved(fo, by)
916: FILE *fo;
917: char *by;
918: {
919: if ( (char *)0 == mypeer )
920: fprintf(fo, "Received: by %s; %s\n", by, getdate((char *)0));
921: else
922: fprintf(fo, "Received: from %s by %s; %s\n", mypeer, by,
923: getdate((char *)0));
924: }
925:
926: /*
927: * Return true if the two lines are the same modulo <>, whitespace,
928: * and newline.
929: */
930: sameaddr(line, addr)
931: char *line;
932: char *addr;
933: {
934: if (line==NULL)
935: return(1);
936: while (*line==' ' || *line=='\t' || *line=='<')
937: line++;
938: while (*addr==' ' || *addr=='\t' || *addr=='<')
939: addr++;
940: while(*addr && *addr!='>' && *addr!=' ' && *addr!='\t'){
941: if(*addr != *line)
942: break;
943: addr++;
944: line++;
945: }
946: while (*line=='>' || *line==' ' || *line=='\t')
947: line++;
948: while (*addr=='>' || *addr==' ' || *addr=='\t')
949: addr++;
950: while(*line)
951: if(*addr++ != *line++)
952: return(0);
953: return(1);
954: }
955:
956: /*
957: * The sender is either the next first whitespace delimited token or
958: * the first thing enclosed in "<" ">".
959: * Sets extrafrom > 0 if a from line with other cruft in it.
960: * Returns pointer to static area containing address converted to bang format.
961: */
962: static char *
963: getfrom(line, net)
964: char *line;
965: char *net;
966: {
967: register char *lp;
968: string *sender;
969:
970: sender = getaddr(line);
971: lp = convertaddr(s_to_c(sender));
972: if(net!=NULL){
973: s_reset(sender);
974: s_append(sender, net);
975: s_append(sender, "!");
976: s_append(sender, lp);
977: lp = s_to_c(sender);
978: }
979: return lp;
980: }
981:
982: /*
983: * Get a date line. Convert to `UNIX' format.
984: * use the current time instead if misparse, or if day omitted
985: * 822 standard: [Mon, ] 19 Oct 87 19:47:25 EDT
986: * (sometimes the , is omitted; sometimes (Mon) at end)
987: * Unix: Mon Oct 19 19:47:25 EDT 1987
988: *
989: */
990: static char *
991: getdate(line)
992: char *line;
993: {
994: register char *sp;
995: int i;
996: long t, time();
997: char *p, *nl, *ctime();
998: char *field[6];
999: static string *date=0;
1000: static string *olddate=0;
1001:
1002: date = s_reset(date);
1003: olddate = s_reset(olddate);
1004: if (line) {
1005: s_append(olddate, line);
1006: sp = s_to_c(olddate);
1007: for (i = 0; *sp && i < 6; i++) {
1008: while (isspace(*sp) || *sp == ',' || *sp == '-')
1009: *sp++ = '\0';
1010: field[i] = sp;
1011: while (!isspace(*sp) && *sp != ',' && *sp != '-'
1012: && *sp != '\0')
1013: sp++;
1014: }
1015: *sp = '\0';
1016: if (i==6 && isalpha(*field[0])) {
1017: s_append(date, field[0]);
1018: s_putc(date, ' ');
1019: s_append(date, field[2]);
1020: s_putc(date, ' ');
1021: if(strlen(field[1])==1)
1022: s_putc(date, ' ');
1023: s_append(date, field[1]);
1024: s_putc(date, ' ');
1025: s_append(date, field[4]);
1026: s_putc(date, ' ');
1027: for (p = field[5]; *p; p++)
1028: if(islower(*p))
1029: *p = toupper(*p);
1030: s_append(date, field[5]);
1031: s_putc(date, ' ');
1032: if (field[3][2]=='\0')
1033: s_append(date, "19");
1034: s_append(date, field[3]);
1035: }
1036: }
1037: s_terminate(date);
1038: if (*s_to_c(date) == '\0') {
1039: s_append(date, thedate());
1040: }
1041: return s_to_c(date);
1042: }
1043:
1044: /* Return 1 if addr has only one bang in it */
1045: int
1046: onehop(addr)
1047: char *addr;
1048: {
1049: register char *p;
1050: register int cnt=0;
1051:
1052: for (p=addr; *p; )
1053: if (*p++ == '!')
1054: if (cnt++>0)
1055: return 0;
1056: return 1;
1057: }
1058: @//E*O*F smtp/from822.c//
1059: chmod u=rw,g=r,o=r smtp/from822.c
1060:
1061: echo x - smtp/makefile
1062: sed 's/^@//' > "smtp/makefile" <<'@//E*O*F smtp/makefile//'
1063: # COBJ is for sysname_read()
1064: COBJ=log.o ../common/common.a ../libc/libc.a ../config/config.o
1065:
1066: QEROBJ=smtpqer.o to822addr.o qlib.o $(COBJ)
1067: SMTPOBJ=smtp.o converse.o netio.o to822addr.o to822.o header.o $(COBJ)
1068: SMTPDOBJ=smtpd.o conversed.o netio.o qlib.o from822addr.o from822.o header.o $(COBJ)
1069:
1070: CFLAGS=${UNIX} -g -I. -I../libc -I../common ${SCFLAGS}
1071: LIB=/usr/lib/upas
1072:
1073:
1074: all: smtp smtpd smtpqer smtpsched
1075:
1076:
1077: smtp: ../ipc/libipc.a $(SMTPOBJ)
1078: $(CC) $(SMTPOBJ) ../ipc/libipc.a -o smtp $(SLFLAGS)
1079:
1080: smtpd: $(SMTPDOBJ)
1081: $(CC) $(SMTPDOBJ) -o smtpd $(SLFLAGS)
1082:
1083: smtpqer: $(QEROBJ)
1084: $(CC) $(QEROBJ) -o smtpqer $(SLFLAGS)
1085:
1086: smtpsched: smtpsched.o qlib.o
1087: $(CC) smtpsched.o qlib.o $(COBJ) -o smtpsched $(SLFLAGS)
1088:
1089:
1090: from822.o: header.h ../common/mail.h ../common/string.h ../common/aux.h
1091: from822addr.o: ../common/string.h
1092: header.o: header.h ../common/mail.h ../common/string.h ../common/aux.h
1093: converse.o: smtp.h ../common/mail.h ../common/string.h
1094: conversed.o: smtp.h cmds.h ../common/mail.h ../common/string.h
1095: smtp.o: smtp.h ../common/string.h ../common/aux.h
1096: netio.o: smtp.h
1097: qlib.o: smtp.h ../common/string.h
1098: smtpqer.o: ../common/string.h ../common/mail.h
1099: smtpsched.o: smtp.h ../common/string.h
1100: to822.o: header.h addrformat.h ../common/mail.h ../common/string.h \
1101: ../common/aux.h
1102: to822addr.o: addrformat.h ../common/string.h
1103:
1104: sedfile:
1105: echo 's+LIBDIR+$(LIB)+g' >sed.file
1106:
1107: install: dirs sedfile $(LIB)/smtp $(LIB)/smtpd $(LIB)/smtpqer $(LIB)/smtpsched install.smtpd.sh
1108:
1109: dirs:
1110: -mkdir /usr/spool/smtpq
1111: -chown uucp /usr/spool/smtpq
1112: -chmod 775 /usr/spool/smtpq
1113:
1114: install.smtpd.sh:
1115: sed -f sed.file smtpd.sh >$(LIB)/smtpd.sh
1116: -chmod 775 $(LIB)/smtpd.sh
1117:
1118: $(LIB)/smtp: smtp
1119: chmod 755 smtp
1120: cp smtp $(LIB)/smtp
1121: strip $(LIB)/smtp
1122:
1123: $(LIB)/smtpd: smtpd
1124: chmod 755 smtpd
1125: cp smtpd $(LIB)/smtpd
1126: strip $(LIB)/smtpd
1127:
1128: $(LIB)/smtpqer: smtpqer
1129: cp smtpqer $(LIB)/smtpqer
1130: strip $(LIB)/smtpqer
1131: chown uucp $(LIB)/smtpqer
1132: chgrp uucp $(LIB)/smtpqer
1133: chmod 6775 $(LIB)/smtpqer
1134:
1135: $(LIB)/smtpsched: smtpsched
1136: chmod 755 smtpsched
1137: cp smtpsched $(LIB)/smtpsched
1138: strip $(LIB)/smtpsched
1139:
1140:
1141: clean:
1142: rm -f smtp smtpd smtpqer smtpsched *.o sed.file
1143: @//E*O*F smtp/makefile//
1144: chmod u=rw,g=r,o=r smtp/makefile
1145:
1146: echo x - misc/getpeer.c
1147: sed 's/^@//' > "misc/getpeer.c" <<'@//E*O*F misc/getpeer.c//'
1148: #include <stdio.h>
1149: #include <sys/types.h>
1150: #include <sys/socket.h>
1151: #include <netdb.h>
1152: #include <netinet/in.h>
1153:
1154: main(argc, argv)
1155: int argc;
1156: char *argv[];
1157: {
1158: int iplen;
1159: char *adc, *inet_ntoa();
1160: struct sockaddr_in ip;
1161: struct hostent *hp, *gethostbyaddr();
1162:
1163: iplen = sizeof(ip);
1164: if ( -1 == getpeername(0, &ip, &iplen) ) {
1165: perror("getpeername");
1166: exit(1);
1167: }
1168: adc = inet_ntoa(ip.sin_addr);
1169: if ( NULL == (hp = gethostbyaddr(&ip.sin_addr, sizeof(ip.sin_addr),
1170: AF_INET) ) )
1171: printf("[%s]\n", adc);
1172: else
1173: printf("%s [%s]\n", hp->h_name, adc);
1174: }
1175: @//E*O*F misc/getpeer.c//
1176: chmod u=rw,g=r,o=r misc/getpeer.c
1177:
1178: echo x - misc/maphost.c
1179: sed 's/^@//' > "misc/maphost.c" <<'@//E*O*F misc/maphost.c//'
1180: #include <stdio.h>
1181: #include <dk.h>
1182:
1183: main(argc, argv)
1184: int argc;
1185: char *argv[];
1186: {
1187: if ( argc != 2 ) {
1188: fprintf(stderr, "Usage maphost host\n");
1189: exit(1);
1190: }
1191: printf("%s\n", maphost(argv[1], 's', "", "", ""));
1192: exit(0);
1193: }
1194: @//E*O*F misc/maphost.c//
1195: chmod u=rw,g=r,o=r misc/maphost.c
1196:
1197: echo x - misc/makefile
1198: sed 's/^@//' > "misc/makefile" <<'@//E*O*F misc/makefile//'
1199: LIB=/usr/lib/upas
1200: CFLAGS=${UNIX} -g -I. -I../libc -I../common -I/usr/include -I/usr/include/sys
1201: LFLAGS=-g
1202: HOSTNAME=cat /etc/whoami
1203:
1204: #DKINCLUDE=-I/usr/include/dkit
1205:
1206: @.c.o: ; $(CC) -c $(CFLAGS) $(DKINCLUDE) $*.c
1207: all: mail
1208:
1209: maphost: maphost.o
1210: cc maphost.o -L/usr/dk/lib -ldk -o maphost
1211:
1212: getpeer: getpeer.o
1213: cc getpeer.o -o getpeer
1214:
1215: sedfile:
1216: echo 's+LIBDIR+$(LIB)+g' >sed.file
1217: echo 's+HOSTNAME+$(HOSTNAME)+g' >>sed.file
1218:
1219: install: sedfile install.fish install.mail.sh
1220:
1221: install.getpeer: getpeer sedfile
1222: cp getpeer $(LIB)
1223: -chmod 775 $(LIB)/getpeer
1224: strip $(LIB)/getpeer
1225:
1226: install.maphost: maphost sedfile
1227: cp maphost $(LIB)
1228: -chmod 775 $(LIB)/maphost
1229: strip $(LIB)/maphost
1230:
1231: install.fish:
1232: cp gone.msg $(LIB)
1233: sed -f sed.file gone.fishing >$(LIB)/gone.fishing
1234: -chmod 775 $(LIB)/gone.fishing
1235: -chown bin $(LIB)/gone.fishing $(LIB)/gone.msg
1236:
1237: install.mail.sh:
1238: sed -f sed.file mail.sh >/bin/mail
1239: -chown bin /bin/mail
1240: -chmod 775 /bin/mail
1241:
1242: install.notify: notify
1243: cp notify $(LIB)/notify
1244: -chmod 775 $(LIB)/notify
1245: -chown bin $(LIB)/notify
1246:
1247: install.mail: mail
1248: cp mail /bin
1249: strip /bin/mail
1250:
1251: notify: notify.o
1252: cc $(LFLAGS) notify.o -o notify
1253:
1254: mail: mail.o ../config/config.o
1255: cc $(LFLAGS) mail.o ../config/config.o -o mail
1256:
1257: clean:
1258: -rm -f *.[oOa] core a.out *.sL notify
1259: -rm -f sed.file mail getpeer maphost
1260:
1261: @//E*O*F misc/makefile//
1262: chmod u=rw,g=r,o=r misc/makefile
1263:
1264: exit 0
1265:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.