1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
4 * Copyright (c) 2013 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
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.
21 #ifndef HAVE_AMALGAMATION
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
44 struct quoteflt
*self
;
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
);
60 _qf_dump_prefix(struct quoteflt
*self
)
66 if ((i
= self
->qf_pfix_len
) > 0 && i
!= fwrite(self
->qf_pfix
, 1, i
,
71 if ((i
= self
->qf_currq
.l
) > 0 && i
!= fwrite(self
->qf_currq
.s
, 1, i
,
84 _qf_add_data(struct quoteflt
*self
, wchar_t wc
)
87 ui32_t save_l
, save_w
;
92 save_l
= save_w
= 0; /* silence cc */
94 /* <newline> ends state */
97 if (wc
== L
'\r') /* TODO CR should be stripped in lower level!! */
100 /* Unroll <tab> to spaces */
102 save_l
= self
->qf_datw
;
103 save_w
= (save_l
+ QUOTE_TAB_SPACES
) & ~(QUOTE_TAB_SPACES
- 1);
105 while (save_w
-- > 0) {
106 ssize_t j
= _qf_add_data(self
, L
' ');
120 self
->qf_dat
.s
[self
->qf_dat
.l
++] = '?';
122 l
= wctomb(self
->qf_dat
.s
+ self
->qf_dat
.l
, wc
);
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
++] = '\\';
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..) */
167 self
->qf_state
= _QF_PREFIX
;
168 self
->qf_wscnt
= self
->qf_datw
= 0;
169 self
->qf_currq
.l
= 0;
177 _qf_state_prefix(struct qf_vc
*vc
)
179 struct quoteflt
*self
;
189 for (buf
= vc
->buf
, len
= vc
->len
; len
> 0;) {
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];
200 self
->qf_mbps
[1] = self
->qf_mbps
[0];
201 if (i
== (size_t)-2) {
202 /* Redundant shift sequence, out of buffer */
215 if (i
== 1 && ISQUOTE(wc
)) {
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
;
223 self
->qf_currq
.s
[self
->qf_currq
.l
++] = buf
[-1];
227 /* The quote is parsed and compressed; dump it */
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
;
237 rv
= _qf_add_data(self
, wc
);
248 _qf_state_data(struct qf_vc
*vc
)
250 struct quoteflt
*self
;
260 for (buf
= vc
->buf
, len
= vc
->len
; len
> 0;) {
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];
270 self
->qf_mbps
[1] = self
->qf_mbps
[0];
271 if (i
== (size_t)-2) {
272 /* Redundant shift sequence, out of buffer */
279 { ssize_t j
= _qf_add_data(self
, wc
);
287 if (self
->qf_state
!= _QF_DATA
)
296 #endif /* HAVE_QUOTE_FOLD */
299 quoteflt_dummy(void) /* TODO LEGACY (until filters are plugged when needed) */
301 static struct quoteflt qf_i
;
307 quoteflt_init(struct quoteflt
*self
, char const *prefix
)
309 #ifdef HAVE_QUOTE_FOLD
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);
331 qmin
= (ui32_t
)strtol(xcp
+ 1, NULL
, 10);
332 if (qmin
< qmax
>> 1)
334 else if (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
);
349 quoteflt_destroy(struct quoteflt
*self
) /* xxx inline */
357 quoteflt_reset(struct quoteflt
*self
, FILE *f
) /* xxx inline */
361 #ifdef HAVE_QUOTE_FOLD
362 self
->qf_state
= _QF_CLEAN
;
364 self
->qf_currq
.l
= 0;
365 memset(self
->qf_mbps
, 0, sizeof self
->qf_mbps
);
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 ..) */
378 self
->qf_nl_last
= (len
> 0 && dat
[len
- 1] == '\n'); /* TODO HACK */
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
))
390 /* Normal: place *indentprefix* at every BOL */
392 #ifdef HAVE_QUOTE_FOLD
393 if (self
->qf_qfold_max
== 0)
398 bool_t pxok
= (self
->qf_qfold_min
!= 0);
402 ll
= self
->qf_pfix_len
;
403 if (ll
!= fwrite(self
->qf_pfix
, 1, ll
, self
->qf_os
))
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
)
418 ll
= PTR2SIZE((char*)vp
- dat
) + 1;
421 if (ll
!= fwrite(dat
, sizeof *dat
, ll
, self
->qf_os
))
424 if ((len
-= ll
) == 0)
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
451 switch (self
->qf_state
) {
454 i
= _qf_state_prefix(&vc
);
456 default: /* silence cc (`i' unused) */
458 i
= _qf_state_data(&vc
);
466 #endif /* HAVE_QUOTE_FOLD */
477 quoteflt_flush(struct quoteflt
*self
)
483 #ifdef HAVE_QUOTE_FOLD
484 if (self
->qf_dat
.l
> 0) {
485 rv
= _qf_dump_prefix(self
);
487 size_t i
= self
->qf_dat
.l
;
488 if (i
== fwrite(self
->qf_dat
.s
, 1, i
, self
->qf_os
))
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
;
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
516 _HF_MINLEN
= 10, /* Minimum line length (can't really be smaller) */
517 _HF_BRKSUB
= 8 /* Start considering line break MAX - BRKSUB */
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>.. */
542 _HFSA_IMG
= -6, /* <img> */
543 _HFSA_HREF
= -7, /* <a>.. */
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)];
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 */
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 */
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., … -> ...) */
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
[] = {
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
),
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
),
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
),
617 /* Entity list; not binary searched.. */
618 static struct hf_ent
const _hf_ents
[] = {
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"}
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),
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)
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
);
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
,
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
,
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
;
704 if (!(self
->hf_flags
& _HF_NL_2
) && putc('\n', self
->hf_os
) == EOF
) {
705 self
->hf_flags
|= _HF_ERROR
;
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
;
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
);
725 self
->hf_flags
|= _HF_ERROR
;
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;
738 static struct htmlflt
*
739 _hf_dump(struct htmlflt
*self
)
745 f
= self
->hf_flags
& ~_HF_BLANK
;
748 self
->hf_mbwidth
= self
->hf_mboff
= self
->hf_last_ws
= self
->hf_len
= 0;
750 for (c
= '\0'; l
> 0; --l
) {
753 if (putc(c
, self
->hf_os
) == EOF
) {
754 self
->hf_flags
= (f
|= _HF_ERROR
);
760 f
|= (f
& _HF_NL_1
) ? _HF_NL_2
: _HF_NL_1
;
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
);
777 static struct htmlflt
*
778 _hf_store(struct htmlflt
*self
, char c
)
787 self
->hf_line
[l
] = (c
== '\t' ? ' ' : c
);
789 if (blankspacechar(c
)) {
791 i
= 8 - ((l
- 1) & 7); /* xxx magic tab width of 8 */
794 self
= _hf_store(self
, ' ');
799 self
->hf_last_ws
= l
;
800 } else if (/*c == '.' ||*/ c
== ',' || c
== ';' || c
== '-')
801 self
->hf_last_ws
= 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.. */
807 int w
, x
= mbtowc(&wc
, self
->hf_line
+ self
->hf_mboff
, l
- self
->hf_mboff
);
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! */
820 } else if (iswspace(wc
))
821 self
->hf_last_ws
= l
;
823 i
= (self
->hf_mbwidth
+= w
);
826 mbtowc(&wc
, NULL
, mb_cur_max
);
827 if (UICMP(32, l
- self
->hf_mboff
, >=, mb_cur_max
)) { /* XXX */
832 i
= self
->hf_mbwidth
;
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
) {
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
);
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
;
861 } else if ((f
& _HF_UTF8
) && ((ui8_t
)c
& 0xC0) != 0x80) {
862 self
->hf_last_ws
= i
;
866 /* Hard break necessary! xxx really badly done */
867 if (l
>= self
->hf_lmax
- 1)
868 self
= _hf_dump(self
);
875 # ifdef HAVE_NATCH_CHAR
876 static struct htmlflt
*
877 __hf_sync_mbstuff(struct htmlflt
*self
)
890 int x
= mbtowc(&wc
, b
, l
);
899 if ((x
= wcwidth(wc
)) == -1)
905 /* Bad, skip over a single character.. XXX very bad indeed */
911 mbtowc(&wc
, NULL
, mb_cur_max
);
915 self
->hf_mbwidth
= w
;
920 # endif /* HAVE_NATCH_CHAR */
922 static struct htmlflt
*
923 _hf_nl(struct htmlflt
*self
)
928 if (!((f
= self
->hf_flags
) & _HF_ERROR
)) {
930 if ((f
& _HF_NL_MASK
) != _HF_NL_MASK
)
931 self
= _hf_dump(self
);
933 self
->hf_flags
= (f
|= _HF_NL_MASK
);
939 static struct htmlflt
*
940 _hf_nl_force(struct htmlflt
*self
)
943 if (!(self
->hf_flags
& _HF_ERROR
))
944 self
= _hf_dump(self
);
949 static struct htmlflt
*
950 _hf_putc(struct htmlflt
*self
, char c
)
955 if ((f
= self
->hf_flags
) & _HF_ERROR
)
961 } else if (c
== ' ' || c
== '\t') {
962 if ((f
& _HF_BLANK
) || self
->hf_len
== 0)
968 self
->hf_flags
= (f
|= _HF_ANY
);
969 self
= _hf_store(self
, c
);
975 static struct htmlflt
*
976 _hf_putc_premode(struct htmlflt
*self
, char c
)
981 if ((f
= self
->hf_flags
) & _HF_ERROR
) {
983 } else if (c
== '\n')
984 self
= _hf_nl_force(self
);
987 self
->hf_flags
= (f
|= _HF_ANY
);
988 self
= _hf_store(self
, c
);
994 static struct htmlflt
*
995 _hf_puts(struct htmlflt
*self
, char const *cp
)
1000 while ((c
= *cp
++) != '\0')
1001 self
= _hf_putc(self
, c
);
1006 static struct htmlflt
*
1007 _hf_putbuf(struct htmlflt
*self
, char const *cp
, size_t len
)
1012 self
= _hf_putc(self
, *cp
++);
1017 static struct htmlflt
*
1018 _hf_param(struct htmlflt
*self
, struct str
*store
, char const *param
)
1030 /* Skip over any non-WS first; be aware of soup, if it slipped through */
1032 if((c
= *cp
++) == '\0' || c
== '>')
1038 /* Search for the parameter, take care of other quoting along the way */
1045 if((c
= *cp
++) == '\0' || c
== '>')
1052 /* Could it be a parameter? */
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
== '>')
1063 while(whitechar(quote
))
1070 continue; /* XXX Optimize: i bytes or even cp2 can't be it! */
1074 /* Not the desired one; but a parameter? */
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
)
1084 while((c
= *cp
) != '\0' && !whitechar(c
) && c
!= '>')
1090 /* Skip further whitespace */
1092 if((c
= *cp
++) == '\0' || c
== '>')
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 " :> */
1106 store
->s
= UNCONST(cp
- 1);
1108 while((c
= *cp
) != '\0' && !whitechar(c
) && c
!= '>')
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)
1128 static struct htmlflt
*
1129 _hf_expand_all_ents(struct htmlflt
*self
, struct str
const *param
)
1131 char const *cp
, *maxcp
, *ep
;
1136 for (cp
= param
->s
, maxcp
= cp
+ param
->l
; cp
< maxcp
;)
1137 if ((c
= *cp
++) != '&')
1139 self
= _hf_putc(self
, c
);
1142 if (ep
== maxcp
|| (c
= *ep
++) == '\0') {
1143 for (; cp
< ep
; ++cp
)
1144 self
= _hf_putc(self
, *cp
);
1146 } else if (c
== ';') {
1147 if ((i
= PTR2SIZE(ep
- cp
)) > 1) {
1148 self
= _hf_check_ent(self
, cp
, i
);
1163 static struct htmlflt
*
1164 _hf_check_tag(struct htmlflt
*self
, char const *s
)
1169 struct htmlflt_tag
const *hftp
;
1173 /* Extra check only */
1176 DBG( n_alert("HTML tagsoup filter _hf_check_tag() called on soup!"); )
1178 self
= _hf_puts(self
, self
->hf_bdat
);
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! */
1188 while ((c
= s
[j
]) != '\0' && c
!= '>' && whitechar(c
))
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
))
1200 if (PTRCMP(++hftp
, >=, _hf_tags
+ NELEM(_hf_tags
)))
1205 switch (hftp
->hft_act
) {
1217 if (!(self
->hf_flags
& _HF_NL_2
))
1218 self
= _hf_nl(self
);
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
, ' ');
1231 self
->hf_ign_tag
= hftp
;
1232 self
->hf_flags
= (f
|= _HF_IGN
| _HF_NOPUT
);
1236 self
= _hf_param(self
, ¶m
, "alt");
1237 self
= _hf_putc(self
, '[');
1238 if (param
.s
== NULL
) {
1239 param
.s
= UNCONST("IMG");
1242 } /* else */ if (memchr(param
.s
, '&', param
.l
) != NULL
)
1243 self
= _hf_expand_all_ents(self
, ¶m
);
1246 self
= _hf_putbuf(self
, param
.s
, param
.l
);
1247 self
= _hf_putc(self
, ']');
1251 self
= _hf_param(self
, ¶m
, "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
);
1267 self
->hf_flags
= (f
&= ~_HF_HREF
);
1269 case _HFSA_HREF_END
:
1271 snprintf(nobuf
, sizeof nobuf
, "[/%u]", self
->hf_href_no
);
1272 self
= _hf_puts(self
, nobuf
);
1277 c
= (char)(hftp
->hft_act
& 0xFF);
1278 self
= _hf_putc(self
, c
);
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 */
1294 /* Ignore <!DOCTYPE, <!-- comments, <? PIs.. */
1297 /* Print out an empty tag as such */
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
);
1319 static struct htmlflt
*
1320 _hf_check_ent(struct htmlflt
*self
, char const *s
, size_t l
)
1325 struct hf_ent
const *hfep
;
1333 /* False entities seen in the wild assert(s[l - 1] == ';'); */
1337 /* Numeric entity, or try named search */
1339 i
= (*++s
== 'x' ? 16 : 10);
1341 if ((i
!= 16 || (++s
, --l
) > 0) && l
< sizeof(nobuf
)) {
1342 memcpy(nobuf
, s
, l
);
1344 i
= strtol(nobuf
, NULL
, i
);
1346 self
= _hf_putc(self
, (char)i
);
1347 else if (self
->hf_flags
& _HF_UTF8
) {
1349 l
= n_utf32_to_utf8((ui32_t
)i
, nobuf
);
1350 self
= _hf_putbuf(self
, nobuf
, l
);
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
)) {
1364 } else if (hf
& _HFE_HAVE_CSTR
)
1365 self
= _hf_puts(self
, hfep
->hfe_cstr
);
1367 self
= _hf_putc(self
, hfep
->hfe_c
);
1371 self
= _hf_putbuf(self
, s_save
, l_save
);
1379 _hf_add_data(struct htmlflt
*self
, char const *dat
, size_t len
)
1381 char c
, *cp
, *cp_max
;
1386 /* Final put request? */
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
);
1397 /* Always ensure some initial buffer */
1398 if ((cp
= self
->hf_curr
) != NULL
)
1399 cp_max
= self
->hf_bmax
;
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
;
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! */
1422 struct htmlflt_tag
const *hftp
= self
->hf_ign_tag
;
1429 } else if (c
== '>') {
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
));
1440 i
= PTR2SIZE(cp
- self
->hf_bdat
);
1441 if ((i
== 1 && c
!= '/') || --i
> hftp
->hft_len
) {
1448 /* People are using & without &ing it, ditto <; be aware */
1449 if (f
& (_HF_NOPUT
| _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)) {
1457 self
= _hf_puts(self
, self
->hf_bdat
);
1463 self
->hf_flags
= (f
|= _HF_NOPUT
);
1466 /* Weird tagsoup around, do we actually parse a tag? */
1467 if (!(f
& _HF_NOPUT
))
1471 f
&= ~(_HF_NOPUT
| _HF_ENT
);
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')
1481 case '\r': /* TODO CR should be stripped in lower level!! (Only B64!?!) */
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 */
1489 self
= (f
& _HF_PRE
) ? _hf_nl_force(self
) : _hf_putc(self
, ' ');
1498 /* If not currently parsing a tag and bypassing normal output.. */
1499 if (!(f
& _HF_NOPUT
)) {
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
;
1510 self
= _hf_putc(self
, c
);
1511 } else if ((f
& _HF_ENT
) && c
== ';') {
1514 f
&= ~(_HF_NOPUT
| _HF_ENT
);
1516 self
= _hf_check_ent(self
, self
->hf_bdat
,
1517 PTR2SIZE(cp
+ 1 - self
->hf_bdat
));
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
);
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
;
1544 __hf_onpipe(int signo
)
1546 NYD_X
; /* Signal handler */
1548 __hf_hadpipesig
= TRU1
;
1552 htmlflt_process_main(void)
1554 char buf
[BUFFER_SIZE
];
1560 __hf_hadpipesig
= FAL0
;
1561 safe_signal(SIGPIPE
, &__hf_onpipe
);
1564 htmlflt_reset(&hf
, stdout
);
1567 if ((i
= fread(buf
, sizeof(buf
[0]), NELEM(buf
), stdin
)) == 0) {
1572 if ((rv
= __hf_hadpipesig
))
1574 /* Just use this directly.. */
1575 if (htmlflt_push(&hf
, buf
, i
) < 0) {
1580 if (rv
== 0 && htmlflt_flush(&hf
) < 0)
1583 htmlflt_destroy(&hf
);
1585 rv
|= __hf_hadpipesig
;
1591 htmlflt_init(struct htmlflt
*self
)
1594 /* (Rather redundant though) */
1595 memset(self
, 0, sizeof *self
);
1600 htmlflt_destroy(struct htmlflt
*self
)
1603 htmlflt_reset(self
, NULL
);
1608 htmlflt_reset(struct htmlflt
*self
, FILE *f
)
1610 struct htmlflt_href
*hfhp
;
1613 while ((hfhp
= self
->hf_hrefs
) != NULL
) {
1614 self
->hf_hrefs
= hfhp
->hfh_next
;
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
);
1626 ui32_t sw
= MAX(_HF_MINLEN
, (ui32_t
)scrnwidth
);
1628 self
->hf_line
= smalloc((size_t)sw
* mb_cur_max
+1);
1631 if (options
& OPT_UNICODE
) /* TODO not truly generic */
1632 self
->hf_flags
= _HF_UTF8
;
1639 htmlflt_push(struct htmlflt
*self
, char const *dat
, size_t len
)
1644 rv
= _hf_add_data(self
, dat
, len
);
1650 htmlflt_flush(struct htmlflt
*self
)
1655 rv
= _hf_add_data(self
, NULL
, 0);
1656 rv
|= !fflush(self
->hf_os
) ? 0 : -1;
1660 #endif /* HAVE_FILTER_HTML_TAGSOUP */