make.rc, mk-conf.sh: OPT_DEVEL includes OPT_DEBUG, but not vice versa
[s-mailx.git] / filter.c
blobdaa564c88e4dd34b7ad104cbe65a03c0b914ad61
1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ Filter objects.
4 * Copyright (c) 2013 - 2016 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 #undef n_FILE
19 #define n_FILE filter
21 #ifndef HAVE_AMALGAMATION
22 # include "nail.h"
23 #endif
26 * Quotation filter
30 * TODO quotation filter: anticipate in future data: don't break if only WS
31 * TODO or a LF escaping \ follows on the line (simply reuse the latter).
34 #ifdef HAVE_QUOTE_FOLD
35 CTA(QUOTE_MAX > 3);
37 enum qf_state {
38 _QF_CLEAN,
39 _QF_PREFIX,
40 _QF_DATA
43 struct qf_vc {
44 struct quoteflt *self;
45 char const *buf;
46 size_t len;
49 /* Print out prefix and current quote */
50 static ssize_t _qf_dump_prefix(struct quoteflt *self);
52 /* Add one data character */
53 static ssize_t _qf_add_data(struct quoteflt *self, wchar_t wc);
55 /* State machine handlers */
56 static ssize_t _qf_state_prefix(struct qf_vc *vc);
57 static ssize_t _qf_state_data(struct qf_vc *vc);
59 static ssize_t
60 _qf_dump_prefix(struct quoteflt *self)
62 ssize_t rv;
63 size_t i;
64 NYD_ENTER;
66 if ((i = self->qf_pfix_len) > 0 && i != fwrite(self->qf_pfix, 1, i,
67 self->qf_os))
68 goto jerr;
69 rv = i;
71 if ((i = self->qf_currq.l) > 0 && i != fwrite(self->qf_currq.s, 1, i,
72 self->qf_os))
73 goto jerr;
74 rv += i;
75 jleave:
76 NYD_LEAVE;
77 return rv;
78 jerr:
79 rv = -1;
80 goto jleave;
83 static ssize_t
84 _qf_add_data(struct quoteflt *self, wchar_t wc)
86 char *save_b;
87 ui32_t save_l, save_w;
88 ssize_t rv = 0;
89 int w, l;
90 NYD_ENTER;
92 save_l = save_w = 0; /* silence cc */
93 save_b = NULL;
94 /* <newline> ends state */
95 if (wc == L'\n')
96 goto jflush;
97 if (wc == L'\r') /* TODO CR should be stripped in lower level!! */
98 goto jleave;
100 /* Unroll <tab> to spaces */
101 if (wc == L'\t') {
102 save_l = self->qf_datw;
103 save_w = (save_l + QUOTE_TAB_SPACES) & ~(QUOTE_TAB_SPACES - 1);
104 save_w -= save_l;
105 while (save_w-- > 0) {
106 ssize_t j = _qf_add_data(self, L' ');
107 if (j < 0) {
108 rv = j;
109 break;
111 rv += j;
113 goto jleave;
116 w = wcwidth(wc);
117 if (w == -1) {
118 jbad:
119 ++self->qf_datw;
120 self->qf_dat.s[self->qf_dat.l++] = '?';
121 } else {
122 l = wctomb(self->qf_dat.s + self->qf_dat.l, wc);
123 if (l < 0)
124 goto jbad;
125 self->qf_datw += (ui32_t)w;
126 self->qf_dat.l += (size_t)l;
129 /* TODO The last visual may excess (adjusted!) *qfold-max* if it's a wide;
130 * TODO place it on the next line, break before */
131 if (self->qf_datw >= self->qf_qfold_max) {
132 /* If we have seen a nice breakpoint during traversal, shuffle data
133 * around a bit so as to restore the trailing part after flushing */
134 if (self->qf_brkl > 0) {
135 save_w = self->qf_datw - self->qf_brkw;
136 save_l = self->qf_dat.l - self->qf_brkl;
137 save_b = self->qf_dat.s + self->qf_brkl + 2;
138 memmove(save_b, save_b - 2, save_l);
139 self->qf_dat.l = self->qf_brkl;
142 self->qf_dat.s[self->qf_dat.l++] = '\\';
143 jflush:
144 self->qf_dat.s[self->qf_dat.l++] = '\n';
145 rv = quoteflt_flush(self);
147 /* Restore takeovers, if any */
148 if (save_b != NULL) {
149 self->qf_brk_isws = FAL0;
150 self->qf_datw += save_w;
151 self->qf_dat.l = save_l;
152 memmove(self->qf_dat.s, save_b, save_l);
154 } else if (self->qf_datw >= self->qf_qfold_min && !self->qf_brk_isws) {
155 bool_t isws = (iswspace(wc) != 0);
157 if (isws || !self->qf_brk_isws || self->qf_brkl == 0) {
158 self->qf_brkl = self->qf_dat.l;
159 self->qf_brkw = self->qf_datw;
160 self->qf_brk_isws = isws;
164 /* If state changed to prefix, perform full reset (note this implies that
165 * quoteflt_flush() performs too much work..) */
166 if (wc == '\n') {
167 self->qf_state = _QF_PREFIX;
168 self->qf_wscnt = self->qf_datw = 0;
169 self->qf_currq.l = 0;
171 jleave:
172 NYD_LEAVE;
173 return rv;
176 static ssize_t
177 _qf_state_prefix(struct qf_vc *vc)
179 struct quoteflt *self;
180 ssize_t rv;
181 char const *buf;
182 size_t len, i;
183 wchar_t wc;
184 NYD_ENTER;
186 self = vc->self;
187 rv = 0;
189 for (buf = vc->buf, len = vc->len; len > 0;) {
190 /* xxx NULL BYTE! */
191 i = mbrtowc(&wc, buf, len, self->qf_mbps);
192 if (i == (size_t)-1) {
193 /* On hard error, don't modify mbstate_t and step one byte */
194 self->qf_mbps[0] = self->qf_mbps[1];
195 ++buf;
196 --len;
197 self->qf_wscnt = 0;
198 continue;
200 self->qf_mbps[1] = self->qf_mbps[0];
201 if (i == (size_t)-2) {
202 /* Redundant shift sequence, out of buffer */
203 len = 0;
204 break;
206 buf += i;
207 len -= i;
209 if (wc == L'\n')
210 goto jfin;
211 if (iswspace(wc)) {
212 ++self->qf_wscnt;
213 continue;
215 if (i == 1 && ISQUOTE(wc)) {
216 self->qf_wscnt = 0;
217 if (self->qf_currq.l >= QUOTE_MAX - 3) {
218 self->qf_currq.s[QUOTE_MAX - 3] = '.';
219 self->qf_currq.s[QUOTE_MAX - 2] = '.';
220 self->qf_currq.s[QUOTE_MAX - 1] = '.';
221 self->qf_currq.l = QUOTE_MAX;
222 } else
223 self->qf_currq.s[self->qf_currq.l++] = buf[-1];
224 continue;
227 /* The quote is parsed and compressed; dump it */
228 jfin:
229 self->qf_state = _QF_DATA;
230 /* Overtake WS to the current quote in order to preserve it for eventual
231 * necessary follow lines, too */
232 /* TODO we de-facto "normalize" to ASCII SP here which MESSES tabs!! */
233 while (self->qf_wscnt-- > 0 && self->qf_currq.l < QUOTE_MAX)
234 self->qf_currq.s[self->qf_currq.l++] = ' ';
235 self->qf_datw = self->qf_pfix_len + self->qf_currq.l;
236 self->qf_wscnt = 0;
237 rv = _qf_add_data(self, wc);
238 break;
241 vc->buf = buf;
242 vc->len = len;
243 NYD_LEAVE;
244 return rv;
247 static ssize_t
248 _qf_state_data(struct qf_vc *vc)
250 struct quoteflt *self;
251 ssize_t rv;
252 char const *buf;
253 size_t len, i;
254 wchar_t wc;
255 NYD_ENTER;
257 self = vc->self;
258 rv = 0;
260 for (buf = vc->buf, len = vc->len; len > 0;) {
261 /* xxx NULL BYTE! */
262 i = mbrtowc(&wc, buf, len, self->qf_mbps);
263 if (i == (size_t)-1) {
264 /* On hard error, don't modify mbstate_t and step one byte */
265 self->qf_mbps[0] = self->qf_mbps[1];
266 ++buf;
267 --len;
268 continue;
270 self->qf_mbps[1] = self->qf_mbps[0];
271 if (i == (size_t)-2) {
272 /* Redundant shift sequence, out of buffer */
273 len = 0;
274 break;
276 buf += i;
277 len -= i;
279 { ssize_t j = _qf_add_data(self, wc);
280 if (j < 0) {
281 rv = j;
282 break;
284 rv += j;
287 if (self->qf_state != _QF_DATA)
288 break;
291 vc->buf = buf;
292 vc->len = len;
293 NYD_LEAVE;
294 return rv;
296 #endif /* HAVE_QUOTE_FOLD */
298 FL struct quoteflt *
299 quoteflt_dummy(void) /* TODO LEGACY (until filters are plugged when needed) */
301 static struct quoteflt qf_i;
303 return &qf_i;
306 FL void
307 quoteflt_init(struct quoteflt *self, char const *prefix)
309 #ifdef HAVE_QUOTE_FOLD
310 char *xcp, *cp;
311 #endif
312 NYD_ENTER;
314 memset(self, 0, sizeof *self);
316 if ((self->qf_pfix = prefix) != NULL)
317 self->qf_pfix_len = (ui32_t)strlen(prefix);
319 /* Check whether the user wants the more fancy quoting algorithm */
320 /* TODO *quote-fold*: QUOTE_MAX may excess it! */
321 #ifdef HAVE_QUOTE_FOLD
322 if (self->qf_pfix_len > 0 && (cp = ok_vlook(quote_fold)) != NULL) {
323 ui32_t qmin, qmax = (ui32_t)strtol(cp, &xcp, 10);
324 /* These magic values ensure we don't bail :) */
325 if (qmax < self->qf_pfix_len + 6)
326 qmax = self->qf_pfix_len + 6;
327 --qmax; /* The newline escape */
328 if (cp == xcp || *xcp == '\0')
329 qmin = (qmax >> 1) + (qmax >> 2) + (qmax >> 5);
330 else {
331 qmin = (ui32_t)strtol(xcp + 1, NULL, 10);
332 if (qmin < qmax >> 1)
333 qmin = qmax >> 1;
334 else if (qmin > qmax - 2)
335 qmin = qmax - 2;
337 self->qf_qfold_min = qmin;
338 self->qf_qfold_max = qmax;
340 /* Add pad for takeover copies, backslash and newline */
341 self->qf_dat.s = salloc((qmax + 3) * mb_cur_max);
342 self->qf_currq.s = salloc((QUOTE_MAX + 1) * mb_cur_max);
344 #endif
345 NYD_LEAVE;
348 FL void
349 quoteflt_destroy(struct quoteflt *self) /* xxx inline */
351 NYD_ENTER;
352 UNUSED(self);
353 NYD_LEAVE;
356 FL void
357 quoteflt_reset(struct quoteflt *self, FILE *f) /* xxx inline */
359 NYD_ENTER;
360 self->qf_os = f;
361 #ifdef HAVE_QUOTE_FOLD
362 self->qf_state = _QF_CLEAN;
363 self->qf_dat.l =
364 self->qf_currq.l = 0;
365 memset(self->qf_mbps, 0, sizeof self->qf_mbps);
366 #endif
367 NYD_LEAVE;
370 FL ssize_t
371 quoteflt_push(struct quoteflt *self, char const *dat, size_t len)
373 /* (xxx Ideally the actual push() [and flush()] would be functions on their
374 * xxx own, via indirect vtbl call ..) */
375 ssize_t rv = 0;
376 NYD_ENTER;
378 self->qf_nl_last = (len > 0 && dat[len - 1] == '\n'); /* TODO HACK */
380 if (len == 0)
381 goto jleave;
383 /* Bypass? TODO Finally, this filter simply should not be used, then
384 * (TODO It supercedes prefix_write() or something) */
385 if (self->qf_pfix_len == 0) {
386 if (len != fwrite(dat, 1, len, self->qf_os))
387 goto jerr;
388 rv = len;
390 /* Normal: place *indentprefix* at every BOL */
391 else
392 #ifdef HAVE_QUOTE_FOLD
393 if (self->qf_qfold_max == 0)
394 #endif
396 void *vp;
397 size_t ll;
398 bool_t pxok = (self->qf_qfold_min != 0);
400 for (;;) {
401 if (!pxok) {
402 ll = self->qf_pfix_len;
403 if (ll != fwrite(self->qf_pfix, 1, ll, self->qf_os))
404 goto jerr;
405 rv += ll;
406 pxok = TRU1;
409 /* xxx Strictly speaking this is invalid, because only `/' and `.' are
410 * xxx mandated by POSIX.1-2008 as "invariant across all locales
411 * xxx supported"; though there is no charset known which uses this
412 * xxx control char as part of a multibyte character; note that S-nail
413 * XXX (and the Mail codebase as such) do not support EBCDIC */
414 if ((vp = memchr(dat, '\n', len)) == NULL)
415 ll = len;
416 else {
417 pxok = FAL0;
418 ll = PTR2SIZE((char*)vp - dat) + 1;
421 if (ll != fwrite(dat, sizeof *dat, ll, self->qf_os))
422 goto jerr;
423 rv += ll;
424 if ((len -= ll) == 0)
425 break;
426 dat += ll;
429 self->qf_qfold_min = pxok;
431 /* Overly complicated, though still only line-per-line: *quote-fold*.
432 * - If .qf_currq.l is 0, then we are in a clean state. Reset .qf_mbps;
433 * TODO note this means we assume that lines start with reset escape seq,
434 * TODO but i don't think this is any worse than what we currently do;
435 * TODO in 15.0, with the value carrier, we should carry conversion states
436 * TODO all along, only resetting on error (or at words for header =???=);
437 * TODO this still is weird for error handling, but we need to act more
438 * TODO stream-alike (though in practice i don't think cross-line states
439 * TODO can be found, because of compatibility reasons; however, being
440 * TODO a problem rather than a solution is not a good thing (tm))
441 * - Lookout for a newline */
442 #ifdef HAVE_QUOTE_FOLD
443 else {
444 struct qf_vc vc;
445 ssize_t i;
447 vc.self = self;
448 vc.buf = dat;
449 vc.len = len;
450 while (vc.len > 0) {
451 switch (self->qf_state) {
452 case _QF_CLEAN:
453 case _QF_PREFIX:
454 i = _qf_state_prefix(&vc);
455 break;
456 default: /* silence cc (`i' unused) */
457 case _QF_DATA:
458 i = _qf_state_data(&vc);
459 break;
461 if (i < 0)
462 goto jerr;
463 rv += i;
466 #endif /* HAVE_QUOTE_FOLD */
468 jleave:
469 NYD_LEAVE;
470 return rv;
471 jerr:
472 rv = -1;
473 goto jleave;
476 FL ssize_t
477 quoteflt_flush(struct quoteflt *self)
479 ssize_t rv = 0;
480 NYD_ENTER;
481 UNUSED(self);
483 #ifdef HAVE_QUOTE_FOLD
484 if (self->qf_dat.l > 0) {
485 rv = _qf_dump_prefix(self);
486 if (rv >= 0) {
487 size_t i = self->qf_dat.l;
488 if (i == fwrite(self->qf_dat.s, 1, i, self->qf_os))
489 rv += i;
490 else
491 rv = -1;
492 self->qf_dat.l = 0;
493 self->qf_brk_isws = FAL0;
494 self->qf_wscnt = self->qf_brkl = self->qf_brkw = 0;
495 self->qf_datw = self->qf_pfix_len + self->qf_currq.l;
498 #endif
499 NYD_LEAVE;
500 return rv;
504 * HTML tagsoup filter TODO rewrite wchar_t based (require HAVE_C90AMEND1)
505 * TODO . Numeric &#NO; entities should also be treated by struct hf_ent
506 * TODO . Yes, we COULD support CSS based quoting when we'd check type="quote"
507 * TODO (nonstandard) and watch out for style="gmail_quote" (or so, VERY
508 * TODO nonstandard) and tracking a stack of such elements (to be popped
509 * TODO once the closing element is seen). Then, after writing a newline,
510 * TODO place sizeof(stack) ">"s first. But aren't these HTML mails rude?
511 * TODO Interlocking and non-well-formed data will break us down
513 #ifdef HAVE_FILTER_HTML_TAGSOUP
515 enum hf_limits {
516 _HF_MINLEN = 10, /* Minimum line length (can't really be smaller) */
517 _HF_BRKSUB = 8 /* Start considering line break MAX - BRKSUB */
520 enum hf_flags {
521 _HF_UTF8 = 1<<0, /* Data is in UTF-8 */
522 _HF_ERROR = 1<<1, /* A hard error occurred, bail as soon as possible */
523 _HF_NOPUT = 1<<2, /* (In a tag,) Don't generate output */
524 _HF_IGN = 1<<3, /* Ignore mode on */
525 _HF_ANY = 1<<4, /* Yet seen just any output */
526 _HF_PRE = 1<<5, /* In <pre>formatted mode */
527 _HF_ENT = 1<<6, /* Currently parsing an entity */
528 _HF_BLANK = 1<<7, /* Whitespace last */
529 _HF_HREF = 1<<8, /* External <a href=> was the last href seen */
531 _HF_NL_1 = 1<<9, /* One \n seen */
532 _HF_NL_2 = 2<<9, /* We have produced an all empty line */
533 _HF_NL_MASK = _HF_NL_1 | _HF_NL_2
536 enum hf_special_actions {
537 _HFSA_NEEDSEP = -1, /* Need an empty line (paragraph separator) */
538 _HFSA_NEEDNL = -2, /* Need a new line start (table row) */
539 _HFSA_IGN = -3, /* Things like <style>..</style>, <script>.. */
540 _HFSA_PRE = -4, /* <pre>.. */
541 _HFSA_PRE_END = -5,
542 _HFSA_IMG = -6, /* <img> */
543 _HFSA_HREF = -7, /* <a>.. */
544 _HFSA_HREF_END = -8
547 enum hf_entity_flags {
548 _HFE_HAVE_UNI = 1<<6, /* Have a Unicode replacement character */
549 _HFE_HAVE_CSTR = 1<<7, /* Have a string replacement */
550 /* We store the length of the entity name in the flags, too */
551 _HFE_LENGTH_MASK = (1<<6) - 1
554 struct htmlflt_href {
555 struct htmlflt_href *hfh_next;
556 ui32_t hfh_no; /* Running sequence */
557 ui32_t hfh_len; /* of .hfh_dat */
558 char hfh_dat[VFIELD_SIZE(0)];
561 struct htmlflt_tag {
562 si32_t hft_act; /* char or hf_special_actions */
563 /* Not NUL: character to inject, with high bit set: place a space
564 * afterwards. Note: only recognized with _HFSA_NEEDSEP or _HFSA_NEEDNL */
565 char hft_injc;
566 ui8_t hft_len; /* Useful bytes in (NUL terminated) .hft_tag */
567 char const hft_tag[10]; /* Tag less < and > surroundings (TR, /TR, ..) */
569 CTA(SIZEOF_FIELD(struct htmlflt_tag, hft_tag) < LINESIZE); /* .hf_ign_tag */
571 struct hf_ent {
572 ui8_t hfe_flags; /* enum hf_entity_flags plus length of .hfe_ent */
573 char hfe_c; /* Plain replacement character */
574 ui16_t hfe_uni; /* Unicode codepoint if _HFE_HAVE_UNI */
575 char hfe_cstr[5]; /* _HFE_HAVE_CSTR (e.g., &hellip; -> ...) */
576 char const hfe_ent[7]; /* Entity less & and ; surroundings */
579 /* Tag list; not binary searched :(, so try to take care a bit */
580 static struct htmlflt_tag const _hf_tags[] = {
581 # undef _X
582 # undef _XC
583 # define _X(S,A) {A, '\0', sizeof(S) -1, S "\0"}
584 # define _XC(S,C,A) {A, C, sizeof(S) -1, S "\0"}
586 _X("P", _HFSA_NEEDSEP), _X("/P", _HFSA_NEEDNL),
587 _X("DIV", _HFSA_NEEDSEP), _X("/DIV", _HFSA_NEEDNL),
588 _X("TR", _HFSA_NEEDNL),
589 _X("/TH", '\t'),
590 _X("/TD", '\t'),
591 /* Let it stand out; also since we don't support implicit paragraphs after
592 * block elements, plain running text after a list (seen in Unicode
593 * announcement via Firefox) */
594 _X("UL", _HFSA_NEEDSEP), _X("/UL", _HFSA_NEEDSEP),
595 _XC("LI", (char)0x80 | '*', _HFSA_NEEDSEP),
596 _X("DL", _HFSA_NEEDSEP),
597 _X("DT", _HFSA_NEEDNL),
599 _X("A", _HFSA_HREF), _X("/A", _HFSA_HREF_END),
600 _X("IMG", _HFSA_IMG),
601 _X("BR", '\n'),
602 _X("PRE", _HFSA_PRE), _X("/PRE", _HFSA_PRE_END),
603 _X("TITLE", _HFSA_NEEDSEP), /*_X("/TITLE", '\n'),*/
604 _X("H1", _HFSA_NEEDSEP), /*_X("/H1", '\n'),*/
605 _X("H2", _HFSA_NEEDSEP), /*_X("/H2", '\n'),*/
606 _X("H3", _HFSA_NEEDSEP), /*_X("/H3", '\n'),*/
607 _X("H4", _HFSA_NEEDSEP), /*_X("/H4", '\n'),*/
608 _X("H5", _HFSA_NEEDSEP), /*_X("/H5", '\n'),*/
609 _X("H6", _HFSA_NEEDSEP), /*_X("/H6", '\n'),*/
611 _X("STYLE", _HFSA_IGN),
612 _X("SCRIPT", _HFSA_IGN),
614 # undef _X
617 /* Entity list; not binary searched.. */
618 static struct hf_ent const _hf_ents[] = {
619 # undef _X
620 # undef _XU
621 # undef _XS
622 # undef _XUS
623 # define _X(E,C) {(sizeof(E) -1), C, 0x0u, "", E "\0"}
624 # define _XU(E,C,U) {(sizeof(E) -1) | _HFE_HAVE_UNI, C, U, "", E "\0"}
625 # define _XS(E,S) {(sizeof(E) -1) | _HFE_HAVE_CSTR, '\0', 0x0u,S "\0",E "\0"}
626 # define _XSU(E,S,U) \
627 {(sizeof(E) -1) | _HFE_HAVE_UNI | _HFE_HAVE_CSTR, '\0', U, S "\0", E "\0"}
629 _X("quot", '"'),
630 _X("amp", '&'),
631 _X("lt", '<'), _X("gt", '>'),
633 _XU("nbsp", ' ', 0x0020 /* Note: not 0x00A0 seems to be better for us */),
634 _XU("middot", '.', 0x00B7),
635 _XSU("hellip", "...", 0x2026),
636 _XSU("mdash", "---", 0x2014), _XSU("ndash", "--", 0x2013),
637 _XSU("laquo", "<<", 0x00AB), _XSU("raquo", ">>", 0x00BB),
638 _XSU("lsaquo", "<", 0x2039), _XSU("rsaquo", ">", 0x203A),
639 _XSU("lsquo", "'", 0x2018), _XSU("rsquo", "'", 0x2019),
640 _XSU("ldquo", "\"", 0x201C), _XSU("rdquo", "\"", 0x201D),
641 _XSU("uarr", "^|", 0x2191), _XSU("darr", "|v", 0x2193),
643 _XSU("cent", "CENT", 0x00A2),
644 _XSU("copy", "(C)", 0x00A9),
645 _XSU("euro", "EUR", 0x20AC),
646 _XSU("infin", "INFY", 0x221E),
647 _XSU("pound", "GBP", 0x00A3),
648 _XSU("reg", "(R)", 0x00AE),
649 _XSU("sect", "S:", 0x00A7),
650 _XSU("yen", "JPY", 0x00A5),
652 /* German umlauts */
653 _XSU("Auml", "Ae", 0x00C4), _XSU("auml", "ae", 0x00E4),
654 _XSU("Ouml", "Oe", 0x00D6), _XSU("ouml", "oe", 0x00F6),
655 _XSU("Uuml", "Ue", 0x00DC), _XSU("uuml", "ue", 0x00FC),
656 _XSU("szlig", "ss", 0x00DF)
658 # undef _X
659 # undef _XU
660 # undef _XS
661 # undef _XSU
664 /* Real output */
665 static struct htmlflt * _hf_dump_hrefs(struct htmlflt *self);
666 static struct htmlflt * _hf_dump(struct htmlflt *self);
667 static struct htmlflt * _hf_store(struct htmlflt *self, char c);
668 # ifdef HAVE_NATCH_CHAR
669 static struct htmlflt * __hf_sync_mbstuff(struct htmlflt *self);
670 # endif
672 /* Virtual output */
673 static struct htmlflt * _hf_nl(struct htmlflt *self);
674 static struct htmlflt * _hf_nl_force(struct htmlflt *self);
675 static struct htmlflt * _hf_putc(struct htmlflt *self, char c);
676 static struct htmlflt * _hf_putc_premode(struct htmlflt *self, char c);
677 static struct htmlflt * _hf_puts(struct htmlflt *self, char const *cp);
678 static struct htmlflt * _hf_putbuf(struct htmlflt *self,
679 char const *cp, size_t len);
681 /* Try to locate a param'eter in >hf_bdat, store it (non-terminated!) or NULL */
682 static struct htmlflt * _hf_param(struct htmlflt *self, struct str *store,
683 char const *param);
685 /* Expand all entities in the given parameter */
686 static struct htmlflt * _hf_expand_all_ents(struct htmlflt *self,
687 struct str const *param);
689 /* Completely parsed over a tag / an entity, interpret that */
690 static struct htmlflt * _hf_check_tag(struct htmlflt *self, char const *s);
691 static struct htmlflt * _hf_check_ent(struct htmlflt *self, char const *s,
692 size_t l);
694 /* Input handler */
695 static ssize_t _hf_add_data(struct htmlflt *self,
696 char const *dat, size_t len);
698 static struct htmlflt *
699 _hf_dump_hrefs(struct htmlflt *self)
701 struct htmlflt_href *hhp;
702 NYD2_ENTER;
704 if (!(self->hf_flags & _HF_NL_2) && putc('\n', self->hf_os) == EOF) {
705 self->hf_flags |= _HF_ERROR;
706 goto jleave;
709 /* Reverse the list */
710 for (hhp = self->hf_hrefs, self->hf_hrefs = NULL; hhp != NULL;) {
711 struct htmlflt_href *tmp = hhp->hfh_next;
712 hhp->hfh_next = self->hf_hrefs;
713 self->hf_hrefs = hhp;
714 hhp = tmp;
717 /* Then dump it */
718 while ((hhp = self->hf_hrefs) != NULL) {
719 self->hf_hrefs = hhp->hfh_next;
721 if (!(self->hf_flags & _HF_ERROR)) {
722 int w = fprintf(self->hf_os, " [%u] %.*s\n",
723 hhp->hfh_no, (int)hhp->hfh_len, hhp->hfh_dat);
724 if (w < 0)
725 self->hf_flags |= _HF_ERROR;
727 free(hhp);
730 self->hf_flags |= (putc('\n', self->hf_os) == EOF)
731 ? _HF_ERROR : _HF_NL_1 | _HF_NL_2;
732 self->hf_href_dist = (ui32_t)realscreenheight >> 1;
733 jleave:
734 NYD2_LEAVE;
735 return self;
738 static struct htmlflt *
739 _hf_dump(struct htmlflt *self)
741 ui32_t f, l;
742 char c, *cp;
743 NYD2_ENTER;
745 f = self->hf_flags & ~_HF_BLANK;
746 l = self->hf_len;
747 cp = self->hf_line;
748 self->hf_mbwidth = self->hf_mboff = self->hf_last_ws = self->hf_len = 0;
750 for (c = '\0'; l > 0; --l) {
751 c = *cp++;
752 jput:
753 if (putc(c, self->hf_os) == EOF) {
754 self->hf_flags = (f |= _HF_ERROR);
755 goto jleave;
759 if (c != '\n') {
760 f |= (f & _HF_NL_1) ? _HF_NL_2 : _HF_NL_1;
761 l = 1;
762 c = '\n';
763 goto jput;
765 self->hf_flags = f;
767 /* Check whether there are HREFs to dump; there is so much messy tagsoup out
768 * there that it seems best not to simply dump HREFs in each _dump(), but
769 * only with some gap, let's say half the real screen height */
770 if (--self->hf_href_dist < 0 && (f & _HF_NL_2) && self->hf_hrefs != NULL)
771 self = _hf_dump_hrefs(self);
772 jleave:
773 NYD2_LEAVE;
774 return self;
777 static struct htmlflt *
778 _hf_store(struct htmlflt *self, char c)
780 ui32_t f, l, i;
781 NYD2_ENTER;
783 assert(c != '\n');
785 f = self->hf_flags;
786 l = self->hf_len;
787 self->hf_line[l] = (c == '\t' ? ' ' : c);
788 self->hf_len = ++l;
789 if (blankspacechar(c)) {
790 if (c == '\t') {
791 i = 8 - ((l - 1) & 7); /* xxx magic tab width of 8 */
792 if (i > 0) {
794 self = _hf_store(self, ' ');
795 while (--i > 0);
796 goto jleave;
799 self->hf_last_ws = l;
800 } else if (/*c == '.' ||*/ c == ',' || c == ';' || c == '-')
801 self->hf_last_ws = l;
803 i = l;
804 # ifdef HAVE_NATCH_CHAR /* XXX This code is really ridiculous! */
805 if (mb_cur_max > 1) { /* XXX should mbrtowc() and THEN store, at least.. */
806 wchar_t wc;
807 int w, x = mbtowc(&wc, self->hf_line + self->hf_mboff, l - self->hf_mboff);
809 if (x > 0) {
810 if ((w = wcwidth(wc)) == -1 ||
811 /* Actively filter out L-TO-R and R-TO-R marks TODO ctext */
812 (wc == 0x200E || wc == 0x200F ||
813 (wc >= 0x202A && wc <= 0x202E)) ||
814 /* And some zero-width messes */
815 wc == 0x00AD || (wc >= 0x200B && wc <= 0x200D) ||
816 /* Oh about the ISO C wide character interfaces, baby! */
817 (wc == 0xFEFF)){
818 self->hf_len -= x;
819 goto jleave;
820 } else if (iswspace(wc))
821 self->hf_last_ws = l;
822 self->hf_mboff += x;
823 i = (self->hf_mbwidth += w);
824 } else {
825 if (x < 0) {
826 mbtowc(&wc, NULL, mb_cur_max);
827 if (UICMP(32, l - self->hf_mboff, >=, mb_cur_max)) { /* XXX */
828 ++self->hf_mboff;
829 ++self->hf_mbwidth;
832 i = self->hf_mbwidth;
835 # endif
837 /* Do we need to break the line? */
838 if (i >= self->hf_lmax - _HF_BRKSUB) {
839 ui32_t lim = self->hf_lmax >> 1;
841 /* Let's hope we saw a sane place to break this line! */
842 if (self->hf_last_ws >= lim) {
843 jput:
844 i = self->hf_len = self->hf_last_ws;
845 self = _hf_dump(self);
846 if ((self->hf_len = (l -= i)) > 0) {
847 self->hf_flags &= ~_HF_NL_MASK;
848 memmove(self->hf_line, self->hf_line + i, l);
849 # ifdef HAVE_NATCH_CHAR
850 __hf_sync_mbstuff(self);
851 # endif
853 goto jleave;
856 /* Any 7-bit characters? */
857 for (i = l; i-- >= lim;)
858 if (asciichar((c = self->hf_line[i]))) {
859 self->hf_last_ws = ++i;
860 goto jput;
861 } else if ((f & _HF_UTF8) && ((ui8_t)c & 0xC0) != 0x80) {
862 self->hf_last_ws = i;
863 goto jput;
866 /* Hard break necessary! xxx really badly done */
867 if (l >= self->hf_lmax - 1)
868 self = _hf_dump(self);
870 jleave:
871 NYD2_LEAVE;
872 return self;
875 # ifdef HAVE_NATCH_CHAR
876 static struct htmlflt *
877 __hf_sync_mbstuff(struct htmlflt *self)
879 wchar_t wc;
880 char const *b;
881 ui32_t o, w, l;
882 NYD2_ENTER;
884 b = self->hf_line;
885 o = w = 0;
886 l = self->hf_len;
887 goto jumpin;
889 while (l > 0) {
890 int x = mbtowc(&wc, b, l);
892 if (x == 0)
893 break;
895 if (x > 0) {
896 b += x;
897 l -= x;
898 o += x;
899 if ((x = wcwidth(wc)) == -1)
900 x = 1;
901 w += x;
902 continue;
905 /* Bad, skip over a single character.. XXX very bad indeed */
906 ++b;
907 ++o;
908 ++w;
909 --l;
910 jumpin:
911 mbtowc(&wc, NULL, mb_cur_max);
914 self->hf_mboff = o;
915 self->hf_mbwidth = w;
917 NYD2_LEAVE;
918 return self;
920 # endif /* HAVE_NATCH_CHAR */
922 static struct htmlflt *
923 _hf_nl(struct htmlflt *self)
925 ui32_t f;
926 NYD2_ENTER;
928 if (!((f = self->hf_flags) & _HF_ERROR)) {
929 if (f & _HF_ANY) {
930 if ((f & _HF_NL_MASK) != _HF_NL_MASK)
931 self = _hf_dump(self);
932 } else
933 self->hf_flags = (f |= _HF_NL_MASK);
935 NYD2_LEAVE;
936 return self;
939 static struct htmlflt *
940 _hf_nl_force(struct htmlflt *self)
942 NYD2_ENTER;
943 if (!(self->hf_flags & _HF_ERROR))
944 self = _hf_dump(self);
945 NYD2_LEAVE;
946 return self;
949 static struct htmlflt *
950 _hf_putc(struct htmlflt *self, char c)
952 ui32_t f;
953 NYD2_ENTER;
955 if ((f = self->hf_flags) & _HF_ERROR)
956 goto jleave;
958 if (c == '\n') {
959 self = _hf_nl(self);
960 goto jleave;
961 } else if (c == ' ' || c == '\t') {
962 if ((f & _HF_BLANK) || self->hf_len == 0)
963 goto jleave;
964 f |= _HF_BLANK;
965 } else
966 f &= ~_HF_BLANK;
967 f &= ~_HF_NL_MASK;
968 self->hf_flags = (f |= _HF_ANY);
969 self = _hf_store(self, c);
970 jleave:
971 NYD2_LEAVE;
972 return self;
975 static struct htmlflt *
976 _hf_putc_premode(struct htmlflt *self, char c)
978 ui32_t f;
979 NYD2_ENTER;
981 if ((f = self->hf_flags) & _HF_ERROR) {
983 } else if (c == '\n')
984 self = _hf_nl_force(self);
985 else {
986 f &= ~_HF_NL_MASK;
987 self->hf_flags = (f |= _HF_ANY);
988 self = _hf_store(self, c);
990 NYD2_LEAVE;
991 return self;
994 static struct htmlflt *
995 _hf_puts(struct htmlflt *self, char const *cp)
997 char c;
998 NYD2_ENTER;
1000 while ((c = *cp++) != '\0')
1001 self = _hf_putc(self, c);
1002 NYD2_LEAVE;
1003 return self;
1006 static struct htmlflt *
1007 _hf_putbuf(struct htmlflt *self, char const *cp, size_t len)
1009 NYD2_ENTER;
1011 while (len-- > 0)
1012 self = _hf_putc(self, *cp++);
1013 NYD2_LEAVE;
1014 return self;
1017 static struct htmlflt *
1018 _hf_param(struct htmlflt *self, struct str *store, char const *param)
1020 char const *cp;
1021 char c, x, quote;
1022 size_t i;
1023 bool_t hot;
1024 NYD2_ENTER;
1026 store->s = NULL;
1027 store->l = 0;
1028 cp = self->hf_bdat;
1030 /* Skip over any non-WS first; be aware of soup, if it slipped through */
1031 for(;;){
1032 if((c = *cp++) == '\0' || c == '>')
1033 goto jleave;
1034 if(whitechar(c))
1035 break;
1038 /* Search for the parameter, take care of other quoting along the way */
1039 x = *param++;
1040 x = upperconv(x);
1041 quote = '\0';
1042 i = strlen(param);
1044 for(hot = TRU1;;){
1045 if((c = *cp++) == '\0' || c == '>')
1046 goto jleave;
1047 if(whitechar(c)){
1048 hot = TRU1;
1049 continue;
1052 /* Could it be a parameter? */
1053 if(hot){
1054 hot = FAL0;
1056 /* Is it the desired one? */
1057 if((c = upperconv(c)) == x && !ascncasecmp(param, cp, i)){
1058 char const *cp2 = cp + i;
1060 if((quote = *cp2++) != '='){
1061 if(quote == '\0' || quote == '>')
1062 goto jleave;
1063 while(whitechar(quote))
1064 quote = *cp2++;
1066 if(quote == '='){
1067 cp = cp2;
1068 break;
1070 continue; /* XXX Optimize: i bytes or even cp2 can't be it! */
1074 /* Not the desired one; but a parameter? */
1075 if(c != '=')
1076 continue;
1077 /* If so, properly skip over the value */
1078 if(c == '"' || c == '\''){
1079 /* TODO oops i have forgotten whether backslash quoting is allowed in
1080 * TODO quoted HTML parameter values? not supporting that for now.. */
1081 for(quote = c; (c = *cp) != '\0' && c != quote; ++cp)
1083 }else
1084 while((c = *cp) != '\0' && !whitechar(c) && c != '>')
1085 ++cp;
1086 if(c == '\0')
1087 goto jleave;
1090 /* Skip further whitespace */
1091 for(;;){
1092 if((c = *cp++) == '\0' || c == '>')
1093 goto jleave;
1094 if(!whitechar(c))
1095 break;
1098 if(c == '"' || c == '\''){
1099 /* TODO oops i have forgotten whether backslash quoting is allowed in
1100 * TODO quoted HTML parameter values? not supporting that for now.. */
1101 store->s = UNCONST(cp);
1102 for(quote = c; (c = *cp) != '\0' && c != quote; ++cp)
1104 /* XXX ... and we simply ignore a missing trailing " :> */
1105 }else{
1106 store->s = UNCONST(cp - 1);
1107 if(!whitechar(c))
1108 while((c = *cp) != '\0' && !whitechar(c) && c != '>')
1109 ++cp;
1111 i = PTR2SIZE(cp - store->s);
1113 /* Terrible tagsoup out there, e.g., groups.google.com produces href=""
1114 * parameter values prefixed and suffixed by newlines! Therefore trim the
1115 * value content TODO join into the parse step above! */
1116 for (cp = store->s; i > 0 && spacechar(*cp); ++cp, --i)
1118 store->s = UNCONST(cp);
1119 for (cp += i - 1; i > 0 && spacechar(*cp); --cp, --i)
1121 if ((store->l = i) == 0)
1122 store->s = NULL;
1123 jleave:
1124 NYD2_LEAVE;
1125 return self;
1128 static struct htmlflt *
1129 _hf_expand_all_ents(struct htmlflt *self, struct str const *param)
1131 char const *cp, *maxcp, *ep;
1132 char c;
1133 size_t i;
1134 NYD2_ENTER;
1136 for (cp = param->s, maxcp = cp + param->l; cp < maxcp;)
1137 if ((c = *cp++) != '&')
1138 jputc:
1139 self = _hf_putc(self, c);
1140 else {
1141 for (ep = cp--;;) {
1142 if (ep == maxcp || (c = *ep++) == '\0') {
1143 for (; cp < ep; ++cp)
1144 self = _hf_putc(self, *cp);
1145 goto jleave;
1146 } else if (c == ';') {
1147 if ((i = PTR2SIZE(ep - cp)) > 1) {
1148 self = _hf_check_ent(self, cp, i);
1149 break;
1150 } else {
1151 c = *cp++;
1152 goto jputc;
1156 cp = ep;
1158 jleave:
1159 NYD2_LEAVE;
1160 return self;
1163 static struct htmlflt *
1164 _hf_check_tag(struct htmlflt *self, char const *s)
1166 char nobuf[32], c;
1167 struct str param;
1168 size_t i;
1169 struct htmlflt_tag const *hftp;
1170 ui32_t f;
1171 NYD2_ENTER;
1173 /* Extra check only */
1174 assert(s != NULL);
1175 if (*s != '<') {
1176 DBG( n_alert("HTML tagsoup filter _hf_check_tag() called on soup!"); )
1177 jput_as_is:
1178 self = _hf_puts(self, self->hf_bdat);
1179 goto jleave;
1182 for (++s, i = 0; (c = s[i]) != '\0' && c != '>' && !whitechar(c); ++i)
1183 /* Special massage for things like <br/>: after the slash only whitespace
1184 * may separate us from the closing right angle! */
1185 if (c == '/') {
1186 size_t j = i + 1;
1188 while ((c = s[j]) != '\0' && c != '>' && whitechar(c))
1189 ++j;
1190 if (c == '>')
1191 break;
1194 for (hftp = _hf_tags;;) {
1195 if (i == hftp->hft_len && !ascncasecmp(s, hftp->hft_tag, i)) {
1196 c = s[hftp->hft_len];
1197 if (c == '>' || c == '/' || whitechar(c))
1198 break;
1200 if (PTRCMP(++hftp, >=, _hf_tags + NELEM(_hf_tags)))
1201 goto jnotknown;
1204 f = self->hf_flags;
1205 switch (hftp->hft_act) {
1206 case _HFSA_PRE_END:
1207 f &= ~_HF_PRE;
1208 if (0) {
1209 /* FALLTHRU */
1210 case _HFSA_PRE:
1211 f |= _HF_PRE;
1213 self->hf_flags = f;
1214 /* FALLTHRU */
1216 case _HFSA_NEEDSEP:
1217 if (!(self->hf_flags & _HF_NL_2))
1218 self = _hf_nl(self);
1219 /* FALLTHRU */
1220 case _HFSA_NEEDNL:
1221 if (!(f & _HF_NL_1))
1222 self = _hf_nl(self);
1223 if (hftp->hft_injc != '\0') {
1224 self = _hf_putc(self, hftp->hft_injc & 0x7F);
1225 if ((uc_i)hftp->hft_injc & 0x80)
1226 self = _hf_putc(self, ' ');
1228 break;
1230 case _HFSA_IGN:
1231 self->hf_ign_tag = hftp;
1232 self->hf_flags = (f |= _HF_IGN | _HF_NOPUT);
1233 break;
1235 case _HFSA_IMG:
1236 self = _hf_param(self, &param, "alt");
1237 self = _hf_putc(self, '[');
1238 if (param.s == NULL) {
1239 param.s = UNCONST("IMG");
1240 param.l = 3;
1241 goto jimg_put;
1242 } /* else */ if (memchr(param.s, '&', param.l) != NULL)
1243 self = _hf_expand_all_ents(self, &param);
1244 else
1245 jimg_put:
1246 self = _hf_putbuf(self, param.s, param.l);
1247 self = _hf_putc(self, ']');
1248 break;
1250 case _HFSA_HREF:
1251 self = _hf_param(self, &param, "href");
1252 /* Ignore non-external links */
1253 if (param.s != NULL && *param.s != '#') {
1254 struct htmlflt_href *hhp = smalloc(sizeof(*hhp) -
1255 VFIELD_SIZEOF(struct htmlflt_href, hfh_dat) + param.l +1);
1257 hhp->hfh_next = self->hf_hrefs;
1258 hhp->hfh_no = ++self->hf_href_no;
1259 hhp->hfh_len = (ui32_t)param.l;
1260 memcpy(hhp->hfh_dat, param.s, param.l);
1262 snprintf(nobuf, sizeof nobuf, "[%u]", hhp->hfh_no);
1263 self->hf_flags = (f |= _HF_HREF);
1264 self->hf_hrefs = hhp;
1265 self = _hf_puts(self, nobuf);
1266 } else
1267 self->hf_flags = (f &= ~_HF_HREF);
1268 break;
1269 case _HFSA_HREF_END:
1270 if (f & _HF_HREF) {
1271 snprintf(nobuf, sizeof nobuf, "[/%u]", self->hf_href_no);
1272 self = _hf_puts(self, nobuf);
1274 break;
1276 default:
1277 c = (char)(hftp->hft_act & 0xFF);
1278 self = _hf_putc(self, c);
1279 break;
1280 case '\0':
1281 break;
1283 jleave:
1284 NYD2_LEAVE;
1285 return self;
1287 /* The problem is that even invalid tagsoup is widely used, without real
1288 * searching i have seen e-mail address in <N@H.D> notation, and more.
1289 * To protect us a bit look around and possibly write the content as such */
1290 jnotknown:
1291 switch (*s) {
1292 case '!':
1293 case '?':
1294 /* Ignore <!DOCTYPE, <!-- comments, <? PIs.. */
1295 goto jleave;
1296 case '>':
1297 /* Print out an empty tag as such */
1298 if (s[1] == '\0') {
1299 --s;
1300 goto jput_as_is;
1302 break;
1303 case '/':
1304 ++s;
1305 break;
1306 default:
1307 break;
1310 /* Also skip over : in order to suppress v:roundrect, w:anchorlock.. */
1311 while ((c = *s++) != '\0' && c != '>' && !whitechar(c) && c != ':')
1312 if (!asciichar(c) || punctchar(c)) {
1313 self = _hf_puts(self, self->hf_bdat);
1314 break;
1316 goto jleave;
1319 static struct htmlflt *
1320 _hf_check_ent(struct htmlflt *self, char const *s, size_t l)
1322 char nobuf[32];
1323 char const *s_save;
1324 size_t l_save;
1325 struct hf_ent const *hfep;
1326 long i;
1327 NYD2_ENTER;
1329 s_save = s;
1330 l_save = l;
1331 assert(*s == '&');
1332 assert(l > 0);
1333 /* False entities seen in the wild assert(s[l - 1] == ';'); */
1334 ++s;
1335 l -= 2;
1337 /* Numeric entity, or try named search */
1338 if (*s == '#') {
1339 i = (*++s == 'x' ? 16 : 10);
1341 if ((i != 16 || (++s, --l) > 0) && l < sizeof(nobuf)) {
1342 memcpy(nobuf, s, l);
1343 nobuf[l] = '\0';
1344 i = strtol(nobuf, NULL, i);
1345 if (i <= 0x7F)
1346 self = _hf_putc(self, (char)i);
1347 else if (self->hf_flags & _HF_UTF8) {
1348 jputuni:
1349 l = n_utf32_to_utf8((ui32_t)i, nobuf);
1350 self = _hf_putbuf(self, nobuf, l);
1351 } else
1352 goto jeent;
1353 } else
1354 goto jeent;
1355 } else {
1356 ui32_t f = self->hf_flags, hf;
1358 for (hfep = _hf_ents; PTRCMP(hfep, <, _hf_ents + NELEM(_hf_ents)); ++hfep)
1359 if (l == ((hf = hfep->hfe_flags) & _HFE_LENGTH_MASK) &&
1360 !strncmp(s, hfep->hfe_ent, l)) {
1361 if ((hf & _HFE_HAVE_UNI) && (f & _HF_UTF8)) {
1362 i = hfep->hfe_uni;
1363 goto jputuni;
1364 } else if (hf & _HFE_HAVE_CSTR)
1365 self = _hf_puts(self, hfep->hfe_cstr);
1366 else
1367 self = _hf_putc(self, hfep->hfe_c);
1368 goto jleave;
1370 jeent:
1371 self = _hf_putbuf(self, s_save, l_save);
1373 jleave:
1374 NYD2_LEAVE;
1375 return self;
1378 static ssize_t
1379 _hf_add_data(struct htmlflt *self, char const *dat, size_t len)
1381 char c, *cp, *cp_max;
1382 bool_t hot;
1383 ssize_t rv = 0;
1384 NYD_ENTER;
1386 /* Final put request? */
1387 if (dat == NULL) {
1388 if (self->hf_len > 0 || self->hf_hrefs != NULL) {
1389 self = _hf_dump(self);
1390 if (self->hf_hrefs != NULL)
1391 self = _hf_dump_hrefs(self);
1392 rv = 1;
1394 goto jleave;
1397 /* Always ensure some initial buffer */
1398 if ((cp = self->hf_curr) != NULL)
1399 cp_max = self->hf_bmax;
1400 else {
1401 cp = self->hf_curr = self->hf_bdat = smalloc(LINESIZE);
1402 cp_max = self->hf_bmax = cp + LINESIZE -1; /* (Always room for NUL!) */
1404 hot = (cp != self->hf_bdat);
1406 for (rv = (ssize_t)len; len > 0; --len) {
1407 ui32_t f = self->hf_flags;
1409 if (f & _HF_ERROR)
1410 break;
1411 c = *dat++;
1413 /* Soup is really weird, and scripts may contain almost anything (and
1414 * newer CSS standards are also cryptic): therefore prefix the _HF_IGN
1415 * test and walk until we see the required end tag */
1416 /* TODO For real safety _HF_IGN soup condome would also need to know
1417 * TODO about quoted strings so that 'var i = "</script>";' couldn't
1418 * TODO fool it! We really want this mode also for _HF_NOPUT to be
1419 * TODO able to *gracefully* detect the tag-closing '>', but then if
1420 * TODO that is a single mechanism we should have made it! */
1421 if (f & _HF_IGN) {
1422 struct htmlflt_tag const *hftp = self->hf_ign_tag;
1423 size_t i;
1425 if (c == '<') {
1426 hot = TRU1;
1427 jcp_reset:
1428 cp = self->hf_bdat;
1429 } else if (c == '>') {
1430 if (hot) {
1431 if ((i = PTR2SIZE(cp - self->hf_bdat)) > 1 &&
1432 --i == hftp->hft_len &&
1433 !ascncasecmp(self->hf_bdat + 1, hftp->hft_tag, i))
1434 self->hf_flags = (f &= ~(_HF_IGN | _HF_NOPUT));
1435 hot = FAL0;
1436 goto jcp_reset;
1438 } else if (hot) {
1439 *cp++ = c;
1440 i = PTR2SIZE(cp - self->hf_bdat);
1441 if ((i == 1 && c != '/') || --i > hftp->hft_len) {
1442 hot = FAL0;
1443 goto jcp_reset;
1446 } else switch (c) {
1447 case '<':
1448 /* People are using & without &amp;ing it, ditto <; be aware */
1449 if (f & (_HF_NOPUT | _HF_ENT)) {
1450 f &= ~_HF_ENT;
1451 /* Special case "<!--" buffer content to deal with really weird
1452 * things that can be done with "<!--[if gte mso 9]>" syntax */
1453 if (PTR2SIZE(cp - self->hf_bdat) != 4 ||
1454 memcmp(self->hf_bdat, "<!--", 4)) {
1455 self->hf_flags = f;
1456 *cp = '\0';
1457 self = _hf_puts(self, self->hf_bdat);
1458 f = self->hf_flags;
1461 cp = self->hf_bdat;
1462 *cp++ = c;
1463 self->hf_flags = (f |= _HF_NOPUT);
1464 break;
1465 case '>':
1466 /* Weird tagsoup around, do we actually parse a tag? */
1467 if (!(f & _HF_NOPUT))
1468 goto jdo_c;
1469 cp[0] = c;
1470 cp[1] = '\0';
1471 f &= ~(_HF_NOPUT | _HF_ENT);
1472 self->hf_flags = f;
1473 self = _hf_check_tag(self, self->hf_bdat);
1474 *(cp = self->hf_bdat) = '\0'; /* xxx extra safety */
1475 /* Quick hack to get rid of redundant newline after <pre> XXX */
1476 if (!(f & _HF_PRE) && (self->hf_flags & _HF_PRE) &&
1477 len > 1 && *dat == '\n')
1478 ++dat, --len;
1479 break;
1481 case '\r': /* TODO CR should be stripped in lower level!! (Only B64!?!) */
1482 break;
1483 case '\n':
1484 /* End of line is not considered unless we are in PRE section.
1485 * However, in _HF_NOPUT mode we must be aware of tagsoup which uses
1486 * newlines for separating parameters */
1487 if (f & _HF_NOPUT)
1488 goto jdo_c;
1489 self = (f & _HF_PRE) ? _hf_nl_force(self) : _hf_putc(self, ' ');
1490 break;
1492 case '\t':
1493 if (!(f & _HF_PRE))
1494 c = ' ';
1495 /* FALLTHRU */
1496 default:
1497 jdo_c:
1498 /* If not currently parsing a tag and bypassing normal output.. */
1499 if (!(f & _HF_NOPUT)) {
1500 if (cntrlchar(c))
1501 break;
1502 if (c == '&') {
1503 cp = self->hf_bdat;
1504 *cp++ = c;
1505 self->hf_flags = (f |= _HF_NOPUT | _HF_ENT);
1506 } else if (f & _HF_PRE) {
1507 self = _hf_putc_premode(self, c);
1508 self->hf_flags &= ~_HF_BLANK;
1509 } else
1510 self = _hf_putc(self, c);
1511 } else if ((f & _HF_ENT) && c == ';') {
1512 cp[0] = c;
1513 cp[1] = '\0';
1514 f &= ~(_HF_NOPUT | _HF_ENT);
1515 self->hf_flags = f;
1516 self = _hf_check_ent(self, self->hf_bdat,
1517 PTR2SIZE(cp + 1 - self->hf_bdat));
1518 } else {
1519 /* We may need to grow the buffer */
1520 if (PTRCMP(cp + 42/2, >=, cp_max)) {
1521 size_t i = PTR2SIZE(cp - self->hf_bdat),
1522 m = PTR2SIZE(self->hf_bmax - self->hf_bdat) + LINESIZE;
1524 cp = self->hf_bdat = srealloc(self->hf_bdat, m);
1525 self->hf_bmax = cp + m -1;
1526 self->hf_curr = (cp += i);
1528 *cp++ = c;
1532 self->hf_curr = cp;
1533 jleave:
1534 NYD_LEAVE;
1535 return (self->hf_flags & _HF_ERROR) ? -1 : rv;
1539 * TODO Because we don't support filter chains yet this filter will be run
1540 * TODO in a dedicated subprocess, driven via a special Popen() mode
1542 static bool_t __hf_hadpipesig;
1543 static void
1544 __hf_onpipe(int signo)
1546 NYD_X; /* Signal handler */
1547 UNUSED(signo);
1548 __hf_hadpipesig = TRU1;
1551 FL int
1552 htmlflt_process_main(void)
1554 char buf[BUFFER_SIZE];
1555 struct htmlflt hf;
1556 size_t i;
1557 int rv;
1558 NYD_ENTER;
1560 __hf_hadpipesig = FAL0;
1561 safe_signal(SIGPIPE, &__hf_onpipe);
1563 htmlflt_init(&hf);
1564 htmlflt_reset(&hf, stdout);
1566 for (;;) {
1567 if ((i = fread(buf, sizeof(buf[0]), NELEM(buf), stdin)) == 0) {
1568 rv = !feof(stdin);
1569 break;
1572 if ((rv = __hf_hadpipesig))
1573 break;
1574 /* Just use this directly.. */
1575 if (htmlflt_push(&hf, buf, i) < 0) {
1576 rv = 1;
1577 break;
1580 if (rv == 0 && htmlflt_flush(&hf) < 0)
1581 rv = 1;
1583 htmlflt_destroy(&hf);
1585 rv |= __hf_hadpipesig;
1586 NYD_LEAVE;
1587 return rv;
1590 FL void
1591 htmlflt_init(struct htmlflt *self)
1593 NYD_ENTER;
1594 /* (Rather redundant though) */
1595 memset(self, 0, sizeof *self);
1596 NYD_LEAVE;
1599 FL void
1600 htmlflt_destroy(struct htmlflt *self)
1602 NYD_ENTER;
1603 htmlflt_reset(self, NULL);
1604 NYD_LEAVE;
1607 FL void
1608 htmlflt_reset(struct htmlflt *self, FILE *f)
1610 struct htmlflt_href *hfhp;
1611 NYD_ENTER;
1613 while ((hfhp = self->hf_hrefs) != NULL) {
1614 self->hf_hrefs = hfhp->hfh_next;
1615 free(hfhp);
1618 if (self->hf_bdat != NULL)
1619 free(self->hf_bdat);
1620 if (self->hf_line != NULL)
1621 free(self->hf_line);
1623 memset(self, 0, sizeof *self);
1625 if (f != NULL) {
1626 ui32_t sw = MAX(_HF_MINLEN, (ui32_t)scrnwidth);
1628 self->hf_line = smalloc((size_t)sw * mb_cur_max +1);
1629 self->hf_lmax = sw;
1631 if (options & OPT_UNICODE) /* TODO not truly generic */
1632 self->hf_flags = _HF_UTF8;
1633 self->hf_os = f;
1635 NYD_LEAVE;
1638 FL ssize_t
1639 htmlflt_push(struct htmlflt *self, char const *dat, size_t len)
1641 ssize_t rv;
1642 NYD_ENTER;
1644 rv = _hf_add_data(self, dat, len);
1645 NYD_LEAVE;
1646 return rv;
1649 FL ssize_t
1650 htmlflt_flush(struct htmlflt *self)
1652 ssize_t rv;
1653 NYD_ENTER;
1655 rv = _hf_add_data(self, NULL, 0);
1656 rv |= !fflush(self->hf_os) ? 0 : -1;
1657 NYD_LEAVE;
1658 return rv;
1660 #endif /* HAVE_FILTER_HTML_TAGSOUP */
1662 /* s-it-mode */