1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <ctype.h>
33 #include <wctype.h>
34 #include <widec.h>
35 #include <dlfcn.h>
36 #include <locale.h>
37 #include <sys/param.h>
38 #include <string.h>
39
40 /*
41 * fmt -- format the concatenation of input files or standard input
42 * onto standard output. Designed for use with Mail ~|
43 *
44 * Syntax: fmt [ -width | -w width ] [ -cs ] [ name ... ]
45 * Author: Kurt Shoens (UCB) 12/7/78
46 */
47
48 #define NOSTR ((wchar_t *)0) /* Null string pointer for lint */
49 #define MAXLINES 100 /* maximum mail header lines to verify */
50
51 wchar_t outbuf[BUFSIZ]; /* Sandbagged output line image */
52 wchar_t *outp; /* Pointer in above */
53 int filler; /* Filler amount in outbuf */
54 char sobuf[BUFSIZ]; /* Global buffer */
55
56 int pfx; /* Current leading blank count */
57 int width = 72; /* Width that we will not exceed */
58 int nojoin = 0; /* split lines only, don't join short ones */
59 int errs = 0; /* Current number of errors */
60
61 enum crown_type {c_none, c_reset, c_head, c_lead, c_fixup, c_body};
62 enum crown_type crown_state; /* Crown margin state */
63 int crown_head; /* The header offset */
64 int crown_body; /* The body offset */
65 /* currently-known initial strings found in mail headers */
66 wchar_t *headnames[] = {
67 L"Apparently-To", L"Bcc", L"bcc", L"Cc", L"cc", L"Confirmed-By",
68 L"Content", L"content-length", L"From", L"Date", L"id",
69 L"Message-I", L"MIME-Version", L"Precedence", L"Return-Path",
70 L"Received", L"Reply-To", L"Status", L"Subject", L"To", L"X-IMAP",
71 L"X-Lines", L"X-Sender", L"X-Sun", L"X-Status", L"X-UID",
72 0};
73
74 enum hdr_type {
75 off, /* mail header processing is off */
76 not_in_hdr, /* not currently processing a mail header */
77 in_hdr, /* currently filling hdrbuf with potential hdr lines */
78 flush_hdr, /* flush hdrbuf; not a header, no special processing */
79 do_hdr /* process hdrbuf as a mail header */
80 };
81 /* current state of hdrbuf */
82 enum hdr_type hdr_state = not_in_hdr;
83
84 wchar_t *hdrbuf[MAXLINES]; /* buffer to hold potential mail header lines */
85 int h_lines; /* index into lines of hdrbuf */
86
87 void (*(split))(wchar_t []);
88 extern int scrwidth(wchar_t);
89 extern boolean_t is_headline(const char *);
90
91
92 static void fill_hdrbuf(wchar_t []);
93 static void header_chk(void);
94 static void process_hdrbuf(void);
95 static void leadin(void);
96 static void tabulate(wchar_t []);
97 static void oflush(void);
98 static void pack(wchar_t []);
99 static void msplit(wchar_t []);
100 static void csplit(wchar_t []);
101 static void _wckind_init(void);
102 static void prefix(wchar_t []);
103 static void fmt(FILE *);
104 static int setopt(char *);
105 int _wckind(wchar_t);
106
107 /*
108 * Drive the whole formatter by managing input files. Also,
109 * cause initialization of the output stuff and flush it out
110 * at the end.
111 */
112
113 int
main(int argc,char ** argv)114 main(int argc, char **argv)
115 {
116 FILE *fi;
117 char *cp;
118 int nofile;
119 char *locale;
120
121 outp = NOSTR;
122 setbuf(stdout, sobuf);
123 setlocale(LC_ALL, "");
124 locale = setlocale(LC_CTYPE, "");
125 if (strcmp(locale, "C") == 0) {
126 split = csplit;
127 } else {
128 split = msplit;
129 _wckind_init();
130 }
131 if (argc < 2) {
132 single:
133 fmt(stdin);
134 oflush();
135 exit(0);
136 }
137 nofile = 1;
138 while (--argc) {
139 cp = *++argv;
140 if (setopt(cp))
141 continue;
142 nofile = 0;
143 if ((fi = fopen(cp, "r")) == NULL) {
144 perror(cp);
145 errs++;
146 continue;
147 }
148 fmt(fi);
149 fclose(fi);
150 }
151 if (nofile)
152 goto single;
153 oflush();
154 fclose(stdout);
155 return (errs);
156 }
157
158 /*
159 * Read up characters from the passed input file, forming lines,
160 * doing ^H processing, expanding tabs, stripping trailing blanks,
161 * and sending each line down for analysis.
162 */
163
164 static void
fmt(FILE * fi)165 fmt(FILE *fi)
166 {
167 wchar_t linebuf[BUFSIZ], canonb[BUFSIZ];
168 wchar_t *cp, *cp2;
169 int col;
170 wchar_t c;
171 char cbuf[BUFSIZ]; /* stores wchar_t string as char string */
172
173 c = getwc(fi);
174 while (c != EOF) {
175 /*
176 * Collect a line, doing ^H processing.
177 * Leave tabs for now.
178 */
179
180 cp = linebuf;
181 while (c != L'\n' && c != EOF && cp-linebuf < BUFSIZ-1) {
182 if (c == L'\b') {
183 if (cp > linebuf)
184 cp--;
185 c = getwc(fi);
186 continue;
187 }
188 if (!(iswprint(c)) && c != L'\t') {
189 c = getwc(fi);
190 continue;
191 }
192 *cp++ = c;
193 c = getwc(fi);
194 }
195 *cp = L'\0';
196
197 /*
198 * Toss anything remaining on the input line.
199 */
200
201 while (c != L'\n' && c != EOF)
202 c = getwc(fi);
203 /*
204 * Expand tabs on the way to canonb.
205 */
206
207 col = 0;
208 cp = linebuf;
209 cp2 = canonb;
210 while (c = *cp++) {
211 if (c != L'\t') {
212 col += scrwidth(c);
213 if (cp2-canonb < BUFSIZ-1)
214 *cp2++ = c;
215 continue;
216 }
217 do {
218 if (cp2-canonb < BUFSIZ-1)
219 *cp2++ = L' ';
220 col++;
221 } while ((col & 07) != 0);
222 }
223
224 /*
225 * Swipe trailing blanks from the line.
226 */
227
228 for (cp2--; cp2 >= canonb && *cp2 == L' '; cp2--) {
229 }
230 *++cp2 = '\0';
231
232 /* special processing to look for mail header lines */
233 switch (hdr_state) {
234 case off:
235 prefix(canonb);
236 /* FALLTHROUGH */
237 case not_in_hdr:
238 /* look for an initial mail header line */
239 /* skip initial blanks */
240 for (cp = canonb; *cp == L' '; cp++) {
241 }
242 /*
243 * Need to convert string from wchar_t to char,
244 * since this is what is_headline() expects. Since we
245 * only want to make sure cp points to a "From" line
246 * of the email, we don't have to alloc
247 * BUFSIZ * MB_LEN_MAX to cbuf.
248 */
249 wcstombs(cbuf, cp, (BUFSIZ - 1));
250 if (is_headline(cbuf) == B_TRUE) {
251 hdr_state = in_hdr;
252 fill_hdrbuf(canonb);
253 } else {
254 /* no mail header line; process normally */
255 prefix(canonb);
256 }
257 break;
258 case in_hdr:
259 /* already saw 1st mail header line; look for more */
260 if (canonb[0] == L'\0') {
261 /*
262 * blank line means end of mail header;
263 * verify current mail header buffer
264 * then process it accordingly
265 */
266 header_chk();
267 process_hdrbuf();
268 /* now process the current blank line */
269 prefix(canonb);
270 } else
271 /*
272 * not a blank line--save this line as
273 * a potential mail header line
274 */
275 fill_hdrbuf(canonb);
276 break;
277 }
278 if (c != EOF)
279 c = getwc(fi);
280 }
281 /*
282 * end of this file--make sure we process the stuff in
283 * hdrbuf before we're finished
284 */
285 if (hdr_state == in_hdr) {
286 header_chk();
287 process_hdrbuf();
288 }
289 }
290
291 /*
292 * Take a line devoid of tabs and other garbage and determine its
293 * blank prefix. If the indent changes, call for a linebreak.
294 * If the input line is blank, echo the blank line on the output.
295 * Finally, if the line minus the prefix is a mail header, try to keep
296 * it on a line by itself.
297 */
298
299 static void
prefix(wchar_t line[])300 prefix(wchar_t line[])
301 {
302 wchar_t *cp;
303 int np;
304 int nosplit = 0; /* flag set if line should not be split */
305
306 if (line[0] == L'\0') {
307 oflush();
308 putchar('\n');
309 if (crown_state != c_none)
310 crown_state = c_reset;
311 return;
312 }
313 for (cp = line; *cp == L' '; cp++) {
314 }
315 np = cp - line;
316
317 /*
318 * The following horrible expression attempts to avoid linebreaks
319 * when the indent changes due to a paragraph.
320 */
321
322 if (crown_state == c_none && np != pfx && (np > pfx || abs(pfx-np) > 8))
323 oflush();
324 /*
325 * if this is a mail header line, don't split it; flush previous
326 * line, if any, so we don't join this line to it
327 */
328 if (hdr_state == do_hdr) {
329 nosplit = 1;
330 oflush();
331 }
332 /* flush previous line so we don't join this one to it */
333 if (nojoin)
334 oflush();
335 /* nroff-type lines starting with '.' are not split nor joined */
336 if (!nosplit && (nosplit = (*cp == L'.')))
337 oflush();
338 pfx = np;
339 switch (crown_state) {
340 case c_reset:
341 crown_head = pfx;
342 crown_state = c_head;
343 break;
344 case c_lead:
345 crown_body = pfx;
346 crown_state = c_body;
347 break;
348 case c_fixup:
349 crown_body = pfx;
350 crown_state = c_body;
351 if (outp) {
352 wchar_t s[BUFSIZ];
353
354 *outp = L'\0';
355 wscpy(s, &outbuf[crown_head]);
356 outp = NOSTR;
357 split(s);
358 }
359 break;
360 }
361 if (nosplit) {
362 /* put whole input line onto outbuf and print it out */
363 pack(cp);
364 oflush();
365 } else
366 /*
367 * split puts current line onto outbuf, but splits it
368 * at word boundaries, if it exceeds desired length
369 */
370 split(cp);
371 if (nojoin)
372 /*
373 * flush current line so next lines, if any,
374 * won't join to this one
375 */
376 oflush();
377 }
378
379 /*
380 * Split up the passed line into output "words" which are
381 * maximal strings of non-blanks with the blank separation
382 * attached at the end. Pass these words along to the output
383 * line packer.
384 */
385
386 static void
csplit(wchar_t line[])387 csplit(wchar_t line[])
388 {
389 wchar_t *cp, *cp2;
390 wchar_t word[BUFSIZ];
391 static const wchar_t *srchlist = (const wchar_t *) L".:!?";
392
393 cp = line;
394 while (*cp) {
395 cp2 = word;
396
397 /*
398 * Collect a 'word,' allowing it to contain escaped
399 * white space.
400 */
401
402 while (*cp && !(iswspace(*cp))) {
403 if (*cp == '\\' && iswspace(cp[1]))
404 *cp2++ = *cp++;
405 *cp2++ = *cp++;
406 }
407
408 /*
409 * Guarantee a space at end of line.
410 * Two spaces after end of sentence punctuation.
411 */
412
413 if (*cp == L'\0') {
414 *cp2++ = L' ';
415 if (wschr(srchlist, cp[-1]) != NULL)
416 *cp2++ = L' ';
417 }
418 while (iswspace(*cp))
419 *cp2++ = *cp++;
420 *cp2 = L'\0';
421 pack(word);
422 }
423 }
424
425 static void
msplit(wchar_t line[])426 msplit(wchar_t line[])
427 {
428 wchar_t *cp, *cp2, prev;
429 wchar_t word[BUFSIZ];
430 static const wchar_t *srchlist = (const wchar_t *) L".:!?";
431
432 cp = line;
433 while (*cp) {
434 cp2 = word;
435 prev = *cp;
436
437 /*
438 * Collect a 'word,' allowing it to contain escaped
439 * white space.
440 */
441
442 while (*cp) {
443 if (iswspace(*cp))
444 break;
445 if (_wckind(*cp) != _wckind(prev))
446 if (wcsetno(*cp) != 0 || wcsetno(prev) != 0)
447 break;
448 if (*cp == '\\' && iswspace(cp[1]))
449 *cp2++ = *cp++;
450 prev = *cp;
451 *cp2++ = *cp++;
452 }
453
454 /*
455 * Guarantee a space at end of line.
456 * Two spaces after end of sentence punctuation.
457 */
458
459 if (*cp == L'\0') {
460 *cp2++ = L' ';
461 if (wschr(srchlist, cp[-1]) != NULL)
462 *cp2++ = L' ';
463 }
464 while (iswspace(*cp))
465 *cp2++ = *cp++;
466 *cp2 = L'\0';
467 pack(word);
468 }
469 }
470
471 /*
472 * Output section.
473 * Build up line images from the words passed in. Prefix
474 * each line with correct number of blanks. The buffer "outbuf"
475 * contains the current partial line image, including prefixed blanks.
476 * "outp" points to the next available space therein. When outp is NOSTR,
477 * there ain't nothing in there yet. At the bottom of this whole mess,
478 * leading tabs are reinserted.
479 */
480
481 /*
482 * Pack a word onto the output line. If this is the beginning of
483 * the line, push on the appropriately-sized string of blanks first.
484 * If the word won't fit on the current line, flush and begin a new
485 * line. If the word is too long to fit all by itself on a line,
486 * just give it its own and hope for the best.
487 */
488
489 static void
pack(wchar_t word[])490 pack(wchar_t word[])
491 {
492 wchar_t *cp;
493 int s, t;
494
495 if (outp == NOSTR)
496 leadin();
497 t = wscol(word);
498 *outp = L'\0';
499 s = wscol(outbuf);
500 if (t+s <= width) {
501 for (cp = word; *cp; *outp++ = *cp++) {
502 }
503 return;
504 }
505 if (s > filler) {
506 oflush();
507 leadin();
508 }
509 for (cp = word; *cp; *outp++ = *cp++) {
510 }
511 }
512
513 /*
514 * If there is anything on the current output line, send it on
515 * its way. Set outp to NOSTR to indicate the absence of the current
516 * line prefix.
517 */
518
519 static void
oflush(void)520 oflush(void)
521 {
522 if (outp == NOSTR)
523 return;
524 *outp = L'\0';
525 tabulate(outbuf);
526 outp = NOSTR;
527 }
528
529 /*
530 * Take the passed line buffer, insert leading tabs where possible, and
531 * output on standard output (finally).
532 */
533
534 static void
tabulate(wchar_t line[])535 tabulate(wchar_t line[])
536 {
537 wchar_t *cp;
538 int b, t;
539
540
541 /* Toss trailing blanks in the output line */
542 cp = line + wslen(line) - 1;
543 while (cp >= line && *cp == L' ')
544 cp--;
545 *++cp = L'\0';
546 /* Count the leading blank space and tabulate */
547 for (cp = line; *cp == L' '; cp++) {
548 }
549 b = cp - line;
550 t = b >> 3;
551 b &= 07;
552 if (t > 0)
553 do {
554 putc('\t', stdout);
555 } while (--t);
556 if (b > 0)
557 do {
558 putc(' ', stdout);
559 } while (--b);
560 while (*cp)
561 putwc(*cp++, stdout);
562 putc('\n', stdout);
563 }
564
565 /*
566 * Initialize the output line with the appropriate number of
567 * leading blanks.
568 */
569
570 static void
leadin(void)571 leadin(void)
572 {
573 int b;
574 wchar_t *cp;
575 int l;
576
577 switch (crown_state) {
578 case c_head:
579 l = crown_head;
580 crown_state = c_lead;
581 break;
582
583 case c_lead:
584 case c_fixup:
585 l = crown_head;
586 crown_state = c_fixup;
587 break;
588
589 case c_body:
590 l = crown_body;
591 break;
592
593 default:
594 l = pfx;
595 break;
596 }
597 filler = l;
598 for (b = 0, cp = outbuf; b < l; b++)
599 *cp++ = L' ';
600 outp = cp;
601 }
602
603 /*
604 * Is s1 a prefix of s2??
605 */
606
607 static int
ispref(wchar_t * s1,wchar_t * s2)608 ispref(wchar_t *s1, wchar_t *s2)
609 {
610
611 while (*s1 != L'\0' && *s2 != L'\0')
612 if (*s1++ != *s2++)
613 return (0);
614 return (1);
615 }
616
617 /*
618 * Set an input option
619 */
620
621 static int
setopt(char * cp)622 setopt(char *cp)
623 {
624 static int ws = 0;
625
626 if (*cp == '-') {
627 if (cp[1] == 'c' && cp[2] == '\0') {
628 crown_state = c_reset;
629 return (1);
630 }
631 if (cp[1] == 's' && cp[2] == '\0') {
632 nojoin = 1;
633 return (1);
634 }
635 if (cp[1] == 'w' && cp[2] == '\0') {
636 ws++;
637 return (1);
638 }
639 width = atoi(cp+1);
640 } else if (ws) {
641 width = atoi(cp);
642 ws = 0;
643 } else
644 return (0);
645 if (width <= 0 || width >= BUFSIZ-2) {
646 fprintf(stderr, "fmt: bad width: %d\n", width);
647 exit(1);
648 }
649 return (1);
650 }
651
652
653 #define LIB_WDRESOLVE "/usr/lib/locale/%s/LC_CTYPE/wdresolve.so"
654 #define WCHKIND "_wdchkind_"
655
656 static int _wckind_c_locale(wchar_t);
657
658 static int (*__wckind)(wchar_t) = _wckind_c_locale;
659 static void *dlhandle = NULL;
660
661
662 static void
_wckind_init(void)663 _wckind_init(void)
664 {
665 char *locale;
666 char path[MAXPATHLEN + 1];
667
668
669 if (dlhandle != NULL) {
670 (void) dlclose(dlhandle);
671 dlhandle = NULL;
672 }
673
674 locale = setlocale(LC_CTYPE, NULL);
675 if (strcmp(locale, "C") == 0)
676 goto c_locale;
677
678 (void) sprintf(path, LIB_WDRESOLVE, locale);
679
680 if ((dlhandle = dlopen(path, RTLD_LAZY)) != NULL) {
681 __wckind = (int (*)(wchar_t))dlsym(dlhandle, WCHKIND);
682 if (__wckind != NULL)
683 return;
684 (void) dlclose(dlhandle);
685 dlhandle = NULL;
686 }
687
688 c_locale:
689 __wckind = _wckind_c_locale;
690 }
691
692
693 int
_wckind(wchar_t wc)694 _wckind(wchar_t wc)
695 {
696 return (*__wckind) (wc);
697 }
698
699
700 static int
_wckind_c_locale(wchar_t wc)701 _wckind_c_locale(wchar_t wc)
702 {
703 int ret;
704
705 /*
706 * DEPEND_ON_ANSIC: L notion for the character is new in
707 * ANSI-C, k&r compiler won't work.
708 */
709 if (iswascii(wc))
710 ret = (iswalnum(wc) || wc == L'_') ? 0 : 1;
711 else
712 ret = wcsetno(wc) + 1;
713
714 return (ret);
715 }
716
717 /*
718 * header_chk -
719 * Called when done looking for a set mail header lines.
720 * Either a blank line was seen, or EOF was reached.
721 *
722 * Verifies if current hdrbuf of potential mail header lines
723 * is really a mail header. A mail header must be at least 2
724 * lines and more than half of them must start with one of the
725 * known mail header strings in headnames.
726 *
727 * header_chk sets hdr_state to do_hdr if hdrbuf contained a valid
728 * mail header. Otherwise, it sets hdr_state to flush_hdr.
729 *
730 * h_lines = hdrbuf index for next line to be saved;
731 * also indicates current # of lines in potential header
732 */
733 static void
header_chk(void)734 header_chk(void)
735 {
736 wchar_t *cp; /* ptr to current char of line */
737 wchar_t **hp; /* ptr to current char of a valid */
738 /* mail header string */
739 int l; /* index */
740 /*
741 * number of lines in hdrbuf that look
742 * like mail header lines (start with
743 * a known mail header prefix)
744 */
745 int hdrcount = 0;
746 /* header must have at least 2 lines (h_lines > 1) */
747 if (h_lines < 2) {
748 hdr_state = flush_hdr;
749 return;
750 }
751 /*
752 * go through each line in hdrbuf and see how many
753 * look like mail header lines
754 */
755 for (l = 0; l < h_lines; l++) {
756 /* skip initial blanks */
757 for (cp = hdrbuf[l]; *cp == L' '; cp++) {
758 }
759 for (hp = &headnames[0]; *hp != (wchar_t *)0; hp++)
760 if (ispref(*hp, cp)) {
761 hdrcount++;
762 break;
763 }
764 }
765 /*
766 * if over half match, we'll assume this is a header;
767 * set hdr_state to indicate whether to treat
768 * these lines as mail header (do_hdr) or not (flush_hdr)
769 */
770 if (hdrcount > h_lines / 2)
771 hdr_state = do_hdr;
772 else
773 hdr_state = flush_hdr;
774 }
775
776 /*
777 * fill_hdrbuf -
778 * Save given input line into next element of hdrbuf,
779 * as a potential mail header line, to be processed later
780 * once we decide whether or not the contents of hdrbuf is
781 * really a mail header, via header_chk().
782 *
783 * Does not allow hdrbuf to exceed MAXLINES lines.
784 * Dynamically allocates space for each line. If we are unable
785 * to allocate space for the current string, stop special mail
786 * header preservation at this point and continue formatting
787 * without it.
788 */
789 static void
fill_hdrbuf(wchar_t line[])790 fill_hdrbuf(wchar_t line[])
791 {
792 wchar_t *cp; /* pointer to characters in input line */
793 int i; /* index into characters a hdrbuf line */
794
795 if (h_lines >= MAXLINES) {
796 /*
797 * if we run over MAXLINES potential mail header
798 * lines, stop checking--this is most likely NOT a
799 * mail header; flush out the hdrbuf, then process
800 * the current 'line' normally.
801 */
802 hdr_state = flush_hdr;
803 process_hdrbuf();
804 prefix(line);
805 return;
806 }
807 hdrbuf[h_lines] = (wchar_t *)malloc(sizeof (wchar_t) *
808 (wslen(line) + 1));
809 if (hdrbuf[h_lines] == NULL) {
810 perror("malloc");
811 fprintf(stderr, "fmt: unable to do mail header preservation\n");
812 errs++;
813 /*
814 * Can't process mail header; flush current contents
815 * of mail header and continue with no more mail
816 * header processing
817 */
818 if (h_lines == 0)
819 /* hdrbuf is empty; process this line normally */
820 prefix(line);
821 else {
822 hdr_state = flush_hdr;
823 for (i = 0; i < h_lines; i++) {
824 prefix(hdrbuf[i]);
825 free(hdrbuf[i]);
826 }
827 h_lines = 0;
828 }
829 hdr_state = off;
830 return;
831 }
832 /* save this line as a potential mail header line */
833 for (i = 0, cp = line; (hdrbuf[h_lines][i] = *cp) != L'\0'; i++, cp++) {
834 }
835 h_lines++;
836 }
837
838 /*
839 * process_hdrbuf -
840 * Outputs the lines currently stored in hdrbuf, according
841 * to the current hdr_state value, assumed to be either do_hdr
842 * or flush_hdr.
843 * This should be called after doing a header_chk() to verify
844 * the hdrbuf and set the hdr_state flag.
845 */
846 static void
process_hdrbuf(void)847 process_hdrbuf(void)
848 {
849 int i;
850
851 for (i = 0; i < h_lines; i++) {
852 prefix(hdrbuf[i]);
853 free(hdrbuf[i]);
854 }
855 hdr_state = not_in_hdr;
856 h_lines = 0;
857 }
858