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
);
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 wether 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 ..) */
381 /* Bypass? XXX Finally, this filter simply should not be used, then */
382 if (self
->qf_pfix_len
== 0) {
383 if (len
!= fwrite(dat
, 1, len
, self
->qf_os
))
387 /* Normal: place *indentprefix* at every BOL */
389 #ifdef HAVE_QUOTE_FOLD
390 if (self
->qf_qfold_max
== 0)
395 bool_t pxok
= (self
->qf_qfold_min
!= 0);
399 ll
= self
->qf_pfix_len
;
400 if (ll
!= fwrite(self
->qf_pfix
, 1, ll
, self
->qf_os
))
406 /* xxx Strictly speaking this is invalid, because only `/' and `.' are
407 * xxx mandated by POSIX.1-2008 as "invariant across all locales
408 * xxx supported"; though there is no charset known which uses this
409 * xxx control char as part of a multibyte character; note that S-nail
410 * XXX (and the Mail codebase as such) do not support EBCDIC */
411 if ((vp
= memchr(dat
, '\n', len
)) == NULL
)
415 ll
= PTR2SIZE((char*)vp
- dat
) + 1;
418 if (ll
!= fwrite(dat
, sizeof *dat
, ll
, self
->qf_os
))
421 if ((len
-= ll
) == 0)
426 self
->qf_qfold_min
= pxok
;
428 /* Overly complicated, though still only line-per-line: *quote-fold*.
429 * - If .qf_currq.l is 0, then we are in a clean state. Reset .qf_mbps;
430 * TODO note this means we assume that lines start with reset escape seq,
431 * TODO but i don't think this is any worse than what we currently do;
432 * TODO in 15.0, with the value carrier, we should carry conversion states
433 * TODO all along, only resetting on error (or at words for header =???=);
434 * TODO this still is weird for error handling, but we need to act more
435 * TODO stream-alike (though in practice i don't think cross-line states
436 * TODO can be found, because of compatibility reasons; however, being
437 * TODO a problem rather than a solution is not a good thing (tm))
438 * - Lookout for a newline */
439 #ifdef HAVE_QUOTE_FOLD
448 switch (self
->qf_state
) {
451 i
= _qf_state_prefix(&vc
);
453 default: /* silence cc (`i' unused) */
455 i
= _qf_state_data(&vc
);
463 #endif /* HAVE_QUOTE_FOLD */
474 quoteflt_flush(struct quoteflt
*self
)
480 #ifdef HAVE_QUOTE_FOLD
481 if (self
->qf_dat
.l
> 0) {
482 rv
= _qf_dump_prefix(self
);
484 size_t i
= self
->qf_dat
.l
;
485 if (i
== fwrite(self
->qf_dat
.s
, 1, i
, self
->qf_os
))
490 self
->qf_brk_isws
= FAL0
;
491 self
->qf_wscnt
= self
->qf_brkl
= self
->qf_brkw
= 0;
492 self
->qf_datw
= self
->qf_pfix_len
+ self
->qf_currq
.l
;
501 * HTML tagsoup filter
502 * TODO . Numeric &#NO; entities should also be treated by struct hf_ent
503 * TODO . Yes, we COULD support CSS based quoting when we'd check type="quote"
504 * TODO (nonstandard) and watch out for style="gmail_quote" (or so, VERY
505 * TODO nonstandard) and tracking a stack of such elements (to be popped
506 * TODO once the closing element is seen). Then, after writing a newline,
507 * TODO place sizeof(stack) ">"s first. But aren't these HTML mails rude?
508 * TODO Interlocking and non-well-formed data will break us down
510 #ifdef HAVE_FILTER_HTML_TAGSOUP
513 _HF_MINLEN
= 10, /* Minimum line length (can't really be smaller) */
514 _HF_BRKSUB
= 8 /* Start considering line break MAX - BRKSUB */
518 _HF_UTF8
= 1<<0, /* Data is in UTF-8 */
519 _HF_ERROR
= 1<<1, /* A hard error occurred, bail as soon as possible */
520 _HF_NOPUT
= 1<<2, /* (In a tag,) Don't generate output */
521 _HF_IGN
= 1<<3, /* Ignore mode on */
522 _HF_ANY
= 1<<4, /* Yet seen just any output */
523 _HF_PRE
= 1<<5, /* In <pre>formatted mode */
524 _HF_ENT
= 1<<6, /* Currently parsing an entity */
525 _HF_BLANK
= 1<<7, /* Whitespace last */
526 _HF_HREF
= 1<<8, /* External <a href=> was the last href seen */
528 _HF_NL_1
= 1<<9, /* One \n seen */
529 _HF_NL_2
= 2<<9, /* We have produced an all empty line */
530 _HF_NL_MASK
= _HF_NL_1
| _HF_NL_2
533 enum hf_special_actions
{
534 _HFSA_NEEDSEP
= -1, /* Need an empty line (paragraph separator) */
535 _HFSA_NEEDNL
= -2, /* Need a new line start (table row) */
536 _HFSA_IGN
= -3, /* Things like <style>..</style>, <script>.. */
537 _HFSA_PRE
= -4, /* <pre>.. */
539 _HFSA_IMG
= -6, /* <img> */
540 _HFSA_HREF
= -7, /* <a>.. */
544 enum hf_entity_flags
{
545 _HFE_HAVE_UNI
= 1<<6, /* Have a Unicode replacement character */
546 _HFE_HAVE_CSTR
= 1<<7, /* Have a string replacement */
547 /* We store the length of the entity name in the flags, too */
548 _HFE_LENGTH_MASK
= (1<<6) - 1
551 struct htmlflt_href
{
552 struct htmlflt_href
*hfh_next
;
553 ui32_t hfh_no
; /* Running sequence */
554 ui32_t hfh_len
; /* of .hfh_dat */
555 char hfh_dat
[VFIELD_SIZE(0)];
559 si32_t hft_act
; /* char or hf_special_actions */
560 /* Not NUL: character to inject, with high bit set: place a space
561 * afterwards. Note: only recognized with _HFSA_NEEDSEP or _HFSA_NEEDNL */
563 ui8_t hft_len
; /* Useful bytes in (NUL terminated) .hft_tag */
564 char const hft_tag
[10]; /* Tag less < and > surroundings (TR, /TR, ..) */
566 CTA(SIZEOF_FIELD(struct htmlflt_tag
, hft_tag
) < LINESIZE
); /* .hf_ign_tag */
569 ui8_t hfe_flags
; /* enum hf_entity_flags plus length of .hfe_ent */
570 char hfe_c
; /* Plain replacement character */
571 ui16_t hfe_uni
; /* Unicode codepoint if _HFE_HAVE_UNI */
572 char hfe_cstr
[5]; /* _HFE_HAVE_CSTR (e.g., … -> ...) */
573 char const hfe_ent
[7]; /* Entity less & and ; surroundings */
576 /* Tag list; not binary searched :(, so try to take care a bit */
577 static struct htmlflt_tag
const _hf_tags
[] = {
580 # define _X(S,A) {A, '\0', sizeof(S) -1, S "\0"}
581 # define _XC(S,C,A) {A, C, sizeof(S) -1, S "\0"}
583 _X("P", _HFSA_NEEDSEP
), _X("/P", _HFSA_NEEDNL
),
584 _X("DIV", _HFSA_NEEDSEP
), _X("/DIV", _HFSA_NEEDNL
),
585 _X("TR", _HFSA_NEEDNL
),
588 /* Let it stand out; also since we don't support implicit paragraphs after
589 * block elements, plain running text after a list (seen in Unicode
590 * announcement via Firefox) */
591 _X("UL", _HFSA_NEEDSEP
), _X("/UL", _HFSA_NEEDSEP
),
592 _XC("LI", (char)0x80 | '*', _HFSA_NEEDSEP
),
593 _X("DL", _HFSA_NEEDSEP
),
594 _X("DT", _HFSA_NEEDNL
),
596 _X("A", _HFSA_HREF
), _X("/A", _HFSA_HREF_END
),
597 _X("IMG", _HFSA_IMG
),
599 _X("PRE", _HFSA_PRE
), _X("/PRE", _HFSA_PRE_END
),
600 _X("TITLE", _HFSA_NEEDSEP
), /*_X("/TITLE", '\n'),*/
601 _X("H1", _HFSA_NEEDSEP
), /*_X("/H1", '\n'),*/
602 _X("H2", _HFSA_NEEDSEP
), /*_X("/H2", '\n'),*/
603 _X("H3", _HFSA_NEEDSEP
), /*_X("/H3", '\n'),*/
604 _X("H4", _HFSA_NEEDSEP
), /*_X("/H4", '\n'),*/
605 _X("H5", _HFSA_NEEDSEP
), /*_X("/H5", '\n'),*/
606 _X("H6", _HFSA_NEEDSEP
), /*_X("/H6", '\n'),*/
608 _X("STYLE", _HFSA_IGN
),
609 _X("SCRIPT", _HFSA_IGN
),
614 /* Entity list; not binary searched.. */
615 static struct hf_ent
const _hf_ents
[] = {
620 # define _X(E,C) {(sizeof(E) -1), C, 0x0u, "", E "\0"}
621 # define _XU(E,C,U) {(sizeof(E) -1) | _HFE_HAVE_UNI, C, U, "", E "\0"}
622 # define _XS(E,S) {(sizeof(E) -1) | _HFE_HAVE_CSTR, '\0', 0x0u,S "\0",E "\0"}
623 # define _XSU(E,S,U) \
624 {(sizeof(E) -1) | _HFE_HAVE_UNI | _HFE_HAVE_CSTR, '\0', U, S "\0", E "\0"}
628 _X("lt", '<'), _X("gt", '>'),
630 _XU("nbsp", ' ', 0x0020 /* Note: not 0x00A0 seems to be better for us */),
631 _XU("middot", '.', 0x00B7),
632 _XSU("hellip", "...", 0x2026),
633 _XSU("mdash", "---", 0x2014), _XSU("ndash", "--", 0x2013),
634 _XSU("laquo", "<<", 0x00AB), _XSU("raquo", ">>", 0x00BB),
635 _XSU("lsaquo", "<", 0x2039), _XSU("rsaquo", ">", 0x203A),
636 _XSU("lsquo", "'", 0x2018), _XSU("rsquo", "'", 0x2019),
637 _XSU("ldquo", "\"", 0x201C), _XSU("rdquo", "\"", 0x201D),
638 _XSU("uarr", "^|", 0x2191), _XSU("darr", "|v", 0x2193),
640 _XSU("cent", "CENT", 0x00A2),
641 _XSU("copy", "(C)", 0x00A9),
642 _XSU("euro", "EUR", 0x20AC),
643 _XSU("infin", "INFY", 0x221E),
644 _XSU("pound", "GBP", 0x00A3),
645 _XSU("reg", "(R)", 0x00AE),
646 _XSU("sect", "S:", 0x00A7),
647 _XSU("yen", "JPY", 0x00A5),
650 _XSU("Auml", "Ae", 0x00C4), _XSU("auml", "ae", 0x00E4),
651 _XSU("Ouml", "Oe", 0x00D6), _XSU("ouml", "oe", 0x00F6),
652 _XSU("Uuml", "Ue", 0x00DC), _XSU("uuml", "ue", 0x00FC),
653 _XSU("szlig", "ss", 0x00DF)
662 static struct htmlflt
* _hf_dump_hrefs(struct htmlflt
*self
);
663 static struct htmlflt
* _hf_dump(struct htmlflt
*self
);
664 static struct htmlflt
* _hf_store(struct htmlflt
*self
, char c
);
665 # ifdef HAVE_NATCH_CHAR
666 static struct htmlflt
* __hf_sync_mbstuff(struct htmlflt
*self
);
670 static struct htmlflt
* _hf_nl(struct htmlflt
*self
);
671 static struct htmlflt
* _hf_nl_force(struct htmlflt
*self
);
672 static struct htmlflt
* _hf_putc(struct htmlflt
*self
, char c
);
673 static struct htmlflt
* _hf_putc_premode(struct htmlflt
*self
, char c
);
674 static struct htmlflt
* _hf_puts(struct htmlflt
*self
, char const *cp
);
675 static struct htmlflt
* _hf_putbuf(struct htmlflt
*self
,
676 char const *cp
, size_t len
);
678 /* Try to locate a param'eter in >hf_bdat, store it (non-terminated!) or NULL */
679 static struct htmlflt
* _hf_param(struct htmlflt
*self
, struct str
*store
,
682 /* Expand all entities in the given parameter */
683 static struct htmlflt
* _hf_expand_all_ents(struct htmlflt
*self
,
684 struct str
const *param
);
686 /* Completely parsed over a tag / an entity, interpret that */
687 static struct htmlflt
* _hf_check_tag(struct htmlflt
*self
, char const *s
);
688 static struct htmlflt
* _hf_check_ent(struct htmlflt
*self
, char const *s
,
692 static ssize_t
_hf_add_data(struct htmlflt
*self
,
693 char const *dat
, size_t len
);
695 static struct htmlflt
*
696 _hf_dump_hrefs(struct htmlflt
*self
)
698 struct htmlflt_href
*hhp
;
701 if (!(self
->hf_flags
& _HF_NL_2
) && putc('\n', self
->hf_os
) == EOF
) {
702 self
->hf_flags
|= _HF_ERROR
;
706 /* Reverse the list */
707 for (hhp
= self
->hf_hrefs
, self
->hf_hrefs
= NULL
; hhp
!= NULL
;) {
708 struct htmlflt_href
*tmp
= hhp
->hfh_next
;
709 hhp
->hfh_next
= self
->hf_hrefs
;
710 self
->hf_hrefs
= hhp
;
715 while ((hhp
= self
->hf_hrefs
) != NULL
) {
716 self
->hf_hrefs
= hhp
->hfh_next
;
718 if (!(self
->hf_flags
& _HF_ERROR
)) {
719 int w
= fprintf(self
->hf_os
, " [%u] %.*s\n",
720 hhp
->hfh_no
, (int)hhp
->hfh_len
, hhp
->hfh_dat
);
722 self
->hf_flags
|= _HF_ERROR
;
727 self
->hf_flags
|= (putc('\n', self
->hf_os
) == EOF
)
728 ? _HF_ERROR
: _HF_NL_1
| _HF_NL_2
;
729 self
->hf_href_dist
= (ui32_t
)realscreenheight
>> 1;
735 static struct htmlflt
*
736 _hf_dump(struct htmlflt
*self
)
742 f
= self
->hf_flags
& ~_HF_BLANK
;
745 self
->hf_mbwidth
= self
->hf_mboff
= self
->hf_last_ws
= self
->hf_len
= 0;
747 for (c
= '\0'; l
> 0; --l
) {
750 if (putc(c
, self
->hf_os
) == EOF
) {
751 self
->hf_flags
= (f
|= _HF_ERROR
);
757 f
|= (f
& _HF_NL_1
) ? _HF_NL_2
: _HF_NL_1
;
764 /* Check wether there are HREFs to dump; there is so much messy tagsoup out
765 * there that it seems best not to simply dump HREFs in each _dump(), but
766 * only with some gap, let's say half the real screen height */
767 if (--self
->hf_href_dist
< 0 && (f
& _HF_NL_2
) && self
->hf_hrefs
!= NULL
)
768 self
= _hf_dump_hrefs(self
);
774 static struct htmlflt
*
775 _hf_store(struct htmlflt
*self
, char c
)
784 self
->hf_line
[l
] = (c
== '\t' ? ' ' : c
);
786 if (blankspacechar(c
)) {
788 i
= 8 - ((l
- 1) & 7); /* xxx magic tab width of 8 */
791 self
= _hf_store(self
, ' ');
796 self
->hf_last_ws
= l
;
797 } else if (/*c == '.' ||*/ c
== ',' || c
== ';' || c
== '-')
798 self
->hf_last_ws
= l
;
801 # ifdef HAVE_NATCH_CHAR /* XXX This code is really ridiculous! */
802 if (mb_cur_max
> 1) { /* XXX should mbrtowc() and THEN store, at least.. */
804 int x
= mbtowc(&wc
, self
->hf_line
+ self
->hf_mboff
, l
- self
->hf_mboff
);
808 if ((x
= wcwidth(wc
)) == -1)
810 else if (iswspace(wc
))
811 self
->hf_last_ws
= l
;
812 i
= (self
->hf_mbwidth
+= x
);
815 mbtowc(&wc
, NULL
, mb_cur_max
);
816 if (UICMP(32, l
- self
->hf_mboff
, >=, mb_cur_max
)) { /* XXX */
821 i
= self
->hf_mbwidth
;
826 /* Do we need to break the line? */
827 if (i
>= self
->hf_lmax
- _HF_BRKSUB
) {
828 ui32_t lim
= self
->hf_lmax
>> 1;
830 /* Let's hope we saw a sane place to break this line! */
831 if (self
->hf_last_ws
>= lim
) {
833 i
= self
->hf_len
= self
->hf_last_ws
;
834 self
= _hf_dump(self
);
835 if ((self
->hf_len
= (l
-= i
)) > 0) {
836 self
->hf_flags
&= ~_HF_NL_MASK
;
837 memmove(self
->hf_line
, self
->hf_line
+ i
, l
);
838 # ifdef HAVE_NATCH_CHAR
839 __hf_sync_mbstuff(self
);
845 /* Any 7-bit characters? */
846 for (i
= l
; i
-- >= lim
;)
847 if (asciichar((c
= self
->hf_line
[i
]))) {
848 self
->hf_last_ws
= ++i
;
850 } else if ((f
& _HF_UTF8
) && ((ui8_t
)c
& 0xC0) != 0x80) {
851 self
->hf_last_ws
= i
;
855 /* Hard break necessary! xxx really badly done */
856 if (l
>= self
->hf_lmax
- 1)
857 self
= _hf_dump(self
);
864 # ifdef HAVE_NATCH_CHAR
865 static struct htmlflt
*
866 __hf_sync_mbstuff(struct htmlflt
*self
)
879 int x
= mbtowc(&wc
, b
, l
);
888 if ((x
= wcwidth(wc
)) == -1)
894 /* Bad, skip over a single character.. XXX very bad indeed */
900 mbtowc(&wc
, NULL
, mb_cur_max
);
904 self
->hf_mbwidth
= w
;
909 # endif /* HAVE_NATCH_CHAR */
911 static struct htmlflt
*
912 _hf_nl(struct htmlflt
*self
)
917 if (!((f
= self
->hf_flags
) & _HF_ERROR
)) {
919 if ((f
& _HF_NL_MASK
) != _HF_NL_MASK
)
920 self
= _hf_dump(self
);
922 self
->hf_flags
= (f
|= _HF_NL_MASK
);
928 static struct htmlflt
*
929 _hf_nl_force(struct htmlflt
*self
)
932 if (!(self
->hf_flags
& _HF_ERROR
))
933 self
= _hf_dump(self
);
938 static struct htmlflt
*
939 _hf_putc(struct htmlflt
*self
, char c
)
944 if ((f
= self
->hf_flags
) & _HF_ERROR
)
950 } else if (c
== ' ' || c
== '\t') {
951 if ((f
& _HF_BLANK
) || self
->hf_len
== 0)
957 self
->hf_flags
= (f
|= _HF_ANY
);
958 self
= _hf_store(self
, c
);
964 static struct htmlflt
*
965 _hf_putc_premode(struct htmlflt
*self
, char c
)
970 if ((f
= self
->hf_flags
) & _HF_ERROR
) {
972 } else if (c
== '\n')
973 self
= _hf_nl_force(self
);
976 self
->hf_flags
= (f
|= _HF_ANY
);
977 self
= _hf_store(self
, c
);
983 static struct htmlflt
*
984 _hf_puts(struct htmlflt
*self
, char const *cp
)
989 while ((c
= *cp
++) != '\0')
990 self
= _hf_putc(self
, c
);
995 static struct htmlflt
*
996 _hf_putbuf(struct htmlflt
*self
, char const *cp
, size_t len
)
1001 self
= _hf_putc(self
, *cp
++);
1006 static struct htmlflt
*
1007 _hf_param(struct htmlflt
*self
, struct str
*store
, char const *param
)
1019 /* Skip over any non-WS first; be aware of soup, if it slipped through */
1021 if((c
= *cp
++) == '\0' || c
== '>')
1027 /* Search for the parameter, take care of other quoting along the way */
1034 if((c
= *cp
++) == '\0' || c
== '>')
1041 /* Could it be a parameter? */
1045 /* Is it the desired one? */
1046 if((c
= upperconv(c
)) == x
&& !ascncasecmp(param
, cp
, i
)){
1047 char const *cp2
= cp
+ i
;
1049 if((quote
= *cp2
++) != '='){
1050 if(quote
== '\0' || quote
== '>')
1052 while(whitechar(quote
))
1059 continue; /* XXX Optimize: i bytes or even cp2 can't be it! */
1063 /* Not the desired one; but a parameter? */
1066 /* If so, properly skip over the value */
1067 if(c
== '"' || c
== '\''){
1068 /* TODO oops i have forgotten wether backslash quoting is allowed in
1069 * TODO quoted HTML parameter values? not supporting that for now.. */
1070 for(quote
= c
; (c
= *cp
) != '\0' && c
!= quote
; ++cp
)
1073 while((c
= *cp
) != '\0' && !whitechar(c
) && c
!= '>')
1079 /* Skip further whitespace */
1081 if((c
= *cp
++) == '\0' || c
== '>')
1087 if(c
== '"' || c
== '\''){
1088 /* TODO oops i have forgotten wether backslash quoting is allowed in
1089 * TODO quoted HTML parameter values? not supporting that for now.. */
1090 store
->s
= UNCONST(cp
);
1091 for(quote
= c
; (c
= *cp
) != '\0' && c
!= quote
; ++cp
)
1093 /* XXX ... and we simply ignore a missing trailing " :> */
1095 store
->s
= UNCONST(cp
- 1);
1097 while((c
= *cp
) != '\0' && !whitechar(c
) && c
!= '>')
1100 i
= PTR2SIZE(cp
- store
->s
);
1102 /* Terrible tagsoup out there, e.g., groups.google.com produces href=""
1103 * parameter values prefixed and suffixed by newlines! Therefore trim the
1104 * value content TODO join into the parse step above! */
1105 for (cp
= store
->s
; i
> 0 && spacechar(*cp
); ++cp
, --i
)
1107 store
->s
= UNCONST(cp
);
1108 for (cp
+= i
- 1; i
> 0 && spacechar(*cp
); --cp
, --i
)
1110 if ((store
->l
= i
) == 0)
1117 static struct htmlflt
*
1118 _hf_expand_all_ents(struct htmlflt
*self
, struct str
const *param
)
1120 char const *cp
, *maxcp
, *ep
;
1125 for (cp
= param
->s
, maxcp
= cp
+ param
->l
; cp
< maxcp
;)
1126 if ((c
= *cp
++) != '&')
1127 self
= _hf_putc(self
, c
);
1129 for (ep
= cp
--; ep
< maxcp
&& (c
= *ep
++) != ';';)
1131 self
= _hf_puts(self
, cp
);
1134 if ((i
= PTR2SIZE(ep
- cp
)) > 1)
1135 self
= _hf_check_ent(self
, cp
, i
);
1143 static struct htmlflt
*
1144 _hf_check_tag(struct htmlflt
*self
, char const *s
)
1149 struct htmlflt_tag
const *hftp
;
1153 /* Extra check only */
1156 DBG( n_alert("HTML tagsoup filter _hf_check_tag() called on soup!"); )
1158 self
= _hf_puts(self
, self
->hf_bdat
);
1162 for (++s
, i
= 0; (c
= s
[i
]) != '\0' && c
!= '>' && !whitechar(c
); ++i
)
1163 /* Special massage for things like <br/>: after the slash only whitespace
1164 * may separate us from the closing right angle! */
1168 while ((c
= s
[j
]) != '\0' && c
!= '>' && whitechar(c
))
1174 for (hftp
= _hf_tags
;;) {
1175 if (i
== hftp
->hft_len
&& !ascncasecmp(s
, hftp
->hft_tag
, i
)) {
1176 c
= s
[hftp
->hft_len
];
1177 if (c
== '>' || c
== '/' || whitechar(c
))
1180 if (PTRCMP(++hftp
, >=, _hf_tags
+ NELEM(_hf_tags
)))
1185 switch (hftp
->hft_act
) {
1197 if (!(self
->hf_flags
& _HF_NL_2
))
1198 self
= _hf_nl(self
);
1201 if (!(f
& _HF_NL_1
))
1202 self
= _hf_nl(self
);
1203 if (hftp
->hft_injc
!= '\0') {
1204 self
= _hf_putc(self
, hftp
->hft_injc
& 0x7F);
1205 if ((uc_i
)hftp
->hft_injc
& 0x80)
1206 self
= _hf_putc(self
, ' ');
1211 self
->hf_ign_tag
= hftp
;
1212 self
->hf_flags
= (f
|= _HF_IGN
| _HF_NOPUT
);
1216 self
= _hf_param(self
, ¶m
, "alt");
1217 self
= _hf_putc(self
, '[');
1218 if (param
.s
== NULL
) {
1219 param
.s
= UNCONST("IMG");
1222 } /* else */ if (memchr(param
.s
, '&', param
.l
) != NULL
)
1223 self
= _hf_expand_all_ents(self
, ¶m
);
1226 self
= _hf_putbuf(self
, param
.s
, param
.l
);
1227 self
= _hf_putc(self
, ']');
1231 self
= _hf_param(self
, ¶m
, "href");
1232 /* Ignore non-external links */
1233 if (param
.s
!= NULL
&& *param
.s
!= '#') {
1234 struct htmlflt_href
*hhp
= smalloc(sizeof(*hhp
) -
1235 VFIELD_SIZEOF(struct htmlflt_href
, hfh_dat
) + param
.l
+1);
1237 hhp
->hfh_next
= self
->hf_hrefs
;
1238 hhp
->hfh_no
= ++self
->hf_href_no
;
1239 hhp
->hfh_len
= (ui32_t
)param
.l
;
1240 memcpy(hhp
->hfh_dat
, param
.s
, param
.l
);
1242 snprintf(nobuf
, sizeof nobuf
, "[%u]", hhp
->hfh_no
);
1243 self
->hf_flags
= (f
|= _HF_HREF
);
1244 self
->hf_hrefs
= hhp
;
1245 self
= _hf_puts(self
, nobuf
);
1247 self
->hf_flags
= (f
&= ~_HF_HREF
);
1249 case _HFSA_HREF_END
:
1251 snprintf(nobuf
, sizeof nobuf
, "[/%u]", self
->hf_href_no
);
1252 self
= _hf_puts(self
, nobuf
);
1257 c
= (char)(hftp
->hft_act
& 0xFF);
1258 self
= _hf_putc(self
, c
);
1267 /* The problem is that even invalid tagsoup is widely used, without real
1268 * searching i have seen e-mail address in <N@H.D> notation, and more.
1269 * To protect us a bit look around and possibly write the content as such */
1274 /* Ignore <!DOCTYPE, <!-- comments, <? PIs.. */
1277 /* Print out an empty tag as such */
1290 /* Also skip over : in order to suppress v:roundrect, w:anchorlock.. */
1291 while ((c
= *s
++) != '\0' && c
!= '>' && !whitechar(c
) && c
!= ':')
1292 if (!asciichar(c
) || punctchar(c
)) {
1293 self
= _hf_puts(self
, self
->hf_bdat
);
1299 static struct htmlflt
*
1300 _hf_check_ent(struct htmlflt
*self
, char const *s
, size_t l
)
1305 struct hf_ent
const *hfep
;
1313 assert(s
[l
- 1] == ';');
1317 /* Numeric entity, or try named search */
1319 i
= (*++s
== 'x' ? 16 : 10);
1321 if ((i
!= 16 || (++s
, --l
) > 0) && l
< sizeof(nobuf
)) {
1322 memcpy(nobuf
, s
, l
);
1324 i
= strtol(nobuf
, NULL
, i
);
1326 self
= _hf_putc(self
, (char)i
);
1327 else if (self
->hf_flags
& _HF_UTF8
) {
1329 l
= n_utf32_to_utf8((ui32_t
)i
, nobuf
);
1330 self
= _hf_putbuf(self
, nobuf
, l
);
1336 ui32_t f
= self
->hf_flags
, hf
;
1338 for (hfep
= _hf_ents
; PTRCMP(hfep
, <, _hf_ents
+ NELEM(_hf_ents
)); ++hfep
)
1339 if (l
== ((hf
= hfep
->hfe_flags
) & _HFE_LENGTH_MASK
) &&
1340 !strncmp(s
, hfep
->hfe_ent
, l
)) {
1341 if ((hf
& _HFE_HAVE_UNI
) && (f
& _HF_UTF8
)) {
1344 } else if (hf
& _HFE_HAVE_CSTR
)
1345 self
= _hf_puts(self
, hfep
->hfe_cstr
);
1347 self
= _hf_putc(self
, hfep
->hfe_c
);
1351 self
= _hf_putbuf(self
, s_save
, l_save
);
1359 _hf_add_data(struct htmlflt
*self
, char const *dat
, size_t len
)
1361 char c
, *cp
, *cp_max
;
1366 /* Final put request? */
1368 if (self
->hf_len
> 0 || self
->hf_hrefs
!= NULL
) {
1369 self
= _hf_dump(self
);
1370 if (self
->hf_hrefs
!= NULL
)
1371 self
= _hf_dump_hrefs(self
);
1377 /* Always ensure some initial buffer */
1378 if ((cp
= self
->hf_curr
) != NULL
)
1379 cp_max
= self
->hf_bmax
;
1381 cp
= self
->hf_curr
= self
->hf_bdat
= smalloc(LINESIZE
);
1382 cp_max
= self
->hf_bmax
= cp
+ LINESIZE
-1; /* (Always room for NUL!) */
1384 hot
= (cp
!= self
->hf_bdat
);
1386 for (rv
= (ssize_t
)len
; len
> 0; --len
) {
1387 ui32_t f
= self
->hf_flags
;
1393 /* Soup is really weird, and scripts may contain almost anything (and
1394 * newer CSS standards are also cryptic): therefore prefix the _HF_IGN
1395 * test and walk until we see the required end tag */
1396 /* TODO For real safety _HF_IGN soup condome would also need to know
1397 * TODO about quoted strings so that 'var i = "</script>";' couldn't
1398 * TODO fool it! We really want this mode also for _HF_NOPUT to be
1399 * TODO able to *gracefully* detect the tag-closing '>', but then if
1400 * TODO that is a single mechanism we should have made it! */
1402 struct htmlflt_tag
const *hftp
= self
->hf_ign_tag
;
1409 } else if (c
== '>') {
1411 if ((i
= PTR2SIZE(cp
- self
->hf_bdat
)) > 1 &&
1412 --i
== hftp
->hft_len
&&
1413 !ascncasecmp(self
->hf_bdat
+ 1, hftp
->hft_tag
, i
))
1414 self
->hf_flags
= (f
&= ~(_HF_IGN
| _HF_NOPUT
));
1420 i
= PTR2SIZE(cp
- self
->hf_bdat
);
1421 if ((i
== 1 && c
!= '/') || --i
> hftp
->hft_len
) {
1428 /* People are using & without &ing it, ditto <; be aware */
1429 if (f
& (_HF_NOPUT
| _HF_ENT
)) {
1431 /* Special case "<!--" buffer content to deal with really weird
1432 * things that can be done with "<!--[if gte mso 9]>" syntax */
1433 if (PTR2SIZE(cp
- self
->hf_bdat
) != 4 ||
1434 memcmp(self
->hf_bdat
, "<!--", 4)) {
1437 self
= _hf_puts(self
, self
->hf_bdat
);
1443 self
->hf_flags
= (f
|= _HF_NOPUT
);
1446 /* Weird tagsoup around, do we actually parse a tag? */
1447 if (!(f
& _HF_NOPUT
))
1451 f
&= ~(_HF_NOPUT
| _HF_ENT
);
1453 self
= _hf_check_tag(self
, self
->hf_bdat
);
1454 *(cp
= self
->hf_bdat
) = '\0'; /* xxx extra safety */
1455 /* Quick hack to get rid of redundant newline after <pre> XXX */
1456 if (!(f
& _HF_PRE
) && (self
->hf_flags
& _HF_PRE
) &&
1457 len
> 1 && *dat
== '\n')
1461 case '\r': /* TODO CR should be stripped in lower level!! (Only B64!?!) */
1464 /* End of line is not considered unless we are in PRE section.
1465 * However, in _HF_NOPUT mode we must be aware of tagsoup which uses
1466 * newlines for separating parameters */
1469 self
= (f
& _HF_PRE
) ? _hf_nl_force(self
) : _hf_putc(self
, ' ');
1478 /* If not currently parsing a tag and bypassing normal output.. */
1479 if (!(f
& _HF_NOPUT
)) {
1485 self
->hf_flags
= (f
|= _HF_NOPUT
| _HF_ENT
);
1486 } else if (f
& _HF_PRE
) {
1487 self
= _hf_putc_premode(self
, c
);
1488 self
->hf_flags
&= ~_HF_BLANK
;
1490 self
= _hf_putc(self
, c
);
1491 } else if ((f
& _HF_ENT
) && c
== ';') {
1494 f
&= ~(_HF_NOPUT
| _HF_ENT
);
1496 self
= _hf_check_ent(self
, self
->hf_bdat
,
1497 PTR2SIZE(cp
+ 1 - self
->hf_bdat
));
1499 /* We may need to grow the buffer */
1500 if (PTRCMP(cp
+ 42/2, >=, cp_max
)) {
1501 size_t i
= PTR2SIZE(cp
- self
->hf_bdat
),
1502 m
= PTR2SIZE(self
->hf_bmax
- self
->hf_bdat
) + LINESIZE
;
1504 cp
= self
->hf_bdat
= srealloc(self
->hf_bdat
, m
);
1505 self
->hf_bmax
= cp
+ m
-1;
1506 self
->hf_curr
= (cp
+= i
);
1515 return (self
->hf_flags
& _HF_ERROR
) ? -1 : rv
;
1519 * TODO Because we don't support filter chains yet this filter will be run
1520 * TODO in a dedicated subprocess, driven via a special Popen() mode
1522 static bool_t __hf_hadpipesig
;
1524 __hf_onpipe(int signo
)
1526 NYD_X
; /* Signal handler */
1528 __hf_hadpipesig
= TRU1
;
1532 htmlflt_process_main(void)
1534 char buf
[BUFFER_SIZE
];
1540 __hf_hadpipesig
= FAL0
;
1541 safe_signal(SIGPIPE
, &__hf_onpipe
);
1544 htmlflt_reset(&hf
, stdout
);
1547 if ((i
= fread(buf
, sizeof(buf
[0]), NELEM(buf
), stdin
)) == 0) {
1552 if ((rv
= __hf_hadpipesig
))
1554 /* Just use this directly.. */
1555 if (htmlflt_push(&hf
, buf
, i
) < 0) {
1560 if (rv
== 0 && htmlflt_flush(&hf
) < 0)
1563 htmlflt_destroy(&hf
);
1565 rv
|= __hf_hadpipesig
;
1571 htmlflt_init(struct htmlflt
*self
)
1574 /* (Rather redundant though) */
1575 memset(self
, 0, sizeof *self
);
1580 htmlflt_destroy(struct htmlflt
*self
)
1583 htmlflt_reset(self
, NULL
);
1588 htmlflt_reset(struct htmlflt
*self
, FILE *f
)
1590 struct htmlflt_href
*hfhp
;
1593 while ((hfhp
= self
->hf_hrefs
) != NULL
) {
1594 self
->hf_hrefs
= hfhp
->hfh_next
;
1598 if (self
->hf_bdat
!= NULL
)
1599 free(self
->hf_bdat
);
1600 if (self
->hf_line
!= NULL
)
1601 free(self
->hf_line
);
1603 memset(self
, 0, sizeof *self
);
1606 ui32_t sw
= MAX(_HF_MINLEN
, (ui32_t
)scrnwidth
);
1608 self
->hf_line
= smalloc((size_t)sw
* mb_cur_max
+1);
1611 if (options
& OPT_UNICODE
) /* TODO not truly generic */
1612 self
->hf_flags
= _HF_UTF8
;
1619 htmlflt_push(struct htmlflt
*self
, char const *dat
, size_t len
)
1624 rv
= _hf_add_data(self
, dat
, len
);
1630 htmlflt_flush(struct htmlflt
*self
)
1635 rv
= _hf_add_data(self
, NULL
, 0);
1636 rv
|= !fflush(self
->hf_os
) ? 0 : -1;
1640 #endif /* HAVE_FILTER_HTML_TAGSOUP */