filter.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Filter objects.
   3  *
   4  * Copyright (c) 2013 - 2014 Steffen "Daode" Nurpmeso <sdaoden@users.sf.net>.
   5  *
   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.
   9  *
  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.
  17  */
  18
  19 #ifndef HAVE_AMALGAMATION
  20 # include "nail.h"
  21 #endif
  22
  23 /*
  24  * Quotation filter
  25  */
  26
  27 /*
  28  * TODO quotation filter: anticipate in future data: don't break if only WS
  29  * TODO or a LF escaping \ follows on the line (simply reuse the latter).
  30  */
  31
  32 #ifdef HAVE_QUOTE_FOLD
  33 CTA(QUOTE_MAX > 3);
  34
  35 enum qf_state {
  36    _QF_CLEAN,
  37    _QF_PREFIX,
  38    _QF_DATA
  39 };
  40
  41 struct qf_vc {
  42    struct quoteflt   *self;
  43    char const        *buf;
  44    size_t            len;
  45 };
  46
  47 /* Print out prefix and current quote */
  48 static ssize_t _qf_dump_prefix(struct quoteflt *self);
  49
  50 /* Add one data character */
  51 static ssize_t _qf_add_data(struct quoteflt *self, wchar_t wc);
  52
  53 /* State machine handlers */
  54 static ssize_t _qf_state_prefix(struct qf_vc *vc);
  55 static ssize_t _qf_state_data(struct qf_vc *vc);
  56
  57 static ssize_t
  58 _qf_dump_prefix(struct quoteflt *self)
  59 {
  60    ssize_t rv;
  61    size_t i;
  62    NYD_ENTER;
  63
  64    if ((i = self->qf_pfix_len) > 0 && i != fwrite(self->qf_pfix, 1, i,
  65          self->qf_os))
  66       goto jerr;
  67    rv = i;
  68
  69    if ((i = self->qf_currq.l) > 0 && i != fwrite(self->qf_currq.s, 1, i,
  70          self->qf_os))
  71       goto jerr;
  72    rv += i;
  73 jleave:
  74    NYD_LEAVE;
  75    return rv;
  76 jerr:
  77    rv = -1;
  78    goto jleave;
  79 }
  80
  81 static ssize_t
  82 _qf_add_data(struct quoteflt *self, wchar_t wc)
  83 {
  84    char *save_b;
  85    ui32_t save_l, save_w;
  86    ssize_t rv = 0;
  87    int w, l;
  88    NYD_ENTER;
  89
  90    save_l = save_w = 0; /* silence cc */
  91    save_b = NULL;
  92    /* <newline> ends state */
  93    if (wc == L'\n')
  94       goto jflush;
  95    if (wc == L'\r') /* TODO CR should be stripped in lower level!! */
  96       goto jleave;
  97
  98    /* Unroll <tab> to spaces */
  99    if (wc == L'\t') {
 100       save_l = self->qf_datw;
 101       save_w = (save_l + QUOTE_TAB_SPACES) & ~(QUOTE_TAB_SPACES - 1);
 102       save_w -= save_l;
 103       while (save_w-- > 0) {
 104          ssize_t j = _qf_add_data(self, L' ');
 105          if (j < 0) {
 106             rv = j;
 107             break;
 108          }
 109          rv += j;
 110       }
 111       goto jleave;
 112    }
 113
 114    w = wcwidth(wc);
 115    if (w == -1) {
 116 jbad:
 117       ++self->qf_datw;
 118       self->qf_dat.s[self->qf_dat.l++] = '?';
 119    } else {
 120       l = wctomb(self->qf_dat.s + self->qf_dat.l, wc);
 121       if (l < 0)
 122          goto jbad;
 123       self->qf_datw += (ui32_t)w;
 124       self->qf_dat.l += (size_t)l;
 125    }
 126
 127    /* TODO The last visual may excess *qfold-max* if it's a wide one;
 128     * TODO place it on the next line, break before */
 129    if (self->qf_datw >= self->qf_qfold_max) {
 130       /* If we have seen a nice breakpoint during traversal, shuffle data
 131        * around a bit so as to restore the trailing part after flushing */
 132       if (self->qf_brkl > 0) {
 133          save_w = self->qf_datw - self->qf_brkw;
 134          save_l = self->qf_dat.l - self->qf_brkl;
 135          save_b = self->qf_dat.s + self->qf_brkl + 2;
 136          memmove(save_b, save_b - 2, save_l);
 137          self->qf_dat.l = self->qf_brkl;
 138       }
 139
 140       self->qf_dat.s[self->qf_dat.l++] = '\\';
 141 jflush:
 142       self->qf_dat.s[self->qf_dat.l++] = '\n';
 143       rv = quoteflt_flush(self);
 144
 145       /* Restore takeovers, if any */
 146       if (save_b != NULL) {
 147          self->qf_brk_isws = FAL0;
 148          self->qf_datw += save_w;
 149          self->qf_dat.l = save_l;
 150          memmove(self->qf_dat.s, save_b, save_l);
 151       }
 152    } else if (self->qf_datw >= self->qf_qfold_min && !self->qf_brk_isws) {
 153       bool_t isws = iswspace(wc);
 154
 155       if ((isws && !self->qf_brk_isws) || self->qf_brkl == 0) {
 156          self->qf_brkl = self->qf_dat.l;
 157          self->qf_brkw = self->qf_datw;
 158          self->qf_brk_isws = isws;
 159       }
 160    }
 161
 162    /* If state changed to prefix, perform full reset (note this implies that
 163     * quoteflt_flush() performs too much work..) */
 164    if (wc == '\n') {
 165       self->qf_state = _QF_PREFIX;
 166       self->qf_wscnt = self->qf_datw = 0;
 167       self->qf_currq.l = 0;
 168    }
 169 jleave:
 170    NYD_LEAVE;
 171    return rv;
 172 }
 173
 174 static ssize_t
 175 _qf_state_prefix(struct qf_vc *vc)
 176 {
 177    struct quoteflt *self = vc->self;
 178    ssize_t rv = 0;
 179    char const *buf;
 180    size_t len, i;
 181    wchar_t wc;
 182    NYD_ENTER;
 183
 184    for (buf = vc->buf, len = vc->len; len > 0;) {
 185       /* TODO NULL BYTE! */
 186       i = mbrtowc(&wc, buf, len, self->qf_mbps);
 187       if (i == (size_t)-1) {
 188          /* On hard error, don't modify mbstate_t and step one byte */
 189          self->qf_mbps[0] = self->qf_mbps[1];
 190          ++buf;
 191          --len;
 192          self->qf_wscnt = 0;
 193          continue;
 194       }
 195       self->qf_mbps[1] = self->qf_mbps[0];
 196       if (i == (size_t)-2) {
 197          /* Redundant shift sequence, out of buffer */
 198          len = 0;
 199          break;
 200       }
 201       buf += i;
 202       len -= i;
 203
 204       if (wc == L'\n')
 205          goto jfin;
 206       if (iswspace(wc)) {
 207          ++self->qf_wscnt;
 208          continue;
 209       }
 210       if (i == 1 && ISQUOTE(wc)) {
 211          self->qf_wscnt = 0;
 212          if (self->qf_currq.l >= QUOTE_MAX - 3) {
 213             self->qf_currq.s[QUOTE_MAX - 3] = '.';
 214             self->qf_currq.s[QUOTE_MAX - 2] = '.';
 215             self->qf_currq.s[QUOTE_MAX - 1] = '.';
 216             self->qf_currq.l = QUOTE_MAX;
 217          } else
 218             self->qf_currq.s[self->qf_currq.l++] = buf[-1];
 219          continue;
 220       }
 221
 222       /* The quote is parsed and compressed; dump it */
 223 jfin:
 224       self->qf_datw = self->qf_pfix_len + self->qf_currq.l;
 225       self->qf_state = _QF_DATA;
 226       /* Overtake WS (xxx but we de-facto "normalize" to ASCII SP here) */
 227       while (self->qf_wscnt-- > 0 && self->qf_currq.l < QUOTE_MAX)
 228          self->qf_currq.s[self->qf_currq.l++] = ' ';
 229       self->qf_wscnt = 0;
 230       rv = _qf_add_data(self, wc);
 231       break;
 232    }
 233
 234    vc->buf = buf;
 235    vc->len = len;
 236    NYD_LEAVE;
 237    return rv;
 238 }
 239
 240 static ssize_t
 241 _qf_state_data(struct qf_vc *vc)
 242 {
 243    struct quoteflt *self = vc->self;
 244    ssize_t rv = 0;
 245    char const *buf;
 246    size_t len, i;
 247    wchar_t wc;
 248    NYD_ENTER;
 249
 250    for (buf = vc->buf, len = vc->len; len > 0;) {
 251       /* TODO NULL BYTE! */
 252       i = mbrtowc(&wc, buf, len, self->qf_mbps);
 253       if (i == (size_t)-1) {
 254          /* On hard error, don't modify mbstate_t and step one byte */
 255          self->qf_mbps[0] = self->qf_mbps[1];
 256          ++buf;
 257          --len;
 258          continue;
 259       }
 260       self->qf_mbps[1] = self->qf_mbps[0];
 261       if (i == (size_t)-2) {
 262          /* Redundant shift sequence, out of buffer */
 263          len = 0;
 264          break;
 265       }
 266       buf += i;
 267       len -= i;
 268
 269       {  ssize_t j = _qf_add_data(self, wc);
 270          if (j < 0) {
 271             rv = j;
 272             break;
 273          }
 274          rv += j;
 275       }
 276
 277       if (self->qf_state != _QF_DATA)
 278          break;
 279    }
 280
 281    vc->buf = buf;
 282    vc->len = len;
 283    NYD_LEAVE;
 284    return rv;
 285 }
 286 #endif /* HAVE_QUOTE_FOLD */
 287
 288 FL struct quoteflt *
 289 quoteflt_dummy(void) /* TODO LEGACY */
 290 {
 291    static struct quoteflt qf_i;
 292
 293    return &qf_i;
 294 }
 295
 296 FL void
 297 quoteflt_init(struct quoteflt *self, char const *prefix)
 298 {
 299 #ifdef HAVE_QUOTE_FOLD
 300    char *xcp, *cp;
 301 #endif
 302    NYD_ENTER;
 303
 304    memset(self, 0, sizeof *self);
 305
 306    if ((self->qf_pfix = prefix) != NULL)
 307       self->qf_pfix_len = (ui32_t)strlen(prefix);
 308
 309    /* Check wether the user wants the more fancy quoting algorithm */
 310    /* TODO *quote-fold*: QUOTE_MAX may excess it! */
 311 #ifdef HAVE_QUOTE_FOLD
 312    if (self->qf_pfix_len > 0 && (cp = ok_vlook(quote_fold)) != NULL) {
 313       ui32_t qmin, qmax = (ui32_t)strtol(cp, &xcp, 10);
 314       /* These magic values ensure we don't bail :) */
 315       if (qmax < self->qf_pfix_len + 6)
 316          qmax = self->qf_pfix_len + 6;
 317       --qmax; /* The newline escape */
 318       if (cp == xcp || *xcp == '\0')
 319          qmin = (qmax >> 1) + (qmax >> 2) + (qmax >> 5);
 320       else {
 321          qmin = (ui32_t)strtol(xcp + 1, NULL, 10);
 322          if (qmin < qmax >> 1)
 323             qmin = qmax >> 1;
 324          else if (qmin > qmax - 2)
 325             qmin = qmax - 2;
 326       }
 327       self->qf_qfold_min = qmin;
 328       self->qf_qfold_max = qmax;
 329
 330       /* Add pad for takeover copies, backslash and newline */
 331       self->qf_dat.s = salloc((qmax + 3) * mb_cur_max);
 332       self->qf_currq.s = salloc((QUOTE_MAX + 1) * mb_cur_max);
 333    }
 334 #endif
 335    NYD_LEAVE;
 336 }
 337
 338 FL void
 339 quoteflt_destroy(struct quoteflt *self) /* xxx inline */
 340 {
 341    NYD_ENTER;
 342    UNUSED(self);
 343    NYD_LEAVE;
 344 }
 345
 346 FL void
 347 quoteflt_reset(struct quoteflt *self, FILE *f) /* xxx inline */
 348 {
 349    NYD_ENTER;
 350    self->qf_os = f;
 351 #ifdef HAVE_QUOTE_FOLD
 352    self->qf_state = _QF_CLEAN;
 353    self->qf_dat.l =
 354    self->qf_currq.l = 0;
 355    memset(self->qf_mbps, 0, sizeof self->qf_mbps);
 356 #endif
 357    NYD_LEAVE;
 358 }
 359
 360 FL ssize_t
 361 quoteflt_push(struct quoteflt *self, char const *dat, size_t len)
 362 {
 363    /* (xxx Ideally the actual push() [and flush()] would be functions on their
 364     * xxx own, via indirect vtbl call ..) */
 365    ssize_t rv = 0;
 366    NYD_ENTER;
 367
 368    if (len == 0)
 369       goto jleave;
 370
 371    /* Bypass? XXX Finally, this filter simply should not be used, then */
 372    if (self->qf_pfix_len == 0) {
 373       if (len != fwrite(dat, 1, len, self->qf_os))
 374          goto jerr;
 375       rv = len;
 376    }
 377    /* Normal: place *indentprefix* at every BOL */
 378    else
 379 #ifdef HAVE_QUOTE_FOLD
 380       if (self->qf_qfold_max == 0)
 381 #endif
 382    {
 383       void *vp;
 384       size_t ll;
 385       bool_t pxok = (self->qf_qfold_min != 0);
 386
 387       for (;;) {
 388          if (!pxok) {
 389             ll = self->qf_pfix_len;
 390             if (ll != fwrite(self->qf_pfix, 1, ll, self->qf_os))
 391                goto jerr;
 392             rv += ll;
 393             pxok = TRU1;
 394          }
 395
 396          /* xxx Strictly speaking this is invalid, because only `/' and `.' are
 397           * xxx mandated by POSIX.1-2008 as "invariant across all locales
 398           * xxx supported"; though there is no charset known which uses this
 399           * xxx control char as part of a multibyte character; note that S-nail
 400           * XXX (and the Mail codebase as such) do not support EBCDIC */
 401          if ((vp = memchr(dat, '\n', len)) == NULL)
 402             ll = len;
 403          else {
 404             pxok = FAL0;
 405             ll = PTR2SIZE((char*)vp - dat) + 1;
 406          }
 407
 408          if (ll != fwrite(dat, sizeof *dat, ll, self->qf_os))
 409             goto jerr;
 410          rv += ll;
 411          if ((len -= ll) == 0)
 412             break;
 413          dat += ll;
 414       }
 415
 416       self->qf_qfold_min = pxok;
 417    }
 418    /* Overly complicated, though still only line-per-line: *quote-fold*.
 419     * - If .qf_currq.l is 0, then we are in a clean state.  Reset .qf_mbps;
 420     *   TODO note this means we assume that lines start with reset escape seq,
 421     *   TODO but i don't think this is any worse than what we currently do;
 422     *   TODO in 15.0, with the value carrier, we should carry conversion states
 423     *   TODO all along, only resetting on error (or at words for header =???=);
 424     *   TODO this still is weird for error handling, but we need to act more
 425     *   TODO stream-alike (though in practice i don't think cross-line states
 426     *   TODO can be found, because of compatibility reasons; however, being
 427     *   TODO a problem rather than a solution is not a good thing (tm))
 428     * - Lookout for a newline */
 429 #ifdef HAVE_QUOTE_FOLD
 430    else {
 431       struct qf_vc vc;
 432       ssize_t i;
 433
 434       vc.self = self;
 435       vc.buf = dat;
 436       vc.len = len;
 437       while (vc.len > 0) {
 438          switch (self->qf_state) {
 439          case _QF_CLEAN:
 440          case _QF_PREFIX:
 441             i = _qf_state_prefix(&vc);
 442             break;
 443          default: /* silence cc (`i' unused) */
 444          case _QF_DATA:
 445             i = _qf_state_data(&vc);
 446             break;
 447          }
 448          if (i < 0)
 449             goto jerr;
 450          rv += i;
 451       }
 452    }
 453 #endif /* HAVE_QUOTE_FOLD */
 454
 455 jleave:
 456    NYD_LEAVE;
 457    return rv;
 458 jerr:
 459    rv = -1;
 460    goto jleave;
 461 }
 462
 463 FL ssize_t
 464 quoteflt_flush(struct quoteflt *self)
 465 {
 466    ssize_t rv = 0;
 467    NYD_ENTER;
 468    UNUSED(self);
 469
 470 #ifdef HAVE_QUOTE_FOLD
 471    if (self->qf_dat.l > 0) {
 472       rv = _qf_dump_prefix(self);
 473       if (rv >= 0) {
 474          size_t i = self->qf_dat.l;
 475          if (i == fwrite(self->qf_dat.s, 1, i, self->qf_os))
 476             rv += i;
 477          else
 478             rv = -1;
 479          self->qf_dat.l = 0;
 480          self->qf_brk_isws = FAL0;
 481          self->qf_wscnt = self->qf_brkl = self->qf_brkw = 0;
 482          self->qf_datw = self->qf_pfix_len + self->qf_currq.l;
 483       }
 484    }
 485 #endif
 486    NYD_LEAVE;
 487    return rv;
 488 }
 489
 490 /* vim:set fenc=utf-8:s-it-mode */