Support `vput' for `cwd'
[s-mailx.git] / mime.c
blob5c9caccfc62fcfad269b9bb799c7642db6bd2b38
1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ MIME support functions.
3 *@ TODO Complete rewrite.
5 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
6 * Copyright (c) 2012 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
7 */
8 /*
9 * Copyright (c) 2000
10 * Gunnar Ritter. All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. All advertising materials mentioning features or use of this software
21 * must display the following acknowledgement:
22 * This product includes software developed by Gunnar Ritter
23 * and his contributors.
24 * 4. Neither the name of Gunnar Ritter nor the names of his contributors
25 * may be used to endorse or promote products derived from this software
26 * without specific prior written permission.
28 * THIS SOFTWARE IS PROVIDED BY GUNNAR RITTER AND CONTRIBUTORS ``AS IS'' AND
29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 * ARE DISCLAIMED. IN NO EVENT SHALL GUNNAR RITTER OR CONTRIBUTORS BE LIABLE
32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * SUCH DAMAGE.
40 #undef n_FILE
41 #define n_FILE mime
43 #ifndef HAVE_AMALGAMATION
44 # include "nail.h"
45 #endif
47 /* Don't ask, but it keeps body and soul together */
48 enum a_mime_structure_hack{
49 a_MIME_SH_NONE,
50 a_MIME_SH_COMMENT,
51 a_MIME_SH_QUOTE
54 static char *_cs_iter_base, *_cs_iter;
55 #ifdef HAVE_ICONV
56 # define _CS_ITER_GET() \
57 ((_cs_iter != NULL) ? _cs_iter : ok_vlook(CHARSET_8BIT_OKEY))
58 #else
59 # define _CS_ITER_GET() ((_cs_iter != NULL) ? _cs_iter : ok_vlook(ttycharset))
60 #endif
61 #define _CS_ITER_STEP() _cs_iter = n_strsep(&_cs_iter_base, ',', TRU1)
63 /* Is 7-bit enough? */
64 #ifdef HAVE_ICONV
65 static bool_t _has_highbit(char const *s);
66 static bool_t _name_highbit(struct name *np);
67 #endif
69 /* fwrite(3) while checking for displayability */
70 static ssize_t _fwrite_td(struct str const *input, enum tdflags flags,
71 struct str *outrest, struct quoteflt *qf);
73 /* Convert header fields to RFC 2047 format and write to the file fo */
74 static ssize_t mime_write_tohdr(struct str *in, FILE *fo,
75 size_t *colp, enum a_mime_structure_hack msh);
77 /* Write len characters of the passed string to the passed file, doing charset
78 * and header conversion */
80 /* Write an address to a header field */
81 static ssize_t mime_write_tohdr_a(struct str *in, FILE *f,
82 size_t *colp);
83 #ifdef HAVE_ICONV
84 static ssize_t a_mime__convhdra(struct str *inp, FILE *fp, size_t *colp,
85 enum a_mime_structure_hack msh);
86 #else
87 # define a_mime__convhdra(S,F,C,MSH) mime_write_tohdr(S, F, C, MSH)
88 #endif
90 /* Append to buf, handling resizing */
91 static void _append_str(char **buf, size_t *sz, size_t *pos,
92 char const *str, size_t len);
93 static void _append_conv(char **buf, size_t *sz, size_t *pos,
94 char const *str, size_t len);
96 #ifdef HAVE_ICONV
97 static bool_t
98 _has_highbit(char const *s)
100 bool_t rv = TRU1;
101 NYD_ENTER;
103 if (s) {
105 if ((ui8_t)*s & 0x80)
106 goto jleave;
107 while (*s++ != '\0');
109 rv = FAL0;
110 jleave:
111 NYD_LEAVE;
112 return rv;
115 static bool_t
116 _name_highbit(struct name *np)
118 bool_t rv = TRU1;
119 NYD_ENTER;
121 while (np) {
122 if (_has_highbit(np->n_name) || _has_highbit(np->n_fullname))
123 goto jleave;
124 np = np->n_flink;
126 rv = FAL0;
127 jleave:
128 NYD_LEAVE;
129 return rv;
131 #endif /* HAVE_ICONV */
133 static sigjmp_buf __mimefwtd_actjmp; /* TODO someday.. */
134 static int __mimefwtd_sig; /* TODO someday.. */
135 static sighandler_type __mimefwtd_opipe;
136 static void
137 __mimefwtd_onsig(int sig) /* TODO someday, we won't need it no more */
139 NYD_X; /* Signal handler */
140 __mimefwtd_sig = sig;
141 siglongjmp(__mimefwtd_actjmp, 1);
144 static ssize_t
145 _fwrite_td(struct str const *input, enum tdflags flags, struct str *outrest,
146 struct quoteflt *qf)
148 /* TODO note: after send/MIME layer rewrite we will have a string pool
149 * TODO so that memory allocation count drops down massively; for now,
150 * TODO v14.* that is, we pay a lot & heavily depend on the allocator */
151 /* TODO well if we get a broken pipe here, and it happens to
152 * TODO happen pretty easy when sleeping in a full pipe buffer,
153 * TODO then the current codebase performs longjump away;
154 * TODO this leaves memory leaks behind ('think up to 3 per,
155 * TODO dep. upon alloca availability). For this to be fixed
156 * TODO we either need to get rid of the longjmp()s (tm) or
157 * TODO the storage must come from the outside or be tracked
158 * TODO in a carrier struct. Best both. But storage reuse
159 * TODO would be a bigbig win besides */
160 /* *input* _may_ point to non-modifyable buffer; but even then it only
161 * needs to be dup'ed away if we have to transform the content */
162 struct str in, out;
163 ssize_t rv;
164 NYD_ENTER;
165 n_UNUSED(outrest);
167 in = *input;
168 out.s = NULL;
169 out.l = 0;
171 #ifdef HAVE_ICONV
172 if ((flags & TD_ICONV) && iconvd != (iconv_t)-1) {
173 char *buf = NULL;
175 if (outrest != NULL && outrest->l > 0) {
176 in.l = outrest->l + input->l;
177 in.s = buf = smalloc(in.l +1);
178 memcpy(in.s, outrest->s, outrest->l);
179 memcpy(&in.s[outrest->l], input->s, input->l);
180 outrest->l = 0;
183 if (n_iconv_str(iconvd, n_ICONV_UNIDEFAULT, &out, &in, &in) != 0 &&
184 outrest != NULL && in.l > 0) {
185 n_iconv_reset(iconvd);
186 /* Incomplete multibyte at EOF is special */
187 if (flags & _TD_EOF) {
188 out.s = srealloc(out.s, out.l + sizeof(n_unirepl));
189 if(n_psonce & n_PSO_UNICODE){
190 memcpy(&out.s[out.l], n_unirepl, sizeof(n_unirepl) -1);
191 out.l += sizeof(n_unirepl) -1;
192 }else
193 out.s[out.l++] = '?';
194 } else
195 n_str_add(outrest, &in);
197 in = out;
198 out.l = 0;
199 out.s = NULL;
200 flags &= ~_TD_BUFCOPY;
202 if (buf != NULL)
203 free(buf);
204 }else
205 #endif
206 /* Else, if we will modify the data bytes and thus introduce the potential
207 * of messing up multibyte sequences which become splitted over buffer
208 * boundaries TODO and unless we don't have our filter chain which will
209 * TODO make these hacks go by, buffer data until we see a NL */
210 if((flags & (TD_ISPR | TD_DELCTRL)) && outrest != NULL &&
211 #ifdef HAVE_ICONV
212 iconvd == (iconv_t)-1 &&
213 #endif
214 (!(flags & _TD_EOF) || outrest->l > 0)
216 size_t i;
217 char *cp;
219 for (cp = &in.s[in.l]; cp > in.s && cp[-1] != '\n'; --cp)
221 i = PTR2SIZE(cp - in.s);
223 if (i != in.l) {
224 if (i > 0) {
225 n_str_assign_buf(outrest, cp, in.l - i);
226 cp = smalloc(i +1);
227 memcpy(cp, in.s, in.l = i);
228 (in.s = cp)[in.l = i] = '\0';
229 flags &= ~_TD_BUFCOPY;
230 } else {
231 n_str_add_buf(outrest, input->s, input->l);
232 rv = 0;
233 goto jleave;
238 if (flags & TD_ISPR)
239 makeprint(&in, &out);
240 else if (flags & _TD_BUFCOPY)
241 n_str_dup(&out, &in);
242 else
243 out = in;
244 if (flags & TD_DELCTRL)
245 out.l = delctrl(out.s, out.l);
247 __mimefwtd_sig = 0;
248 __mimefwtd_opipe = safe_signal(SIGPIPE, &__mimefwtd_onsig);
249 if (sigsetjmp(__mimefwtd_actjmp, 1)) {
250 rv = 0;
251 goto j__sig;
254 rv = quoteflt_push(qf, out.s, out.l);
256 j__sig:
257 if (out.s != in.s)
258 free(out.s);
259 if (in.s != input->s)
260 free(in.s);
261 safe_signal(SIGPIPE, __mimefwtd_opipe);
262 if (__mimefwtd_sig != 0)
263 n_raise(__mimefwtd_sig);
264 jleave:
265 NYD_LEAVE;
266 return rv;
269 static ssize_t
270 mime_write_tohdr(struct str *in, FILE *fo, size_t *colp,
271 enum a_mime_structure_hack msh)
273 /* TODO mime_write_tohdr(): we don't know the name of our header->maxcol..
274 * TODO MIME/send layer rewrite: more available state!!
275 * TODO Because of this we cannot make a difference in between structured
276 * TODO and unstructured headers (RFC 2047, 5. (2))
277 * TODO This means, e.g., that this gets called multiple times for a
278 * TODO structured header and always starts thinking it is at column 0.
279 * TODO I.e., it may get called for only the content of a comment etc.,
280 * TODO not knowing anything of its context.
281 * TODO Instead we should have a list of header body content tokens,
282 * TODO convert them, and then dump the converted tokens, breaking lines.
283 * TODO I.e., get rid of convhdra, mime_write_tohdr_a and such...
284 * TODO Somewhen, the following should produce smooth stuff:
285 * TODO ' "Hallo\"," Dr. Backe "Bl\"ö\"d" (Gell) <ha@llöch.en>
286 * TODO "Nochm\"a\"l"<ta@tu.da>(Dümm)'
287 * TODO NOT MULTIBYTE SAFE IF AN ENCODED WORD HAS TO BE SPLITTED!
288 * TODO To be better we had to mbtowc_l() (non-std! and no locale!!) and
289 * TODO work char-wise! -> S-CText..
290 * TODO The real problem for STD compatibility is however that "in" is
291 * TODO already iconv(3) encoded to the target character set! We could
292 * TODO also solve it (very expensively!) if we would narrow down to an
293 * TODO encoded word and then iconv(3)+MIME encode in one go, in which
294 * TODO case multibyte errors could be catched! */
295 enum {
296 /* Maximum line length */
297 a_MAXCOL_NENC = MIME_LINELEN,
298 a_MAXCOL = MIME_LINELEN_RFC2047
301 struct str cout, cin;
302 enum {
303 _FIRST = 1<<0, /* Nothing written yet, start of string */
304 _MSH_NOTHING = 1<<1, /* Now, really: nothing at all has been written */
305 a_ANYENC = 1<<2, /* We have RFC 2047 anything at least once */
306 _NO_QP = 1<<3, /* No quoted-printable allowed */
307 _NO_B64 = 1<<4, /* Ditto, base64 */
308 _ENC_LAST = 1<<5, /* Last round generated encoded word */
309 _SHOULD_BEE = 1<<6, /* Avoid lines longer than SHOULD via encoding */
310 _RND_SHIFT = 7,
311 _RND_MASK = (1<<_RND_SHIFT) - 1,
312 _SPACE = 1<<(_RND_SHIFT+1), /* Leading whitespace */
313 _8BIT = 1<<(_RND_SHIFT+2), /* High bit set */
314 _ENCODE = 1<<(_RND_SHIFT+3), /* Need encoding */
315 _ENC_B64 = 1<<(_RND_SHIFT+4), /* - let it be base64 */
316 _OVERLONG = 1<<(_RND_SHIFT+5) /* Temporarily rised limit */
317 } flags;
318 char const *cset7, *cset8, *wbot, *upper, *wend, *wcur;
319 ui32_t cset7_len, cset8_len;
320 size_t col, i, j;
321 ssize_t sz;
323 NYD_ENTER;
325 cout.s = NULL, cout.l = 0;
326 cset7 = ok_vlook(charset_7bit);
327 cset7_len = (ui32_t)strlen(cset7);
328 cset8 = _CS_ITER_GET(); /* TODO MIME/send layer: iter active? iter! else */
329 cset8_len = (ui32_t)strlen(cset8);
331 flags = _FIRST;
332 if(msh != a_MIME_SH_NONE)
333 flags |= _MSH_NOTHING;
335 /* RFC 1468, "MIME Considerations":
336 * ISO-2022-JP may also be used in MIME Part 2 headers. The "B"
337 * encoding should be used with ISO-2022-JP text. */
338 /* TODO of course, our current implementation won't deal properly with
339 * TODO any stateful encoding at all... (the standard says each encoded
340 * TODO word must include all necessary reset sequences..., i.e., each
341 * TODO encoded word must be a self-contained iconv(3) life cycle) */
342 if (!asccasecmp(cset8, "iso-2022-jp") || mime_enc_target() == MIMEE_B64)
343 flags |= _NO_QP;
345 wbot = in->s;
346 upper = wbot + in->l;
348 if(colp == NULL || (col = *colp) == 0)
349 col = sizeof("Mail-Followup-To: ") -1; /* dreadful thing */
351 for (sz = 0; wbot < upper; flags &= ~_FIRST, wbot = wend) {
352 flags &= _RND_MASK;
353 wcur = wbot;
354 while (wcur < upper && whitechar(*wcur)) {
355 flags |= _SPACE;
356 ++wcur;
359 /* Any occurrence of whitespace resets prevention of lines >SHOULD via
360 * enforced encoding (xxx SHOULD, but.. encoding is expensive!!) */
361 if (flags & _SPACE)
362 flags &= ~_SHOULD_BEE;
364 /* Data ends with WS - dump it and done.
365 * Also, if we have seen multiple successive whitespace characters, then
366 * if there was no encoded word last, i.e., if we can simply take them
367 * over to the output as-is, keep one WS for possible later separation
368 * purposes and simply print the others as-is, directly! */
369 if (wcur == upper) {
370 wend = wcur;
371 goto jnoenc_putws;
373 if ((flags & (_ENC_LAST | _SPACE)) == _SPACE && wcur - wbot > 1) {
374 wend = wcur - 1;
375 goto jnoenc_putws;
378 /* Skip over a word to next non-whitespace, keep track along the way
379 * whether our 7-bit charset suffices to represent the data */
380 for (wend = wcur; wend < upper; ++wend) {
381 if (whitechar(*wend))
382 break;
383 if ((uc_i)*wend & 0x80)
384 flags |= _8BIT;
387 /* Decide whether the range has to become encoded or not */
388 i = PTR2SIZE(wend - wcur);
389 j = mime_enc_mustquote(wcur, i, MIMEEF_ISHEAD);
390 /* If it just cannot fit on a SHOULD line length, force encode */
391 if (i > a_MAXCOL_NENC) {
392 flags |= _SHOULD_BEE; /* (Sigh: SHOULD only, not MUST..) */
393 goto j_beejump;
395 if ((flags & _SHOULD_BEE) || j > 0) {
396 j_beejump:
397 flags |= _ENCODE;
398 /* Use base64 if requested or more than 50% -37.5-% of the bytes of
399 * the string need to be encoded */
400 if ((flags & _NO_QP) || j >= i >> 1)/*(i >> 2) + (i >> 3))*/
401 flags |= _ENC_B64;
403 DBG( if (flags & _8BIT) assert(flags & _ENCODE); )
405 if (!(flags & _ENCODE)) {
406 /* Encoded word produced, but no linear whitespace for necessary RFC
407 * 2047 separation? Generate artificial data (bad standard!) */
408 if ((flags & (_ENC_LAST | _SPACE)) == _ENC_LAST) {
409 if (col >= a_MAXCOL) {
410 putc('\n', fo);
411 ++sz;
412 col = 0;
414 if(flags & _MSH_NOTHING){
415 flags &= ~_MSH_NOTHING;
416 putc((msh == a_MIME_SH_COMMENT ? '(' : '"'), fo);
417 ++sz;
418 ++col;
420 putc(' ', fo);
421 ++sz;
422 ++col;
425 jnoenc_putws:
426 flags &= ~_ENC_LAST;
428 /* todo No effort here: (1) v15.0 has to bring complete rewrite,
429 * todo (2) the standard is braindead and (3) usually this is one
430 * todo word only, and why be smarter than the standard? */
431 jnoenc_retry:
432 i = PTR2SIZE(wend - wbot);
433 if (i + col + ((flags & _MSH_NOTHING) != 0) <=
434 (flags & _OVERLONG ? MIME_LINELEN_MAX
435 : (flags & a_ANYENC ? a_MAXCOL : a_MAXCOL_NENC))) {
436 if(flags & _MSH_NOTHING){
437 flags &= ~_MSH_NOTHING;
438 putc((msh == a_MIME_SH_COMMENT ? '(' : '"'), fo);
439 ++sz;
440 ++col;
442 i = fwrite(wbot, sizeof *wbot, i, fo);
443 sz += i;
444 col += i;
445 continue;
448 /* Doesn't fit, try to break the line first; */
449 if (col > 1) {
450 putc('\n', fo);
451 if (whitechar(*wbot)) {
452 putc((uc_i)*wbot, fo);
453 ++wbot;
454 } else
455 putc(' ', fo); /* Bad standard: artificial data! */
456 sz += 2;
457 col = 1;
458 if(flags & _MSH_NOTHING){
459 flags &= ~_MSH_NOTHING;
460 putc((msh == a_MIME_SH_COMMENT ? '(' : '"'), fo);
461 ++sz;
462 ++col;
464 flags |= _OVERLONG;
465 goto jnoenc_retry;
468 /* It is so long that it needs to be broken, effectively causing
469 * artificial spaces to be inserted (bad standard), yuck */
470 /* todo This is not multibyte safe, as above; and completely stupid
471 * todo P.S.: our _SHOULD_BEE prevents these cases in the meanwhile */
472 /* FIXME n_PSO_UNICODE and parse using UTF-8 sync possibility! */
473 wcur = wbot + MIME_LINELEN_MAX - 8;
474 while (wend > wcur)
475 wend -= 4;
476 goto jnoenc_retry;
477 } else {
478 /* Encoding to encoded word(s); deal with leading whitespace, place
479 * a separator first as necessary: encoded words must always be
480 * separated from text and other encoded words with linear WS.
481 * And if an encoded word was last, intermediate whitespace must
482 * also be encoded, otherwise it would get stripped away! */
483 wcur = n_UNCONST(n_empty);
484 if ((flags & (_ENC_LAST | _SPACE)) != _SPACE) {
485 /* Reinclude whitespace */
486 flags &= ~_SPACE;
487 /* We don't need to place a separator at the very beginning */
488 if (!(flags & _FIRST))
489 wcur = n_UNCONST(" ");
490 } else
491 wcur = wbot++;
493 flags |= a_ANYENC | _ENC_LAST;
494 n_pstate |= n_PS_HEADER_NEEDED_MIME;
496 /* RFC 2047:
497 * An 'encoded-word' may not be more than 75 characters long,
498 * including 'charset', 'encoding', 'encoded-text', and
499 * delimiters. If it is desirable to encode more text than will
500 * fit in an 'encoded-word' of 75 characters, multiple
501 * 'encoded-word's (separated by CRLF SPACE) may be used.
503 * While there is no limit to the length of a multiple-line
504 * header field, each line of a header field that contains one
505 * or more 'encoded-word's is limited to 76 characters */
506 jenc_retry:
507 cin.s = n_UNCONST(wbot);
508 cin.l = PTR2SIZE(wend - wbot);
510 /* C99 */{
511 struct str *xout;
513 if(flags & _ENC_B64)
514 xout = b64_encode(&cout, &cin, B64_ISHEAD | B64_ISENCWORD);
515 else
516 xout = qp_encode(&cout, &cin, QP_ISHEAD | QP_ISENCWORD);
517 if(xout == NULL){
518 sz = -1;
519 break;
521 j = xout->l;
523 /* (Avoid trigraphs in the RFC 2047 placeholder..) */
524 i = j + (flags & _8BIT ? cset8_len : cset7_len) + sizeof("=!!B!!=") -1;
525 if (*wcur != '\0')
526 ++i;
528 jenc_retry_same:
529 /* Unfortunately RFC 2047 explicitly disallows encoded words to be
530 * longer (just like RFC 5322's "a line SHOULD fit in 78 but MAY be
531 * 998 characters long"), so we cannot use the _OVERLONG mechanism,
532 * even though all tested mailers seem to support it */
533 if (i + col <= (/*flags & _OVERLONG ? MIME_LINELEN_MAX :*/ a_MAXCOL)) {
534 if(flags & _MSH_NOTHING){
535 flags &= ~_MSH_NOTHING;
536 putc((msh == a_MIME_SH_COMMENT ? '(' : '"'), fo);
537 ++sz;
538 ++col;
540 fprintf(fo, "%.1s=?%s?%c?%.*s?=",
541 wcur, (flags & _8BIT ? cset8 : cset7),
542 (flags & _ENC_B64 ? 'B' : 'Q'),
543 (int)cout.l, cout.s);
544 sz += i;
545 col += i;
546 continue;
549 /* Doesn't fit, try to break the line first */
550 /* TODO I've commented out the _FIRST test since we (1) cannot do
551 * TODO _OVERLONG since (MUAs support but) the standard disallows,
552 * TODO and because of our iconv problem i prefer an empty first line
553 * TODO in favour of a possibly messed up multibytes character. :-( */
554 if (col > 1 /* TODO && !(flags & _FIRST)*/) {
555 putc('\n', fo);
556 sz += 2;
557 col = 1;
558 if (!(flags & _SPACE)) {
559 putc(' ', fo);
560 wcur = n_UNCONST(n_empty);
561 /*flags |= _OVERLONG;*/
562 goto jenc_retry_same;
563 } else {
564 putc((uc_i)*wcur, fo);
565 if (whitechar(*(wcur = wbot)))
566 ++wbot;
567 else {
568 flags &= ~_SPACE;
569 wcur = n_UNCONST(n_empty);
571 /*flags &= ~_OVERLONG;*/
572 goto jenc_retry;
576 /* It is so long that it needs to be broken, effectively causing
577 * artificial data to be inserted (bad standard), yuck */
578 /* todo This is not multibyte safe, as above */
579 /*if (!(flags & _OVERLONG)) { Mechanism explicitly forbidden by 2047
580 flags |= _OVERLONG;
581 goto jenc_retry;
584 /* FIXME n_PSO_UNICODE and parse using UTF-8 sync possibility! */
585 i = PTR2SIZE(wend - wbot) + !!(flags & _SPACE);
586 j = 3 + !(flags & _ENC_B64);
587 for (;;) {
588 wend -= j;
589 i -= j;
590 /* (Note the problem most likely is the transfer-encoding blow,
591 * which is why we test this *after* the decrements.. */
592 if (i <= a_MAXCOL)
593 break;
595 goto jenc_retry;
599 if(!(flags & _MSH_NOTHING) && msh != a_MIME_SH_NONE){
600 putc((msh == a_MIME_SH_COMMENT ? ')' : '"'), fo);
601 ++sz;
602 ++col;
605 if (cout.s != NULL)
606 free(cout.s);
608 if(colp != NULL)
609 *colp = col;
610 NYD_LEAVE;
611 return sz;
614 static ssize_t
615 mime_write_tohdr_a(struct str *in, FILE *f, size_t *colp)
617 struct str xin;
618 size_t i;
619 char const *cp, *lastcp;
620 ssize_t sz, x;
621 NYD_ENTER;
623 in->s[in->l] = '\0';
624 lastcp = in->s;
625 if((cp = routeaddr(in->s)) != NULL && cp > lastcp) {
626 xin.s = in->s;
627 xin.l = PTR2SIZE(cp - in->s);
628 if ((sz = mime_write_tohdr_a(&xin, f, colp)) < 0)
629 goto jleave;
630 xin.s[xin.l] = '<';
631 lastcp = cp;
632 } else {
633 cp = in->s;
634 sz = 0;
637 for( ; *cp != '\0'; ++cp){
638 switch(*cp){
639 case '(':
640 i = PTR2SIZE(cp - lastcp);
641 if(i > 0){
642 if(fwrite(lastcp, 1, i, f) != i)
643 goto jerr;
644 sz += i;
646 lastcp = ++cp;
647 cp = skip_comment(cp);
648 if(--cp > lastcp){
649 i = PTR2SIZE(cp - lastcp);
650 xin.s = n_UNCONST(lastcp);
651 xin.l = i;
652 if ((x = a_mime__convhdra(&xin, f, colp, a_MIME_SH_COMMENT)) < 0)
653 goto jerr;
654 sz += x;
656 lastcp = &cp[1];
657 break;
658 case '"':
659 i = PTR2SIZE(cp - lastcp);
660 if(i > 0){
661 if(fwrite(lastcp, 1, i, f) != i)
662 goto jerr;
663 sz += i;
665 for(lastcp = ++cp; *cp != '\0'; ++cp){
666 if(*cp == '"')
667 break;
668 if(*cp == '\\' && cp[1] != '\0')
669 ++cp;
671 i = PTR2SIZE(cp - lastcp);
672 if(i > 0){
673 xin.s = n_UNCONST(lastcp);
674 xin.l = i;
675 if((x = a_mime__convhdra(&xin, f, colp, a_MIME_SH_QUOTE)) < 0)
676 goto jerr;
677 sz += x;
679 ++sz;
680 lastcp = &cp[1];
681 break;
685 i = PTR2SIZE(cp - lastcp);
686 if(i > 0){
687 if(fwrite(lastcp, 1, i, f) != i)
688 goto jerr;
689 sz += i;
691 jleave:
692 NYD_LEAVE;
693 return sz;
694 jerr:
695 sz = -1;
696 goto jleave;
699 #ifdef HAVE_ICONV
700 static ssize_t
701 a_mime__convhdra(struct str *inp, FILE *fp, size_t *colp,
702 enum a_mime_structure_hack msh){
703 struct str ciconv;
704 ssize_t rv;
705 NYD_ENTER;
707 rv = 0;
708 ciconv.s = NULL;
710 if(iconvd != (iconv_t)-1){
711 ciconv.l = 0;
712 if(n_iconv_str(iconvd, n_ICONV_IGN_NOREVERSE, &ciconv, inp, NULL) != 0){
713 n_iconv_reset(iconvd);
714 goto jleave;
716 *inp = ciconv;
719 rv = mime_write_tohdr(inp, fp, colp, msh);
720 jleave:
721 if(ciconv.s != NULL)
722 free(ciconv.s);
723 NYD_LEAVE;
724 return rv;
726 #endif /* HAVE_ICONV */
728 static void
729 _append_str(char **buf, size_t *sz, size_t *pos, char const *str, size_t len)
731 NYD_ENTER;
732 *buf = srealloc(*buf, *sz += len);
733 memcpy(&(*buf)[*pos], str, len);
734 *pos += len;
735 NYD_LEAVE;
738 static void
739 _append_conv(char **buf, size_t *sz, size_t *pos, char const *str, size_t len)
741 struct str in, out;
742 NYD_ENTER;
744 in.s = n_UNCONST(str);
745 in.l = len;
746 mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
747 _append_str(buf, sz, pos, out.s, out.l);
748 free(out.s);
749 NYD_LEAVE;
752 FL bool_t
753 charset_iter_reset(char const *a_charset_to_try_first) /* TODO elim. dups! */
755 char const *sarr[3];
756 size_t sarrl[3], len;
757 char *cp;
758 NYD_ENTER;
759 n_UNUSED(a_charset_to_try_first);
761 #ifdef HAVE_ICONV
762 sarr[2] = ok_vlook(CHARSET_8BIT_OKEY);
764 if(a_charset_to_try_first != NULL && strcmp(a_charset_to_try_first, sarr[2]))
765 sarr[0] = a_charset_to_try_first;
766 else
767 sarr[0] = NULL;
769 if((sarr[1] = ok_vlook(sendcharsets)) == NULL &&
770 ok_blook(sendcharsets_else_ttycharset)){
771 cp = n_UNCONST(ok_vlook(ttycharset));
772 if(strcmp(cp, sarr[2]) && (sarr[0] == NULL || strcmp(cp, sarr[0])))
773 sarr[1] = cp;
775 #else
776 sarr[2] = ok_vlook(ttycharset);
777 #endif
779 sarrl[2] = len = strlen(sarr[2]);
780 #ifdef HAVE_ICONV
781 if ((cp = n_UNCONST(sarr[1])) != NULL)
782 len += (sarrl[1] = strlen(cp));
783 else
784 sarrl[1] = 0;
785 if ((cp = n_UNCONST(sarr[0])) != NULL)
786 len += (sarrl[0] = strlen(cp));
787 else
788 sarrl[0] = 0;
789 #endif
791 _cs_iter_base = cp = salloc(len + 1 + 1 +1);
793 #ifdef HAVE_ICONV
794 if ((len = sarrl[0]) != 0) {
795 memcpy(cp, sarr[0], len);
796 cp[len] = ',';
797 cp += ++len;
799 if ((len = sarrl[1]) != 0) {
800 memcpy(cp, sarr[1], len);
801 cp[len] = ',';
802 cp += ++len;
804 #endif
805 len = sarrl[2];
806 memcpy(cp, sarr[2], len);
807 cp[len] = '\0';
809 _CS_ITER_STEP();
810 NYD_LEAVE;
811 return (_cs_iter != NULL);
814 FL bool_t
815 charset_iter_next(void)
817 bool_t rv;
818 NYD_ENTER;
820 _CS_ITER_STEP();
821 rv = (_cs_iter != NULL);
822 NYD_LEAVE;
823 return rv;
826 FL bool_t
827 charset_iter_is_valid(void)
829 bool_t rv;
830 NYD_ENTER;
832 rv = (_cs_iter != NULL);
833 NYD_LEAVE;
834 return rv;
837 FL char const *
838 charset_iter(void)
840 char const *rv;
841 NYD_ENTER;
843 rv = _cs_iter;
844 NYD_LEAVE;
845 return rv;
848 FL char const *
849 charset_iter_or_fallback(void)
851 char const *rv;
852 NYD_ENTER;
854 rv = _CS_ITER_GET();
855 NYD_LEAVE;
856 return rv;
859 FL void
860 charset_iter_recurse(char *outer_storage[2]) /* TODO LEGACY FUN, REMOVE */
862 NYD_ENTER;
863 outer_storage[0] = _cs_iter_base;
864 outer_storage[1] = _cs_iter;
865 NYD_LEAVE;
868 FL void
869 charset_iter_restore(char *outer_storage[2]) /* TODO LEGACY FUN, REMOVE */
871 NYD_ENTER;
872 _cs_iter_base = outer_storage[0];
873 _cs_iter = outer_storage[1];
874 NYD_LEAVE;
877 #ifdef HAVE_ICONV
878 FL char const *
879 need_hdrconv(struct header *hp) /* TODO once only, then iter */
881 struct n_header_field *hfp;
882 char const *rv;
883 NYD_ENTER;
885 rv = NULL;
887 if((hfp = hp->h_user_headers) != NULL)
888 do if(_has_highbit(hfp->hf_dat + hfp->hf_nl +1))
889 goto jneeds;
890 while((hfp = hfp->hf_next) != NULL);
892 if((hfp = hp->h_custom_headers) != NULL ||
893 (hp->h_custom_headers = hfp = n_customhdr_query()) != NULL)
894 do if(_has_highbit(hfp->hf_dat + hfp->hf_nl +1))
895 goto jneeds;
896 while((hfp = hfp->hf_next) != NULL);
898 if (hp->h_mft != NULL) {
899 if (_name_highbit(hp->h_mft))
900 goto jneeds;
902 if (hp->h_from != NULL) {
903 if (_name_highbit(hp->h_from))
904 goto jneeds;
905 } else if (_has_highbit(myaddrs(NULL)))
906 goto jneeds;
907 if (hp->h_replyto) {
908 if (_name_highbit(hp->h_replyto))
909 goto jneeds;
910 } else if (_has_highbit(ok_vlook(replyto)))
911 goto jneeds;
912 if (hp->h_sender) {
913 if (_name_highbit(hp->h_sender))
914 goto jneeds;
915 } else if (_has_highbit(ok_vlook(sender)))
916 goto jneeds;
918 if (_name_highbit(hp->h_to))
919 goto jneeds;
920 if (_name_highbit(hp->h_cc))
921 goto jneeds;
922 if (_name_highbit(hp->h_bcc))
923 goto jneeds;
924 if (_has_highbit(hp->h_subject))
925 jneeds:
926 rv = _CS_ITER_GET(); /* TODO MIME/send: iter active? iter! else */
927 NYD_LEAVE;
928 return rv;
930 #endif /* HAVE_ICONV */
932 FL void
933 mime_fromhdr(struct str const *in, struct str *out, enum tdflags flags)
935 /* TODO mime_fromhdr(): is called with strings that contain newlines;
936 * TODO this is the usual newline problem all around the codebase;
937 * TODO i.e., if we strip it, then the display misses it ;>
938 * TODO this is why it is so messy and why S-nail v14.2 plus additional
939 * TODO patch for v14.5.2 (and maybe even v14.5.3 subminor) occurred, and
940 * TODO why our display reflects what is contained in the message: the 1:1
941 * TODO relationship of message content and display!
942 * TODO instead a header line should be decoded to what it is (a single
943 * TODO line that is) and it should be objective to the backend whether
944 * TODO it'll be folded to fit onto the display or not, e.g., for search
945 * TODO purposes etc. then the only condition we have to honour in here
946 * TODO is that whitespace in between multiple adjacent MIME encoded words
947 * TODO á la RFC 2047 is discarded; i.e.: this function should deal with
948 * TODO RFC 2047 and be renamed: mime_fromhdr() -> mime_rfc2047_decode() */
949 struct str cin, cout;
950 char *p, *op, *upper;
951 ui32_t convert, lastenc, lastoutl;
952 #ifdef HAVE_ICONV
953 char const *tcs;
954 char *cbeg;
955 iconv_t fhicd = (iconv_t)-1;
956 #endif
957 NYD_ENTER;
959 out->l = 0;
960 if (in->l == 0) {
961 *(out->s = smalloc(1)) = '\0';
962 goto jleave;
964 out->s = NULL;
966 #ifdef HAVE_ICONV
967 tcs = ok_vlook(ttycharset);
968 #endif
969 p = in->s;
970 upper = p + in->l;
971 lastenc = lastoutl = 0;
973 while (p < upper) {
974 op = p;
975 if (*p == '=' && *(p + 1) == '?') {
976 p += 2;
977 #ifdef HAVE_ICONV
978 cbeg = p;
979 #endif
980 while (p < upper && *p != '?')
981 ++p; /* strip charset */
982 if (p >= upper)
983 goto jnotmime;
984 ++p;
985 #ifdef HAVE_ICONV
986 if (flags & TD_ICONV) {
987 size_t i = PTR2SIZE(p - cbeg);
988 char *ltag, *cs = ac_alloc(i);
990 memcpy(cs, cbeg, --i);
991 cs[i] = '\0';
992 /* RFC 2231 extends the RFC 2047 character set definition in
993 * encoded words by language tags - silently strip those off */
994 if ((ltag = strchr(cs, '*')) != NULL)
995 *ltag = '\0';
997 if (fhicd != (iconv_t)-1)
998 n_iconv_close(fhicd);
999 fhicd = asccasecmp(cs, tcs) ? n_iconv_open(tcs, cs) : (iconv_t)-1;
1000 ac_free(cs);
1002 #endif
1003 switch (*p) {
1004 case 'B': case 'b':
1005 convert = CONV_FROMB64;
1006 break;
1007 case 'Q': case 'q':
1008 convert = CONV_FROMQP;
1009 break;
1010 default: /* invalid, ignore */
1011 goto jnotmime;
1013 if (*++p != '?')
1014 goto jnotmime;
1015 cin.s = ++p;
1016 cin.l = 1;
1017 for (;;) {
1018 if (PTRCMP(p + 1, >=, upper))
1019 goto jnotmime;
1020 if (*p++ == '?' && *p == '=')
1021 break;
1022 ++cin.l;
1024 ++p;
1025 --cin.l;
1027 cout.s = NULL;
1028 cout.l = 0;
1029 if (convert == CONV_FROMB64) {
1030 if(!b64_decode_header(&cout, &cin))
1031 n_str_assign_cp(&cout, _("[Invalid Base64 encoding]"));
1032 }else if(!qp_decode_header(&cout, &cin))
1033 n_str_assign_cp(&cout, _("[Invalid Quoted-Printable encoding]"));
1035 out->l = lastenc;
1036 #ifdef HAVE_ICONV
1037 if ((flags & TD_ICONV) && fhicd != (iconv_t)-1) {
1038 cin.s = NULL, cin.l = 0; /* XXX string pool ! */
1039 convert = n_iconv_str(fhicd, n_ICONV_UNIDEFAULT, &cin, &cout, NULL);
1040 out = n_str_add(out, &cin);
1041 if (convert) {/* EINVAL at EOS */
1042 n_iconv_reset(fhicd);
1043 out = n_str_add_buf(out, "?", 1); /* TODO unicode replacement */
1045 free(cin.s);
1046 } else
1047 #endif
1048 out = n_str_add(out, &cout);
1049 lastenc = lastoutl = out->l;
1050 free(cout.s);
1051 } else
1052 jnotmime: {
1053 bool_t onlyws;
1055 p = op;
1056 onlyws = (lastenc > 0);
1057 for (;;) {
1058 if (++op == upper)
1059 break;
1060 if (op[0] == '=' && (PTRCMP(op + 1, ==, upper) || op[1] == '?'))
1061 break;
1062 if (onlyws && !blankchar(*op))
1063 onlyws = FAL0;
1066 out = n_str_add_buf(out, p, PTR2SIZE(op - p));
1067 p = op;
1068 if (!onlyws || lastoutl != lastenc)
1069 lastenc = out->l;
1070 lastoutl = out->l;
1073 out->s[out->l] = '\0';
1075 if (flags & TD_ISPR) {
1076 makeprint(out, &cout);
1077 free(out->s);
1078 *out = cout;
1080 if (flags & TD_DELCTRL)
1081 out->l = delctrl(out->s, out->l);
1082 #ifdef HAVE_ICONV
1083 if (fhicd != (iconv_t)-1)
1084 n_iconv_close(fhicd);
1085 #endif
1086 jleave:
1087 NYD_LEAVE;
1088 return;
1091 FL char *
1092 mime_fromaddr(char const *name)
1094 char const *cp, *lastcp;
1095 char *res = NULL;
1096 size_t ressz = 1, rescur = 0;
1097 NYD_ENTER;
1099 if (name == NULL)
1100 goto jleave;
1101 if (*name == '\0') {
1102 res = savestr(name);
1103 goto jleave;
1106 if ((cp = routeaddr(name)) != NULL && cp > name) {
1107 _append_conv(&res, &ressz, &rescur, name, PTR2SIZE(cp - name));
1108 lastcp = cp;
1109 } else
1110 cp = lastcp = name;
1112 for ( ; *cp; ++cp) {
1113 switch (*cp) {
1114 case '(':
1115 _append_str(&res, &ressz, &rescur, lastcp, PTR2SIZE(cp - lastcp + 1));
1116 lastcp = ++cp;
1117 cp = skip_comment(cp);
1118 if (--cp > lastcp)
1119 _append_conv(&res, &ressz, &rescur, lastcp, PTR2SIZE(cp - lastcp));
1120 lastcp = cp;
1121 break;
1122 case '"':
1123 while (*cp) {
1124 if (*++cp == '"')
1125 break;
1126 if (*cp == '\\' && cp[1] != '\0')
1127 ++cp;
1129 break;
1132 if (cp > lastcp)
1133 _append_str(&res, &ressz, &rescur, lastcp, PTR2SIZE(cp - lastcp));
1134 /* TODO rescur==0: inserted to silence Coverity ...; check that */
1135 if (rescur == 0)
1136 res = n_UNCONST(n_empty);
1137 else
1138 res[rescur] = '\0';
1139 { char *x = res;
1140 res = savestr(res);
1141 free(x);
1143 jleave:
1144 NYD_LEAVE;
1145 return res;
1148 FL ssize_t
1149 xmime_write(char const *ptr, size_t size, FILE *f, enum conversion convert,
1150 enum tdflags dflags)
1152 ssize_t rv;
1153 struct quoteflt *qf;
1154 NYD_ENTER;
1156 quoteflt_reset(qf = quoteflt_dummy(), f);
1157 rv = mime_write(ptr, size, f, convert, dflags, qf, NULL, NULL);
1158 quoteflt_flush(qf);
1159 NYD_LEAVE;
1160 return rv;
1163 static sigjmp_buf __mimemw_actjmp; /* TODO someday.. */
1164 static int __mimemw_sig; /* TODO someday.. */
1165 static sighandler_type __mimemw_opipe;
1166 static void
1167 __mimemw_onsig(int sig) /* TODO someday, we won't need it no more */
1169 NYD_X; /* Signal handler */
1170 __mimemw_sig = sig;
1171 siglongjmp(__mimemw_actjmp, 1);
1174 FL ssize_t
1175 mime_write(char const *ptr, size_t size, FILE *f,
1176 enum conversion convert, enum tdflags volatile dflags,
1177 struct quoteflt *qf, struct str * volatile outrest,
1178 struct str * volatile inrest)
1180 /* TODO note: after send/MIME layer rewrite we will have a string pool
1181 * TODO so that memory allocation count drops down massively; for now,
1182 * TODO v14.0 that is, we pay a lot & heavily depend on the allocator */
1183 struct str in, out;
1184 ssize_t volatile sz;
1185 NYD_ENTER;
1187 dflags |= _TD_BUFCOPY;
1188 in.s = n_UNCONST(ptr);
1189 in.l = size;
1191 if(inrest != NULL && inrest->l > 0){
1192 out.s = smalloc(inrest->l + size + 1);
1193 memcpy(out.s, inrest->s, inrest->l);
1194 if(size > 0)
1195 memcpy(&out.s[inrest->l], in.s, size);
1196 size += inrest->l;
1197 inrest->l = 0;
1198 (in.s = out.s)[in.l = size] = '\0';
1199 dflags &= ~_TD_BUFCOPY;
1202 out.s = NULL;
1203 out.l = 0;
1205 if ((sz = size) == 0) {
1206 if (outrest != NULL && outrest->l != 0)
1207 goto jconvert;
1208 goto jleave;
1211 #ifdef HAVE_ICONV
1212 if ((dflags & TD_ICONV) && iconvd != (iconv_t)-1 &&
1213 (convert == CONV_TOQP || convert == CONV_8BIT ||
1214 convert == CONV_TOB64 || convert == CONV_TOHDR)) {
1215 if (n_iconv_str(iconvd, n_ICONV_IGN_NOREVERSE, &out, &in, NULL) != 0) {
1216 n_iconv_reset(iconvd);
1217 /* TODO This causes hard-failure. We would need to have an action
1218 * TODO policy FAIL|IGNORE|SETERROR(but continue). Better huh? */
1219 sz = -1;
1220 goto jleave;
1222 in = out;
1223 out.s = NULL;
1224 dflags &= ~_TD_BUFCOPY;
1226 #endif
1228 jconvert:
1229 __mimemw_sig = 0;
1230 __mimemw_opipe = safe_signal(SIGPIPE, &__mimemw_onsig);
1231 if (sigsetjmp(__mimemw_actjmp, 1))
1232 goto jleave;
1234 switch (convert) {
1235 case CONV_FROMQP:
1236 if(!qp_decode_part(&out, &in, outrest, inrest)){
1237 n_err(_("Invalid Quoted-Printable encoding ignored\n"));
1238 sz = 0; /* TODO sz = -1 stops outer levels! */
1239 break;
1241 goto jqpb64_dec;
1242 case CONV_TOQP:
1243 if(qp_encode(&out, &in, QP_NONE) == NULL){
1244 sz = 0; /* TODO sz = -1 stops outer levels! */
1245 break;
1247 goto jqpb64_enc;
1248 case CONV_8BIT:
1249 sz = quoteflt_push(qf, in.s, in.l);
1250 break;
1251 case CONV_FROMB64:
1252 if(!b64_decode_part(&out, &in, outrest, inrest))
1253 goto jeb64;
1254 outrest = NULL;
1255 if(0){
1256 /* FALLTHRU */
1257 case CONV_FROMB64_T:
1258 if(!b64_decode_part(&out, &in, outrest, inrest)){
1259 jeb64:
1260 n_err(_("Invalid Base64 encoding ignored\n"));
1261 sz = 0; /* TODO sz = -1 stops outer levels! */
1262 break;
1265 jqpb64_dec:
1266 if ((sz = out.l) != 0) {
1267 ui32_t opl = qf->qf_pfix_len;
1268 sz = _fwrite_td(&out, (dflags & ~_TD_BUFCOPY), outrest, qf);
1269 qf->qf_pfix_len = opl;
1271 break;
1272 case CONV_TOB64:
1273 if(b64_encode(&out, &in, B64_LF | B64_MULTILINE) == NULL){
1274 sz = -1;
1275 break;
1277 jqpb64_enc:
1278 sz = fwrite(out.s, sizeof *out.s, out.l, f);
1279 if (sz != (ssize_t)out.l)
1280 sz = -1;
1281 break;
1282 case CONV_FROMHDR:
1283 mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV | (dflags & TD_DELCTRL));
1284 sz = quoteflt_push(qf, out.s, out.l);
1285 break;
1286 case CONV_TOHDR:
1287 sz = mime_write_tohdr(&in, f, NULL, a_MIME_SH_NONE);
1288 break;
1289 case CONV_TOHDR_A:{
1290 size_t col;
1292 if(dflags & _TD_BUFCOPY){
1293 n_str_dup(&out, &in);
1294 in = out;
1295 out.s = NULL;
1296 dflags &= ~_TD_BUFCOPY;
1298 col = 0;
1299 sz = mime_write_tohdr_a(&in, f, &col);
1300 } break;
1301 default:
1302 sz = _fwrite_td(&in, dflags, NULL, qf);
1303 break;
1305 jleave:
1306 if (out.s != NULL)
1307 free(out.s);
1308 if (in.s != ptr)
1309 free(in.s);
1310 safe_signal(SIGPIPE, __mimemw_opipe);
1311 if (__mimemw_sig != 0)
1312 n_raise(__mimemw_sig);
1313 NYD_LEAVE;
1314 return sz;
1317 /* s-it-mode */