3 * scansbr.c -- routines to help scan along...
5 * This code is Copyright (c) 2002, by the authors of nmh. See the
6 * COPYRIGHT file in the root directory of the nmh distribution for
7 * complete copyright information.
11 #include <h/addrsbr.h>
12 #include <h/fmt_scan.h>
13 #include <h/scansbr.h>
17 #define MAXSCANL 256 /* longest possible scan line */
20 * Buffer size for content part of header fields. We want this
21 * to be large enough so that we don't do a lot of extra FLDPLUS
22 * calls on m_getfld but small enough so that we don't snarf
23 * the entire message body when we're only going to display 30
28 static struct format *fmt;
29 static struct comp *datecomp; /* pntr to "date" comp */
30 static struct comp *bodycomp; /* pntr to "body" pseudo-comp *
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 */
36 static int dat[5]; /* aux. data for format routine */
38 char *scanl = 0; /* text of most recent scanline */
40 #define DIEWRERR() adios (scnmsg, "write error on")
43 if (mh_fputs(buf,scnout) == EOF)\
50 static int mh_fputs(char *, FILE *);
52 #ifdef MULTIBYTE_SUPPORT
53 #define SCAN_CHARWIDTH MB_CUR_MAX
55 #define SCAN_CHARWIDTH 1
59 scan (FILE *inb, int innum, int outnum, char *nfs, int width, int curflg,
60 int unseen, char *folder, long size, int noisy)
62 int i, compnum, encrypted, state;
63 unsigned char *cp, *tmpbuf, *startbody;
65 char *saved_c_text = NULL;
67 struct comp **savecomp;
71 static int rlwidth, slwidth;
72 static size_t scanl_size;
74 /* first-time only initialization */
77 if ((width = sc_width ()) < WIDTH/2)
79 else if (width > MAXSCANL)
82 dat[3] = slwidth = width;
83 /* Arbitrarily allocate 20 * slwidth to provide room for lots
84 of escape sequences. */
85 scanl_size = SCAN_CHARWIDTH * (20 * slwidth + 2);
86 scanl = (char *) mh_xmalloc (scanl_size);
90 /* Compile format string */
91 ncomps = fmt_compile (nfs, &fmt, 1) + 2;
93 bodycomp = fmt_findcomp("body");
94 datecomp = fmt_findcomp("date");
95 cptr = fmt_findcomp("folder");
97 cptr->c_text = getcpy(folder);
98 if (fmt_addcompentry("encrypted")) {
101 cptr = fmt_findcomp("dtimenow");
103 cptr->c_text = getcpy(dtimenow (0));
106 * In other programs I got rid of this complicated buffer switching,
107 * but since scan reads lots of messages at once and this complicated
108 * memory management, I decided to keep it; otherwise there was
109 * the potential for a lot of malloc() and free()s, and I could
110 * see the malloc() pool really getting fragmented. Maybe it
111 * wouldn't be an issue in practice; perhaps this will get
114 * So, some notes for what's going on:
116 * nxtbuf is an array of pointers that contains malloc()'d buffers
117 * to hold our component text. used_buf is an array of struct comp
118 * pointers that holds pointers to component structures we found while
119 * processing a message.
121 * We read in the message with m_getfld(), using "tmpbuf" as our
122 * input buffer. tmpbuf is set at the start of message processing
123 * to the first buffer in our buffer pool (nxtbuf).
125 * Every time we find a component we care about, we set that component's
126 * text buffer to the current value of tmpbuf, and then switch tmpbuf
127 * to the next buffer in our pool. We also add that component to
130 * When we're done, we go back and zero out all of the component
131 * text buffer pointers that we saved in used_buf.
133 * Note that this means c_text memory is NOT owned by the fmt_module
134 * and it's our responsibility to free it.
137 nxtbuf = compbuffers = (char **) calloc((size_t) ncomps, sizeof(char *));
139 adios (NULL, "unable to allocate component buffers");
140 used_buf = (struct comp **) calloc((size_t) (ncomps+1),
141 sizeof(struct comp *));
142 if (used_buf == NULL)
143 adios (NULL, "unable to allocate component buffer stack");
144 used_buf += ncomps+1; *--used_buf = 0;
145 rlwidth = bodycomp && (width > SBUFSIZ) ? width : SBUFSIZ;
146 for (i = ncomps; i--; )
147 *nxtbuf++ = mh_xmalloc(rlwidth);
151 * each-message initialization
153 nxtbuf = compbuffers;
157 dat[0] = innum ? innum : outnum;
162 * Get the first field. If the message is non-empty
163 * and we're doing an "inc", open the output file.
165 if ((state = m_getfld (FLD, name, tmpbuf, rlwidth, inb)) == FILEEOF) {
167 advise("read", "unable to"); /* "read error" */
176 scnmsg = m_name (outnum);
177 if (*scnmsg == '?') /* msg num out of range */
180 scnmsg = "/dev/null";
182 if ((scnout = fopen (scnmsg, "w")) == NULL)
183 adios (scnmsg, "unable to write");
186 /* scan - main loop */
187 for (compnum = 1; ; state = m_getfld (state, name, tmpbuf, rlwidth, inb)) {
194 if ( putc (':', scnout) == EOF) DIEWRERR();
198 * if we're interested in this component, save a pointer
199 * to the component text, then start using our next free
200 * buffer as the component temp buffer (buffer switching
201 * saves an extra copy of the component text).
203 if ((cptr = fmt_findcasecomp(name))) {
204 if (! cptr->c_text) {
205 cptr->c_text = tmpbuf;
206 for (cp = tmpbuf + strlen (tmpbuf) - 1;
217 while (state == FLDPLUS) {
218 state = m_getfld (state, name, tmpbuf, rlwidth, inb);
227 * A slight hack ... if we have less than rlwidth characters
228 * in the buffer, call m_getfld again.
231 if ((i = strlen(tmpbuf)) < rlwidth) {
232 state = m_getfld (state, name, tmpbuf + i,
237 state = FILEEOF; /* stop now if scan cmd */
238 if (bodycomp && startbody == NULL)
242 if (putc ('\n', scnout) == EOF) DIEWRERR();
245 * The previous code here used to call m_getfld() using
246 * pointers to the underlying output stdio buffers to
247 * avoid the extra copy. Tests by Markus Schnalke show
248 * no noticable performance loss on larger mailboxes
249 * if we incur an extra copy, and messing around with
250 * internal stdio buffers is becoming more and more
251 * unportable as times go on. So from now on just deal
252 * with the overhead of an extra copy.
254 * Subtle change - with the previous code tmpbuf wasn't
255 * used, so we could reuse it for the {body} component.
256 * Now since we're using tmpbuf as our read buffer we
257 * need to save the beginning of the body for later.
258 * See the above (and below) use of startbody.
261 if (bodycomp && startbody == NULL) {
266 while (state == BODY) {
267 state = m_getfld(state, name, tmpbuf, rlwidth, inb);
275 innum ? "??Format error (message %d) in "
276 : "??Format error in ",
277 outnum ? outnum : innum);
278 fprintf (stderr, "component %d\n", compnum);
281 FPUTS ("\n\nBAD MSG:\n");
283 if (putc ('\n', scnout) == EOF) DIEWRERR();
293 adios (NULL, "getfld() returned %d", state);
298 * format and output the scan line.
302 advise("read", "unable to"); /* "read error" */
306 /* Save and restore buffer so we don't trash our dynamic pool! */
308 saved_c_text = bodycomp->c_text;
309 bodycomp->c_text = startbody;
316 dat[2] = ftell(scnout);
317 if (dat[2] == EOF) DIEWRERR();
320 if ((datecomp && !datecomp->c_text) || (!size && !outnum)) {
323 fstat (fileno(inb), &st);
324 if (!size && !outnum)
327 if (! datecomp->c_text) {
328 if (datecomp->c_tws == NULL)
329 datecomp->c_tws = (struct tws *)
330 calloc((size_t) 1, sizeof(*datecomp->c_tws));
331 if (datecomp->c_tws == NULL)
332 adios (NULL, "unable to allocate tws buffer");
333 *datecomp->c_tws = *dlocaltime ((time_t *) &st.st_mtime);
334 datecomp->c_flags |= CF_DATEFAB|CF_TRUE;
336 datecomp->c_flags &= ~CF_DATEFAB;
341 fmt_scan (fmt, scanl, scanl_size, slwidth, dat);
344 bodycomp->c_text = saved_c_text;
347 fputs (scanl, stdout);
349 cptr = fmt_findcomp ("encrypted");
350 encrypted = cptr && cptr->c_text;
352 /* return dynamically allocated buffers to pool */
353 while ((cptr = *savecomp++)) {
354 *--nxtbuf = cptr->c_text;
359 if (outnum && (ferror(scnout) || fclose (scnout) == EOF))
362 return (state != FILEEOF ? SCNERR : encrypted ? SCNENC : SCNMSG);
367 mh_fputs(char *s, FILE *stream)
372 if (putc (c,stream) == EOF )