![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scansbr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip|
Return to scansbr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip |
1.1 root 1: /* scansbr.c - routines to help scan along... */
2:
3: #include "../h/mh.h"
4: #include "../h/addrsbr.h"
5: #include "../h/formatsbr.h"
6: #include "../h/scansbr.h"
7: #include "../zotnet/tws.h"
8: #include <stdio.h>
9: #include <ctype.h>
10: #include <sys/types.h>
11: #include <sys/stat.h>
12:
13:
14: #define MAXSCANL 256 /* longest possible scan line */
15: #define SBUFSIZ 128 /* buffer size for content part of header
16: * fields. We want this to be large
17: * enough so that we don't do a lot of
18: * extra FLDPLUS calls on m_getfld but
19: * small enough so that we don't snarf
20: * the entire message body when we're
21: * only going to display 30 characters
22: * of it.
23: */
24:
25: /* */
26:
27: static struct format *fmt;
28:
29: static struct comp *datecomp; /* pntr to "date" comp */
30: static struct comp *bodycomp; /* pntr to "body" pseudo-comp
31: * (if referenced) */
32: static int ncomps = 0; /* # of interesting components */
33: static char **compbuffers = 0; /* buffers for component text */
34: static struct comp **used_buf = 0; /* stack for comp that use buffers */
35:
36: char *scanl = 0; /* text of most recent scanline */
37:
38: static int dat[4]; /* aux. data for format routine */
39:
40: #ifdef RPATHS
41: char *unixline (); /* info from UNIX From: line */
42: #endif RPATHS
43:
44: #define FPUTS(buf) {\
45: if (fputs(buf,scnout) == EOF)\
46: adios (scnmsg, "write error on");\
47: }
48:
49: /* */
50:
51: /* ARGSUSED */
52:
53: int scan (inb, innum, outnum, nfs, width, curflg, header, size, noisy)
54: char *nfs;
55: int innum,
56: outnum,
57: width,
58: curflg,
59: header,
60: noisy;
61: long size;
62: register FILE *inb;
63: {
64: int compnum,
65: state;
66: register int i;
67: register struct comp *cptr;
68: register char *tmpbuf;
69: register char **nxtbuf;
70: register struct comp **savecomp;
71: char *scnmsg;
72: FILE *scnout;
73: char name[NAMESZ];
74: static int slwidth;
75: #ifdef RPATHS
76: char *cp;
77: #endif RPATHS
78:
79: /* first-time only initialization */
80: if (scanl == NULLCP) {
81: if (width == 0) {
82: if ((width = sc_width ()) < WIDTH/2)
83: width = WIDTH/2;
84: else if (width > MAXSCANL)
85: width = MAXSCANL;
86: }
87: dat[3] = slwidth = width;
88: scanl = (char *)malloc( (unsigned) (slwidth + 2) );
89: if (outnum)
90: (void) umask( ~ m_gmprot() );
91:
92: ncomps = fmt_compile (nfs, &fmt) + 1;
93: FINDCOMP(bodycomp, "body");
94: FINDCOMP(datecomp, "date");
95: nxtbuf = compbuffers = (char **)calloc((unsigned) ncomps,sizeof(char *));
96: used_buf = (struct comp **)calloc((unsigned) (ncomps+1),sizeof(struct comp *));
97: used_buf += ncomps+1; *--used_buf = 0;
98: for (i = ncomps; i--; )
99: *nxtbuf++ = malloc( SBUFSIZ );
100: }
101: /* each-message initialization */
102: nxtbuf = compbuffers;
103: savecomp = used_buf;
104: tmpbuf = *nxtbuf++;
105: dat[0] = innum? innum : outnum;
106: dat[1] = curflg;
107:
108: /*
109: * get the first field. If the msg is non-empty and we're doing
110: * an "inc", open the output file.
111: */
112: if ((state = m_getfld (FLD, name, tmpbuf, SBUFSIZ, inb)) == FILEEOF)
113: return SCNEOF;
114:
115: if (outnum) {
116: scnmsg = m_name (outnum);
117: if (*scnmsg == '?') /* msg num out of range */
118: return SCNNUM;
119: if ((scnout = fopen (scnmsg, "w")) == NULL)
120: adios (scnmsg, "unable to write");
121: #ifdef RPATHS
122: if ((cp = unixline ()) && *cp) {
123: FPUTS ("Return-Path: ");
124: FPUTS (cp);
125: }
126: #endif RPATHS
127: }
128:
129: /* scan - main loop */
130: for (compnum = 1; ; state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb)) {
131: switch (state) {
132: case FLD:
133: case FLDPLUS:
134: compnum++;
135: if (outnum) {
136: FPUTS (name);
137: (void) putc (':', scnout);
138: FPUTS (tmpbuf);
139: }
140: /*
141: * if we're interested in this component, save a pointer
142: * to the component text, then start using our next free
143: * buffer as the component temp buffer (buffer switching
144: * saves an extra copy of the component text).
145: */
146: if (cptr = wantcomp[CHASH(name)])
147: do {
148: if (uleq(name, cptr->c_name)) {
149: if (! cptr->c_text) {
150: cptr->c_text = tmpbuf;
151: *--savecomp = cptr;
152: tmpbuf = *nxtbuf++;
153: }
154: break;
155: }
156: } while (cptr = cptr->c_next);
157:
158: while (state == FLDPLUS) {
159: state = m_getfld (state, name, tmpbuf, SBUFSIZ, inb);
160: if (outnum)
161: FPUTS (tmpbuf);
162: }
163: break;
164:
165: case BODY:
166: compnum = -1;
167: if (! outnum) {
168: state = FILEEOF; /* stop now if scan cmd */
169: goto finished;
170: }
171: (void) putc ('\n', scnout);
172: FPUTS (tmpbuf);
173: /*
174: * performance hack: some people like to run "inc" on
175: * things like net.sources or large digests. We do a
176: * copy directly into the output buffer rather than
177: * going through an intermediate buffer.
178: *
179: * We need the amount of data m_getfld found & don't
180: * want to do a strlen on the long buffer so there's
181: * a hack in m_getfld to save the amount of data it
182: * returned in the global "msg_count".
183: */
184: body: ;
185: while (state == BODY) {
186: if (scnout->_cnt <= 0) {
187: if (fflush(scnout) == EOF)
188: adios (scnmsg, "write error on");
189: }
190: state = m_getfld( state, name, scnout->_ptr,
191: -(scnout->_cnt), inb );
192: scnout->_cnt -= msg_count;
193: scnout->_ptr += msg_count;
194: }
195: goto finished;
196:
197: case LENERR:
198: case FMTERR:
199: fprintf (stderr,
200: innum ? "??Format error (message %d) in "
201: : "??Format error in ",
202: outnum ? outnum : innum);
203: fprintf (stderr, "component %d\n", compnum);
204:
205: if (outnum) {
206: FPUTS ("\n\nBAD MSG:\n");
207: FPUTS (name);
208: (void) putc ('\n', scnout);
209: state = BODY;
210: goto body;
211: }
212: /* fall through */
213:
214: case FILEEOF:
215: goto finished;
216:
217: default:
218: adios (NULLCP, "getfld() returned %d\n", state);
219: }
220: }
221: /*
222: * format and output the scan line.
223: */
224: finished:
225: if (noisy) {
226: if (bodycomp)
227: bodycomp->c_text = tmpbuf;
228:
229: if (size)
230: dat[2] = size;
231: else if (outnum)
232: dat[2] = ftell(scnout);
233:
234: if ( (datecomp && ! datecomp->c_text) || (!size && !outnum)) {
235: struct stat st;
236: (void) fstat (fileno(inb), &st);
237: if (!size && !outnum)
238: dat[2] = st.st_size;
239: if (datecomp) {
240: if (! datecomp->c_text) {
241: *datecomp->c_tws = *dlocaltime ((long *) &st.st_mtime);
242: datecomp->c_flags = -1;
243: } else {
244: datecomp->c_flags = 0;
245: }
246: }
247: }
248: (void) fmtscan (fmt, scanl, slwidth, dat);
249: (void) fputs (scanl, stdout);
250:
251: if (bodycomp)
252: bodycomp->c_text = NULLCP;
253: }
254:
255: /* return dynamically allocated buffers to pool */
256: while ( cptr = *savecomp++ ) {
257: *--nxtbuf = cptr->c_text;
258: cptr->c_text = NULLCP;
259: }
260: *--nxtbuf = tmpbuf;
261:
262: if (outnum)
263: if (fclose (scnout) == EOF)
264: adios (scnmsg, "write error on");
265:
266: return (state == FILEEOF? SCNMSG : SCNERR);
267: }
268:
269: /* */
270:
271: /* Cheat: we are loaded with adrparse, which wants a routine called
272: OfficialName(). We call adrparse:getm() with the correct arguments
273: to prevent OfficialName() from being called. Hence, the following
274: is to keep the loader happy.
275: */
276:
277: char *OfficialName (name)
278: register char *name;
279: {
280: return name;
281: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.