![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / sendmail / src|
Return to util.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / sendmail / src |
1.1 root 1: /*
2: * Copyright (c) 1983 Eric P. Allman
3: * Copyright (c) 1988 Regents of the University of California.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms are permitted provided
7: * that: (1) source distributions retain this entire copyright notice and
8: * comment, and (2) distributions including binaries display the following
9: * acknowledgement: ``This product includes software developed by the
10: * University of California, Berkeley and its contributors'' in the
11: * documentation or other materials provided with the distribution and in
12: * all advertising materials mentioning features or use of this software.
13: * Neither the name of the University nor the names of its contributors may
14: * be used to endorse or promote products derived from this software without
15: * specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: */
20:
21: #ifndef lint
22: static char sccsid[] = "@(#)util.c 5.18 (Berkeley) 6/1/90";
23: #endif /* not lint */
24:
25: # include <stdio.h>
26: # include <sys/types.h>
27: # include <sys/stat.h>
28: # include <sysexits.h>
29: # include <errno.h>
30: # include "sendmail.h"
31:
32: /*
33: ** STRIPQUOTES -- Strip quotes & quote bits from a string.
34: **
35: ** Runs through a string and strips off unquoted quote
36: ** characters and quote bits. This is done in place.
37: **
38: ** Parameters:
39: ** s -- the string to strip.
40: ** qf -- if set, remove actual `` " '' characters
41: ** as well as the quote bits.
42: **
43: ** Returns:
44: ** none.
45: **
46: ** Side Effects:
47: ** none.
48: **
49: ** Called By:
50: ** deliver
51: */
52:
53: stripquotes(s, qf)
54: char *s;
55: bool qf;
56: {
57: register char *p;
58: register char *q;
59: register char c;
60:
61: if (s == NULL)
62: return;
63:
64: for (p = q = s; (c = *p++) != '\0'; )
65: {
66: if (c != '"' || !qf)
67: *q++ = c & 0177;
68: }
69: *q = '\0';
70: }
71: /*
72: ** QSTRLEN -- give me the string length assuming 0200 bits add a char
73: **
74: ** Parameters:
75: ** s -- the string to measure.
76: **
77: ** Reurns:
78: ** The length of s, including space for backslash escapes.
79: **
80: ** Side Effects:
81: ** none.
82: */
83:
84: qstrlen(s)
85: register char *s;
86: {
87: register int l = 0;
88: register char c;
89:
90: while ((c = *s++) != '\0')
91: {
92: if (bitset(0200, c))
93: l++;
94: l++;
95: }
96: return (l);
97: }
98: /*
99: ** CAPITALIZE -- return a copy of a string, properly capitalized.
100: **
101: ** Parameters:
102: ** s -- the string to capitalize.
103: **
104: ** Returns:
105: ** a pointer to a properly capitalized string.
106: **
107: ** Side Effects:
108: ** none.
109: */
110:
111: char *
112: capitalize(s)
113: register char *s;
114: {
115: static char buf[50];
116: register char *p;
117:
118: p = buf;
119:
120: for (;;)
121: {
122: while (!isalpha(*s) && *s != '\0')
123: *p++ = *s++;
124: if (*s == '\0')
125: break;
126: *p++ = toupper(*s);
127: s++;
128: while (isalpha(*s))
129: *p++ = *s++;
130: }
131:
132: *p = '\0';
133: return (buf);
134: }
135: /*
136: ** XALLOC -- Allocate memory and bitch wildly on failure.
137: **
138: ** THIS IS A CLUDGE. This should be made to give a proper
139: ** error -- but after all, what can we do?
140: **
141: ** Parameters:
142: ** sz -- size of area to allocate.
143: **
144: ** Returns:
145: ** pointer to data region.
146: **
147: ** Side Effects:
148: ** Memory is allocated.
149: */
150:
151: char *
152: xalloc(sz)
153: register int sz;
154: {
155: register char *p;
156: extern char *malloc();
157:
158: p = malloc((unsigned) sz);
159: if (p == NULL)
160: {
161: syserr("Out of memory!!");
162: abort();
163: /* exit(EX_UNAVAILABLE); */
164: }
165: return (p);
166: }
167: /*
168: ** COPYPLIST -- copy list of pointers.
169: **
170: ** This routine is the equivalent of newstr for lists of
171: ** pointers.
172: **
173: ** Parameters:
174: ** list -- list of pointers to copy.
175: ** Must be NULL terminated.
176: ** copycont -- if TRUE, copy the contents of the vector
177: ** (which must be a string) also.
178: **
179: ** Returns:
180: ** a copy of 'list'.
181: **
182: ** Side Effects:
183: ** none.
184: */
185:
186: char **
187: copyplist(list, copycont)
188: char **list;
189: bool copycont;
190: {
191: register char **vp;
192: register char **newvp;
193:
194: for (vp = list; *vp != NULL; vp++)
195: continue;
196:
197: vp++;
198:
199: newvp = (char **) xalloc((int) (vp - list) * sizeof *vp);
200: bcopy((char *) list, (char *) newvp, (int) (vp - list) * sizeof *vp);
201:
202: if (copycont)
203: {
204: for (vp = newvp; *vp != NULL; vp++)
205: *vp = newstr(*vp);
206: }
207:
208: return (newvp);
209: }
210: /*
211: ** PRINTAV -- print argument vector.
212: **
213: ** Parameters:
214: ** av -- argument vector.
215: **
216: ** Returns:
217: ** none.
218: **
219: ** Side Effects:
220: ** prints av.
221: */
222:
223: printav(av)
224: register char **av;
225: {
226: while (*av != NULL)
227: {
228: if (tTd(0, 44))
229: printf("\n\t%08x=", *av);
230: else
231: (void) putchar(' ');
232: xputs(*av++);
233: }
234: (void) putchar('\n');
235: }
236: /*
237: ** LOWER -- turn letter into lower case.
238: **
239: ** Parameters:
240: ** c -- character to turn into lower case.
241: **
242: ** Returns:
243: ** c, in lower case.
244: **
245: ** Side Effects:
246: ** none.
247: */
248:
249: char
250: lower(c)
251: register char c;
252: {
253: return(isascii(c) && isupper(c) ? tolower(c) : c);
254: }
255: /*
256: ** XPUTS -- put string doing control escapes.
257: **
258: ** Parameters:
259: ** s -- string to put.
260: **
261: ** Returns:
262: ** none.
263: **
264: ** Side Effects:
265: ** output to stdout
266: */
267:
268: xputs(s)
269: register char *s;
270: {
271: register char c;
272:
273: if (s == NULL)
274: {
275: printf("<null>");
276: return;
277: }
278: (void) putchar('"');
279: while ((c = *s++) != '\0')
280: {
281: if (!isascii(c))
282: {
283: (void) putchar('\\');
284: c &= 0177;
285: }
286: if (c < 040 || c >= 0177)
287: {
288: (void) putchar('^');
289: c ^= 0100;
290: }
291: (void) putchar(c);
292: }
293: (void) putchar('"');
294: (void) fflush(stdout);
295: }
296: /*
297: ** MAKELOWER -- Translate a line into lower case
298: **
299: ** Parameters:
300: ** p -- the string to translate. If NULL, return is
301: ** immediate.
302: **
303: ** Returns:
304: ** none.
305: **
306: ** Side Effects:
307: ** String pointed to by p is translated to lower case.
308: **
309: ** Called By:
310: ** parse
311: */
312:
313: makelower(p)
314: register char *p;
315: {
316: register char c;
317:
318: if (p == NULL)
319: return;
320: for (; (c = *p) != '\0'; p++)
321: if (isascii(c) && isupper(c))
322: *p = tolower(c);
323: }
324: /*
325: ** BUILDFNAME -- build full name from gecos style entry.
326: **
327: ** This routine interprets the strange entry that would appear
328: ** in the GECOS field of the password file.
329: **
330: ** Parameters:
331: ** p -- name to build.
332: ** login -- the login name of this user (for &).
333: ** buf -- place to put the result.
334: **
335: ** Returns:
336: ** none.
337: **
338: ** Side Effects:
339: ** none.
340: */
341:
342: buildfname(p, login, buf)
343: register char *p;
344: char *login;
345: char *buf;
346: {
347: register char *bp = buf;
348:
349: if (*p == '*')
350: p++;
351: while (*p != '\0' && *p != ',' && *p != ';' && *p != '%')
352: {
353: if (*p == '&')
354: {
355: (void) strcpy(bp, login);
356: *bp = toupper(*bp);
357: while (*bp != '\0')
358: bp++;
359: p++;
360: }
361: else
362: *bp++ = *p++;
363: }
364: *bp = '\0';
365: }
366: /*
367: ** SAFEFILE -- return true if a file exists and is safe for a user.
368: **
369: ** Parameters:
370: ** fn -- filename to check.
371: ** uid -- uid to compare against.
372: ** mode -- mode bits that must match.
373: **
374: ** Returns:
375: ** TRUE if fn exists, is owned by uid, and matches mode.
376: ** FALSE otherwise.
377: **
378: ** Side Effects:
379: ** none.
380: */
381:
382: bool
383: safefile(fn, uid, mode)
384: char *fn;
385: int uid;
386: int mode;
387: {
388: struct stat stbuf;
389:
390: if (stat(fn, &stbuf) >= 0 && stbuf.st_uid == uid &&
391: (stbuf.st_mode & mode) == mode)
392: return (TRUE);
393: errno = 0;
394: return (FALSE);
395: }
396: /*
397: ** FIXCRLF -- fix <CR><LF> in line.
398: **
399: ** Looks for the <CR><LF> combination and turns it into the
400: ** UNIX canonical <NL> character. It only takes one line,
401: ** i.e., it is assumed that the first <NL> found is the end
402: ** of the line.
403: **
404: ** Parameters:
405: ** line -- the line to fix.
406: ** stripnl -- if true, strip the newline also.
407: **
408: ** Returns:
409: ** none.
410: **
411: ** Side Effects:
412: ** line is changed in place.
413: */
414:
415: fixcrlf(line, stripnl)
416: char *line;
417: bool stripnl;
418: {
419: register char *p;
420:
421: p = index(line, '\n');
422: if (p == NULL)
423: return;
424: if (p > line && p[-1] == '\r')
425: p--;
426: if (!stripnl)
427: *p++ = '\n';
428: *p = '\0';
429: }
430: /*
431: ** DFOPEN -- determined file open
432: **
433: ** This routine has the semantics of fopen, except that it will
434: ** keep trying a few times to make this happen. The idea is that
435: ** on very loaded systems, we may run out of resources (inodes,
436: ** whatever), so this tries to get around it.
437: */
438:
439: FILE *
440: dfopen(filename, mode)
441: char *filename;
442: char *mode;
443: {
444: register int tries;
445: register FILE *fp;
446:
447: for (tries = 0; tries < 10; tries++)
448: {
449: sleep((unsigned) (10 * tries));
450: errno = 0;
451: fp = fopen(filename, mode);
452: if (fp != NULL)
453: break;
454: if (errno != ENFILE && errno != EINTR)
455: break;
456: }
457: errno = 0;
458: return (fp);
459: }
460: /*
461: ** PUTLINE -- put a line like fputs obeying SMTP conventions
462: **
463: ** This routine always guarantees outputing a newline (or CRLF,
464: ** as appropriate) at the end of the string.
465: **
466: ** Parameters:
467: ** l -- line to put.
468: ** fp -- file to put it onto.
469: ** m -- the mailer used to control output.
470: **
471: ** Returns:
472: ** none
473: **
474: ** Side Effects:
475: ** output of l to fp.
476: */
477:
478: # define SMTPLINELIM 990 /* maximum line length */
479:
480: putline(l, fp, m)
481: register char *l;
482: FILE *fp;
483: MAILER *m;
484: {
485: register char *p;
486: char svchar;
487:
488: /* strip out 0200 bits -- these can look like TELNET protocol */
489: if (bitnset(M_LIMITS, m->m_flags))
490: {
491: p = l;
492: while ((*p++ &= ~0200) != 0)
493: continue;
494: }
495:
496: do
497: {
498: /* find the end of the line */
499: p = index(l, '\n');
500: if (p == NULL)
501: p = &l[strlen(l)];
502:
503: /* check for line overflow */
504: while ((p - l) > SMTPLINELIM && bitnset(M_LIMITS, m->m_flags))
505: {
506: register char *q = &l[SMTPLINELIM - 1];
507:
508: svchar = *q;
509: *q = '\0';
510: if (l[0] == '.' && bitnset(M_XDOT, m->m_flags))
511: (void) putc('.', fp);
512: fputs(l, fp);
513: (void) putc('!', fp);
514: fputs(m->m_eol, fp);
515: *q = svchar;
516: l = q;
517: }
518:
519: /* output last part */
520: svchar = *p;
521: *p = '\0';
522: if (l[0] == '.' && bitnset(M_XDOT, m->m_flags))
523: (void) putc('.', fp);
524: fputs(l, fp);
525: fputs(m->m_eol, fp);
526: *p = svchar;
527: l = p;
528: if (*l == '\n')
529: l++;
530: } while (l[0] != '\0');
531: }
532: /*
533: ** XUNLINK -- unlink a file, doing logging as appropriate.
534: **
535: ** Parameters:
536: ** f -- name of file to unlink.
537: **
538: ** Returns:
539: ** none.
540: **
541: ** Side Effects:
542: ** f is unlinked.
543: */
544:
545: xunlink(f)
546: char *f;
547: {
548: register int i;
549:
550: # ifdef LOG
551: if (LogLevel > 20)
552: syslog(LOG_DEBUG, "%s: unlink %s\n", CurEnv->e_id, f);
553: # endif LOG
554:
555: i = unlink(f);
556: # ifdef LOG
557: if (i < 0 && LogLevel > 21)
558: syslog(LOG_DEBUG, "%s: unlink-fail %d", f, errno);
559: # endif LOG
560: }
561: /*
562: ** SFGETS -- "safe" fgets -- times out and ignores random interrupts.
563: **
564: ** Parameters:
565: ** buf -- place to put the input line.
566: ** siz -- size of buf.
567: ** fp -- file to read from.
568: **
569: ** Returns:
570: ** NULL on error (including timeout). This will also leave
571: ** buf containing a null string.
572: ** buf otherwise.
573: **
574: ** Side Effects:
575: ** none.
576: */
577:
578: static jmp_buf CtxReadTimeout;
579:
580: char *
581: sfgets(buf, siz, fp)
582: char *buf;
583: int siz;
584: FILE *fp;
585: {
586: register EVENT *ev = NULL;
587: register char *p;
588: extern readtimeout();
589:
590: /* set the timeout */
591: if (ReadTimeout != 0)
592: {
593: if (setjmp(CtxReadTimeout) != 0)
594: {
595: # ifdef LOG
596: syslog(LOG_NOTICE,
597: "timeout waiting for input from %s\n",
598: RealHostName? RealHostName: "local");
599: # endif
600: errno = 0;
601: usrerr("451 timeout waiting for input");
602: buf[0] = '\0';
603: return (NULL);
604: }
605: ev = setevent((time_t) ReadTimeout, readtimeout, 0);
606: }
607:
608: /* try to read */
609: p = NULL;
610: while (p == NULL && !feof(fp) && !ferror(fp))
611: {
612: errno = 0;
613: p = fgets(buf, siz, fp);
614: if (errno == EINTR)
615: clearerr(fp);
616: }
617:
618: /* clear the event if it has not sprung */
619: clrevent(ev);
620:
621: /* clean up the books and exit */
622: LineNumber++;
623: if (p == NULL)
624: {
625: buf[0] = '\0';
626: return (NULL);
627: }
628: for (p = buf; *p != '\0'; p++)
629: *p &= ~0200;
630: return (buf);
631: }
632:
633: static
634: readtimeout()
635: {
636: longjmp(CtxReadTimeout, 1);
637: }
638: /*
639: ** FGETFOLDED -- like fgets, but know about folded lines.
640: **
641: ** Parameters:
642: ** buf -- place to put result.
643: ** n -- bytes available.
644: ** f -- file to read from.
645: **
646: ** Returns:
647: ** buf on success, NULL on error or EOF.
648: **
649: ** Side Effects:
650: ** buf gets lines from f, with continuation lines (lines
651: ** with leading white space) appended. CRLF's are mapped
652: ** into single newlines. Any trailing NL is stripped.
653: */
654:
655: char *
656: fgetfolded(buf, n, f)
657: char *buf;
658: register int n;
659: FILE *f;
660: {
661: register char *p = buf;
662: register int i;
663:
664: n--;
665: while ((i = getc(f)) != EOF)
666: {
667: if (i == '\r')
668: {
669: i = getc(f);
670: if (i != '\n')
671: {
672: if (i != EOF)
673: (void) ungetc(i, f);
674: i = '\r';
675: }
676: }
677: if (--n > 0)
678: *p++ = i;
679: if (i == '\n')
680: {
681: LineNumber++;
682: i = getc(f);
683: if (i != EOF)
684: (void) ungetc(i, f);
685: if (i != ' ' && i != '\t')
686: {
687: *--p = '\0';
688: return (buf);
689: }
690: }
691: }
692: return (NULL);
693: }
694: /*
695: ** CURTIME -- return current time.
696: **
697: ** Parameters:
698: ** none.
699: **
700: ** Returns:
701: ** the current time.
702: **
703: ** Side Effects:
704: ** none.
705: */
706:
707: time_t
708: curtime()
709: {
710: auto time_t t;
711:
712: (void) time(&t);
713: return (t);
714: }
715: /*
716: ** ATOBOOL -- convert a string representation to boolean.
717: **
718: ** Defaults to "TRUE"
719: **
720: ** Parameters:
721: ** s -- string to convert. Takes "tTyY" as true,
722: ** others as false.
723: **
724: ** Returns:
725: ** A boolean representation of the string.
726: **
727: ** Side Effects:
728: ** none.
729: */
730:
731: bool
732: atobool(s)
733: register char *s;
734: {
735: if (*s == '\0' || index("tTyY", *s) != NULL)
736: return (TRUE);
737: return (FALSE);
738: }
739: /*
740: ** ATOOCT -- convert a string representation to octal.
741: **
742: ** Parameters:
743: ** s -- string to convert.
744: **
745: ** Returns:
746: ** An integer representing the string interpreted as an
747: ** octal number.
748: **
749: ** Side Effects:
750: ** none.
751: */
752:
753: atooct(s)
754: register char *s;
755: {
756: register int i = 0;
757:
758: while (*s >= '0' && *s <= '7')
759: i = (i << 3) | (*s++ - '0');
760: return (i);
761: }
762: /*
763: ** WAITFOR -- wait for a particular process id.
764: **
765: ** Parameters:
766: ** pid -- process id to wait for.
767: **
768: ** Returns:
769: ** status of pid.
770: ** -1 if pid never shows up.
771: **
772: ** Side Effects:
773: ** none.
774: */
775:
776: waitfor(pid)
777: int pid;
778: {
779: auto int st;
780: int i;
781:
782: do
783: {
784: errno = 0;
785: i = wait(&st);
786: } while ((i >= 0 || errno == EINTR) && i != pid);
787: if (i < 0)
788: st = -1;
789: return (st);
790: }
791: /*
792: ** BITINTERSECT -- tell if two bitmaps intersect
793: **
794: ** Parameters:
795: ** a, b -- the bitmaps in question
796: **
797: ** Returns:
798: ** TRUE if they have a non-null intersection
799: ** FALSE otherwise
800: **
801: ** Side Effects:
802: ** none.
803: */
804:
805: bool
806: bitintersect(a, b)
807: BITMAP a;
808: BITMAP b;
809: {
810: int i;
811:
812: for (i = BITMAPBYTES / sizeof (int); --i >= 0; )
813: if ((a[i] & b[i]) != 0)
814: return (TRUE);
815: return (FALSE);
816: }
817: /*
818: ** BITZEROP -- tell if a bitmap is all zero
819: **
820: ** Parameters:
821: ** map -- the bit map to check
822: **
823: ** Returns:
824: ** TRUE if map is all zero.
825: ** FALSE if there are any bits set in map.
826: **
827: ** Side Effects:
828: ** none.
829: */
830:
831: bool
832: bitzerop(map)
833: BITMAP map;
834: {
835: int i;
836:
837: for (i = BITMAPBYTES / sizeof (int); --i >= 0; )
838: if (map[i] != 0)
839: return (FALSE);
840: return (TRUE);
841: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.