head.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Routines for processing and detecting headlines.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  *      The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE head
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 #ifdef HAVE_IDNA
  43 # if HAVE_IDNA == HAVE_IDNA_LIBIDNA
  44 #  include <idna.h>
  45 #  include <idn-free.h>
  46 #  include <stringprep.h>
  47 # elif HAVE_IDNA == HAVE_IDNA_IDNKIT
  48 #  include <idn/api.h>
  49 # endif
  50 #endif
  51
  52 struct cmatch_data {
  53    size_t      tlen;    /* Length of .tdata */
  54    char const  *tdata;  /* Template date - see _cmatch_data[] */
  55 };
  56
  57 /* Template characters for cmatch_data.tdata:
  58  * 'A'   An upper case char
  59  * 'a'   A lower case char
  60  * ' '   A space
  61  * '0'   A digit
  62  * 'O'   An optional digit or space
  63  * ':'   A colon
  64  * '+'  Either a plus or a minus sign */
  65 static struct cmatch_data const  _cmatch_data[] = {
  66    { 24, "Aaa Aaa O0 00:00:00 0000" },       /* BSD/ISO C90 ctime */
  67    { 28, "Aaa Aaa O0 00:00:00 AAA 0000" },   /* BSD tmz */
  68    { 21, "Aaa Aaa O0 00:00 0000" },          /* SysV ctime */
  69    { 25, "Aaa Aaa O0 00:00 AAA 0000" },      /* SysV tmz */
  70    /* RFC 822-alike From_ lines do not conform to RFC 4155, but seem to be used
  71     * in the wild (by UW-imap) */
  72    { 30, "Aaa Aaa O0 00:00:00 0000 +0000" },
  73    /* RFC 822 with zone spec; 1. military, 2. UT, 3. north america time
  74     * zone strings; note that 1. is strictly speaking not correct as some
  75     * letters are not used, and 2. is not because only "UT" is defined */
  76 #define __reuse      "Aaa Aaa O0 00:00:00 0000 AAA"
  77    { 28 - 2, __reuse }, { 28 - 1, __reuse }, { 28 - 0, __reuse },
  78    { 0, NULL }
  79 };
  80 #define _DATE_MINLEN 21
  81
  82 /* Skip over "word" as found in From_ line */
  83 static char const *        _from__skipword(char const *wp);
  84
  85 /* Match the date string against the date template (tp), return if match.
  86  * See _cmatch_data[] for template character description */
  87 static int                 _cmatch(size_t len, char const *date,
  88                               char const *tp);
  89
  90 /* Check wether date is a valid 'From_' date.
  91  * (Rather ctime(3) generated dates, according to RFC 4155) */
  92 static int                 _is_date(char const *date);
  93
  94 /* Convert the domain part of a skinned address to IDNA.
  95  * If an error occurs before Unicode information is available, revert the IDNA
  96  * error to a normal CHAR one so that the error message doesn't talk Unicode */
  97 #ifdef HAVE_IDNA
  98 static struct addrguts *   _idna_apply(struct addrguts *agp);
  99 #endif
 100
 101 /* Classify and check a (possibly skinned) header body according to RFC
 102  * *addr-spec* rules; if it (is assumed to has been) skinned it may however be
 103  * also a file or a pipe command, so check that first, then.
 104  * Otherwise perform content checking and isolate the domain part (for IDNA) */
 105 static int                 _addrspec_check(int doskin, struct addrguts *agp);
 106
 107 /* Return the next header field found in the given message.
 108  * Return >= 0 if something found, < 0 elsewise.
 109  * "colon" is set to point to the colon in the header.
 110  * Must deal with \ continuations & other such fraud */
 111 static int                 gethfield(FILE *f, char **linebuf, size_t *linesize,
 112                               int rem, char **colon);
 113
 114 static int                 msgidnextc(char const **cp, int *status);
 115
 116 /* Count the occurances of c in str */
 117 static int                 charcount(char *str, int c);
 118
 119 static char const *        nexttoken(char const *cp);
 120
 121 static char const *
 122 _from__skipword(char const *wp)
 123 {
 124    char c = 0;
 125    NYD2_ENTER;
 126
 127    if (wp != NULL) {
 128       while ((c = *wp++) != '\0' && !blankchar(c)) {
 129          if (c == '"') {
 130             while ((c = *wp++) != '\0' && c != '"')
 131                ;
 132             if (c != '"')
 133                --wp;
 134          }
 135       }
 136       for (; blankchar(c); c = *wp++)
 137          ;
 138    }
 139    NYD2_LEAVE;
 140    return (c == 0 ? NULL : wp - 1);
 141 }
 142
 143 static int
 144 _cmatch(size_t len, char const *date, char const *tp)
 145 {
 146    int ret = 0;
 147    NYD2_ENTER;
 148
 149    while (len--) {
 150       char c = date[len];
 151       switch (tp[len]) {
 152       case 'a':
 153          if (!lowerchar(c))
 154             goto jleave;
 155          break;
 156       case 'A':
 157          if (!upperchar(c))
 158             goto jleave;
 159          break;
 160       case ' ':
 161          if (c != ' ')
 162             goto jleave;
 163          break;
 164       case '0':
 165          if (!digitchar(c))
 166             goto jleave;
 167          break;
 168       case 'O':
 169          if (c != ' ' && !digitchar(c))
 170             goto jleave;
 171          break;
 172       case ':':
 173          if (c != ':')
 174             goto jleave;
 175          break;
 176       case '+':
 177          if (c != '+' && c != '-')
 178             goto jleave;
 179          break;
 180       }
 181    }
 182    ret = 1;
 183 jleave:
 184    NYD2_LEAVE;
 185    return ret;
 186 }
 187
 188 static int
 189 _is_date(char const *date)
 190 {
 191    struct cmatch_data const *cmdp;
 192    size_t dl;
 193    int rv = 0;
 194    NYD2_ENTER;
 195
 196    if ((dl = strlen(date)) >= _DATE_MINLEN)
 197       for (cmdp = _cmatch_data; cmdp->tdata != NULL; ++cmdp)
 198          if (dl == cmdp->tlen && (rv = _cmatch(dl, date, cmdp->tdata)))
 199             break;
 200    NYD2_LEAVE;
 201    return rv;
 202 }
 203
 204 #ifdef HAVE_IDNA
 205 # if HAVE_IDNA == HAVE_IDNA_LIBIDNA
 206 static struct addrguts *
 207 _idna_apply(struct addrguts *agp)
 208 {
 209    char *idna_utf8, *idna_ascii, *cs;
 210    size_t sz, i;
 211    NYD_ENTER;
 212
 213    sz = agp->ag_slen - agp->ag_sdom_start;
 214    assert(sz > 0);
 215    idna_utf8 = ac_alloc(sz +1);
 216    memcpy(idna_utf8, agp->ag_skinned + agp->ag_sdom_start, sz);
 217    idna_utf8[sz] = '\0';
 218
 219    /* GNU Libidn settles on top of iconv(3) without any fallback, so let's just
 220     * let it perform the charset conversion, if any should be necessary */
 221    if (!(options & OPT_UNICODE)) {
 222       char const *tcs = charset_get_lc();
 223       idna_ascii = idna_utf8;
 224       idna_utf8 = stringprep_convert(idna_ascii, "UTF-8", tcs);
 225       i = (idna_utf8 == NULL && errno == EINVAL);
 226       ac_free(idna_ascii);
 227
 228       if (idna_utf8 == NULL) {
 229          if (i)
 230             n_err(_("Cannot convert from %s to %s\n"), tcs, "UTF-8");
 231          agp->ag_n_flags ^= NAME_ADDRSPEC_ERR_IDNA | NAME_ADDRSPEC_ERR_CHAR;
 232          goto jleave;
 233       }
 234    }
 235
 236    if (idna_to_ascii_8z(idna_utf8, &idna_ascii, 0) != IDNA_SUCCESS) {
 237       agp->ag_n_flags ^= NAME_ADDRSPEC_ERR_IDNA | NAME_ADDRSPEC_ERR_CHAR;
 238       goto jleave1;
 239    }
 240
 241    /* Replace the domain part of .ag_skinned with IDNA version */
 242    sz = strlen(idna_ascii);
 243    i = agp->ag_sdom_start;
 244    cs = salloc(agp->ag_slen - i + sz +1);
 245    memcpy(cs, agp->ag_skinned, i);
 246    memcpy(cs + i, idna_ascii, sz);
 247    i += sz;
 248    cs[i] = '\0';
 249
 250    agp->ag_skinned = cs;
 251    agp->ag_slen = i;
 252    NAME_ADDRSPEC_ERR_SET(agp->ag_n_flags,
 253       NAME_NAME_SALLOC | NAME_SKINNED | NAME_IDNA, 0);
 254
 255    idn_free(idna_ascii);
 256 jleave1:
 257    if (options & OPT_UNICODE)
 258       ac_free(idna_utf8);
 259    else
 260       idn_free(idna_utf8);
 261 jleave:
 262    NYD_LEAVE;
 263    return agp;
 264 }
 265
 266 # elif HAVE_IDNA == HAVE_IDNA_IDNKIT /* IDNA==LIBIDNA */
 267 static struct addrguts *
 268 _idna_apply(struct addrguts *agp)
 269 {
 270    char *idna_in, *idna_out, *cs;
 271    size_t sz, i;
 272    idn_result_t r;
 273    NYD_ENTER;
 274
 275    sz = agp->ag_slen - agp->ag_sdom_start;
 276    assert(sz > 0);
 277    idna_in = ac_alloc(sz +1);
 278    memcpy(idna_in, agp->ag_skinned + agp->ag_sdom_start, sz);
 279    idna_in[sz] = '\0';
 280
 281    for (idna_out = NULL, sz = HOST_NAME_MAX +1;; sz += HOST_NAME_MAX) {
 282       idna_out = ac_alloc(sz);
 283
 284       r = idn_encodename(IDN_ENCODE_APP, idna_in, idna_out, sz);
 285       switch (r) {
 286       case idn_success:
 287       case idn_buffer_overflow:
 288          break;
 289       case idn_invalid_encoding:
 290          n_err(_("Cannot convert from %s to %s\n"), charset_get_lc(), "UTF-8");
 291          /* FALLTHRU */
 292       default:
 293          agp->ag_n_flags ^= NAME_ADDRSPEC_ERR_IDNA | NAME_ADDRSPEC_ERR_CHAR;
 294          goto jleave;
 295       }
 296
 297       if (r == idn_success)
 298          break;
 299       ac_free(idna_out);
 300    }
 301
 302    /* Replace the domain part of .ag_skinned with IDNA version */
 303    sz = strlen(idna_out);
 304    i = agp->ag_sdom_start;
 305    cs = salloc(agp->ag_slen - i + sz +1);
 306    memcpy(cs, agp->ag_skinned, i);
 307    memcpy(cs + i, idna_out, sz);
 308    i += sz;
 309    cs[i] = '\0';
 310
 311    agp->ag_skinned = cs;
 312    agp->ag_slen = i;
 313    NAME_ADDRSPEC_ERR_SET(agp->ag_n_flags,
 314       NAME_NAME_SALLOC | NAME_SKINNED | NAME_IDNA, 0);
 315
 316 jleave:
 317    ac_free(idna_out);
 318    ac_free(idna_in);
 319    NYD_LEAVE;
 320    return agp;
 321 }
 322 # endif /* IDNA==IDNKIT */
 323 #endif /* HAVE_IDNA */
 324
 325 static int
 326 _addrspec_check(int skinned, struct addrguts *agp)
 327 {
 328    char *addr, *p;
 329    bool_t in_quote;
 330    ui8_t in_domain, hadat;
 331    union {char c; unsigned char u;} c;
 332 #ifdef HAVE_IDNA
 333    ui8_t use_idna;
 334 #endif
 335    NYD_ENTER;
 336
 337 #ifdef HAVE_IDNA
 338    use_idna = ok_blook(idna_disable) ? 0 : 1;
 339 #endif
 340    agp->ag_n_flags |= NAME_ADDRSPEC_CHECKED;
 341    addr = agp->ag_skinned;
 342
 343    if (agp->ag_iaddr_aend - agp->ag_iaddr_start == 0) {
 344       NAME_ADDRSPEC_ERR_SET(agp->ag_n_flags, NAME_ADDRSPEC_ERR_EMPTY, 0);
 345       goto jleave;
 346    }
 347
 348    /* If the field is not a recipient, it cannot be a file or a pipe */
 349    if (!skinned)
 350       goto jaddr_check;
 351
 352    /* When changing any of the following adjust any RECIPIENTADDRSPEC;
 353     * grep the latter for the complete picture */
 354    if (*addr == '|') {
 355       agp->ag_n_flags |= NAME_ADDRSPEC_ISPIPE;
 356       goto jleave;
 357    }
 358    if (addr[0] == '/' || (addr[0] == '.' && addr[1] == '/'))
 359       goto jisfile;
 360    if (memchr(addr, '@', agp->ag_slen) == NULL) {
 361       if (*addr == '+')
 362          goto jisfile;
 363       for (p = addr; (c.c = *p); ++p) {
 364          if (c.c == '!' || c.c == '%')
 365             break;
 366          if (c.c == '/') {
 367 jisfile:
 368             agp->ag_n_flags |= NAME_ADDRSPEC_ISFILE;
 369             goto jleave;
 370          }
 371       }
 372    }
 373
 374 jaddr_check:
 375    in_quote = FAL0;
 376    in_domain = hadat = 0;
 377
 378    for (p = addr; (c.c = *p++) != '\0';) {
 379       if (c.c == '"') {
 380          in_quote = !in_quote;
 381       } else if (c.u < 040 || c.u >= 0177) { /* TODO no magics: !bodychar()? */
 382 #ifdef HAVE_IDNA
 383          if (in_domain && use_idna > 0) {
 384             if (use_idna == 1)
 385                NAME_ADDRSPEC_ERR_SET(agp->ag_n_flags, NAME_ADDRSPEC_ERR_IDNA,
 386                   c.u);
 387             use_idna = 2;
 388          } else
 389 #endif
 390             break;
 391       } else if (in_domain == 2) {
 392          if ((c.c == ']' && *p != '\0') || c.c == '\\' || whitechar(c.c))
 393             break;
 394       } else if (in_quote && in_domain == 0) {
 395          /*EMPTY*/;
 396       } else if (c.c == '\\' && *p != '\0') {
 397          ++p;
 398       } else if (c.c == '@') {
 399          if (hadat++ > 0) {
 400             NAME_ADDRSPEC_ERR_SET(agp->ag_n_flags, NAME_ADDRSPEC_ERR_ATSEQ,
 401                c.u);
 402             goto jleave;
 403          }
 404          agp->ag_sdom_start = PTR2SIZE(p - addr);
 405          agp->ag_n_flags |= NAME_ADDRSPEC_ISADDR; /* TODO .. really? */
 406          in_domain = (*p == '[') ? 2 : 1;
 407          continue;
 408       } else if (c.c == '(' || c.c == ')' || c.c == '<' || c.c == '>' ||
 409             c.c == ',' || c.c == ';' || c.c == ':' || c.c == '\\' ||
 410             c.c == '[' || c.c == ']')
 411          break;
 412       hadat = 0;
 413    }
 414    if (c.c != '\0') {
 415       NAME_ADDRSPEC_ERR_SET(agp->ag_n_flags, NAME_ADDRSPEC_ERR_CHAR, c.u);
 416       goto jleave;
 417    }
 418
 419    if (!(agp->ag_n_flags & NAME_ADDRSPEC_ISADDR))
 420       agp->ag_n_flags |= NAME_ADDRSPEC_ISNAME;
 421
 422 #ifdef HAVE_IDNA
 423    if (use_idna == 2)
 424       agp = _idna_apply(agp);
 425 #endif
 426 jleave:
 427    NYD_LEAVE;
 428    return ((agp->ag_n_flags & NAME_ADDRSPEC_INVALID) != 0);
 429 }
 430
 431 static int
 432 gethfield(FILE *f, char **linebuf, size_t *linesize, int rem, char **colon)
 433 {
 434    char *line2 = NULL, *cp, *cp2;
 435    size_t line2size = 0;
 436    int c, isenc;
 437    NYD2_ENTER;
 438
 439    if (*linebuf == NULL)
 440       *linebuf = srealloc(*linebuf, *linesize = 1);
 441    **linebuf = '\0';
 442    for (;;) {
 443       if (--rem < 0) {
 444          rem = -1;
 445          break;
 446       }
 447       if ((c = readline_restart(f, linebuf, linesize, 0)) <= 0) {
 448          rem = -1;
 449          break;
 450       }
 451       for (cp = *linebuf; fieldnamechar(*cp); ++cp)
 452          ;
 453       if (cp > *linebuf)
 454          while (blankchar(*cp))
 455             ++cp;
 456       if (*cp != ':' || cp == *linebuf)
 457          continue;
 458
 459       /* I guess we got a headline.  Handle wraparound */
 460       *colon = cp;
 461       cp = *linebuf + c;
 462       for (;;) {
 463          isenc = 0;
 464          while (PTRCMP(--cp, >=, *linebuf) && blankchar(*cp))
 465             ;
 466          cp++;
 467          if (rem <= 0)
 468             break;
 469          if (PTRCMP(cp - 8, >=, *linebuf) && cp[-1] == '=' && cp[-2] == '?')
 470             isenc |= 1;
 471          ungetc(c = getc(f), f);
 472          if (!blankchar(c))
 473             break;
 474          c = readline_restart(f, &line2, &line2size, 0);
 475          if (c < 0)
 476             break;
 477          --rem;
 478          for (cp2 = line2; blankchar(*cp2); ++cp2)
 479             ;
 480          c -= (int)PTR2SIZE(cp2 - line2);
 481          if (cp2[0] == '=' && cp2[1] == '?' && c > 8)
 482             isenc |= 2;
 483          if (PTRCMP(cp + c, >=, *linebuf + *linesize - 2)) {
 484             size_t diff = PTR2SIZE(cp - *linebuf),
 485                colondiff = PTR2SIZE(*colon - *linebuf);
 486             *linebuf = srealloc(*linebuf, *linesize += c + 2);
 487             cp = &(*linebuf)[diff];
 488             *colon = &(*linebuf)[colondiff];
 489          }
 490          if (isenc != 3)
 491             *cp++ = ' ';
 492          memcpy(cp, cp2, c);
 493          cp += c;
 494       }
 495       *cp = '\0';
 496
 497       if (line2 != NULL)
 498          free(line2);
 499       break;
 500    }
 501    NYD2_LEAVE;
 502    return rem;
 503 }
 504
 505 static int
 506 msgidnextc(char const **cp, int *status)
 507 {
 508    int c;
 509    NYD2_ENTER;
 510
 511    assert(cp != NULL);
 512    assert(*cp != NULL);
 513    assert(status != NULL);
 514
 515    for (;;) {
 516       if (*status & 01) {
 517          if (**cp == '"') {
 518             *status &= ~01;
 519             (*cp)++;
 520             continue;
 521          }
 522          if (**cp == '\\') {
 523             (*cp)++;
 524             if (**cp == '\0')
 525                goto jeof;
 526          }
 527          goto jdfl;
 528       }
 529       switch (**cp) {
 530       case '(':
 531          *cp = skip_comment(&(*cp)[1]);
 532          continue;
 533       case '>':
 534       case '\0':
 535 jeof:
 536          c = '\0';
 537          goto jleave;
 538       case '"':
 539          (*cp)++;
 540          *status |= 01;
 541          continue;
 542       case '@':
 543          *status |= 02;
 544          /*FALLTHRU*/
 545       default:
 546 jdfl:
 547          c = *(*cp)++ & 0377;
 548          c = (*status & 02) ? lowerconv(c) : c;
 549          goto jleave;
 550       }
 551    }
 552 jleave:
 553    NYD2_LEAVE;
 554    return c;
 555 }
 556
 557 static int
 558 charcount(char *str, int c)
 559 {
 560    char *cp;
 561    int i;
 562    NYD2_ENTER;
 563
 564    for (i = 0, cp = str; *cp; ++cp)
 565       if (*cp == c)
 566          ++i;
 567    NYD2_LEAVE;
 568    return i;
 569 }
 570
 571 static char const *
 572 nexttoken(char const *cp)
 573 {
 574    NYD2_ENTER;
 575    for (;;) {
 576       if (*cp == '\0') {
 577          cp = NULL;
 578          break;
 579       }
 580
 581       if (*cp == '(') {
 582          size_t nesting = 1;
 583
 584          do switch (*++cp) {
 585          case '(':
 586             ++nesting;
 587             break;
 588          case ')':
 589             --nesting;
 590             break;
 591          } while (nesting > 0 && *cp != '\0'); /* XXX error? */
 592       } else if (blankchar(*cp) || *cp == ',')
 593          ++cp;
 594       else
 595          break;
 596    }
 597    NYD2_LEAVE;
 598    return cp;
 599 }
 600
 601 FL char const *
 602 myaddrs(struct header *hp)
 603 {
 604    struct name *np;
 605    char *rv;
 606    NYD_ENTER;
 607
 608    if (hp != NULL && (np = hp->h_from) != NULL) {
 609       if ((rv = np->n_fullname) != NULL)
 610          goto jleave;
 611       if ((rv = np->n_name) != NULL)
 612          goto jleave;
 613    }
 614
 615    if ((rv = ok_vlook(from)) != NULL)
 616       goto jleave;
 617
 618    /* When invoking *sendmail* directly, it's its task to generate an otherwise
 619     * undeterminable From: address.  However, if the user sets *hostname*,
 620     * accept his desire */
 621    if (ok_vlook(smtp) != NULL || ok_vlook(hostname) != NULL) {
 622       char *hn = nodename(1);
 623       size_t sz = strlen(myname) + strlen(hn) + 1 +1;
 624       rv = salloc(sz);
 625       sstpcpy(sstpcpy(sstpcpy(rv, myname), "@"), hn);
 626    }
 627 jleave:
 628    NYD_LEAVE;
 629    return rv;
 630 }
 631
 632 FL char const *
 633 myorigin(struct header *hp)
 634 {
 635    char const *rv = NULL, *ccp;
 636    struct name *np;
 637    NYD_ENTER;
 638
 639    if ((ccp = myaddrs(hp)) != NULL &&
 640          (np = lextract(ccp, GEXTRA | GFULL)) != NULL)
 641       rv = (np->n_flink != NULL) ? ok_vlook(sender) : ccp;
 642    NYD_LEAVE;
 643    return rv;
 644 }
 645
 646 FL int
 647 is_head(char const *linebuf, size_t linelen, bool_t compat)
 648 {
 649    char date[FROM_DATEBUF];
 650    int rv;
 651    NYD2_ENTER;
 652
 653    if ((rv = (linelen >= 5 && !strncmp(linebuf, "From ", 5))) &&
 654          (!compat || ok_blook(mbox_rfc4155)))
 655       rv = (extract_date_from_from_(linebuf, linelen, date) && _is_date(date));
 656    NYD2_LEAVE;
 657    return rv;
 658 }
 659
 660 FL int
 661 extract_date_from_from_(char const *line, size_t linelen,
 662    char datebuf[FROM_DATEBUF])
 663 {
 664    int rv = 0;
 665    char const *cp = line;
 666    NYD_ENTER;
 667
 668    /* "From " */
 669    cp = _from__skipword(cp);
 670    if (cp == NULL)
 671       goto jerr;
 672    /* "addr-spec " */
 673    cp = _from__skipword(cp);
 674    if (cp == NULL)
 675       goto jerr;
 676    if (cp[0] == 't' && cp[1] == 't' && cp[2] == 'y') {
 677       cp = _from__skipword(cp);
 678       if (cp == NULL)
 679          goto jerr;
 680    }
 681    /* It seems there are invalid MBOX archives in the wild, compare
 682     * . http://bugs.debian.org/624111
 683     * . [Mutt] #3868: mutt should error if the imported mailbox is invalid
 684     * What they do is that they obfuscate the address to "name at host".
 685     * I think we should handle that */
 686    else if(cp[0] == 'a' && cp[1] == 't' && cp[2] == ' '){
 687       cp = _from__skipword(cp += 3);
 688       if (cp == NULL)
 689          goto jerr;
 690    }
 691
 692    linelen -= PTR2SIZE(cp - line);
 693    if (linelen < _DATE_MINLEN)
 694       goto jerr;
 695    if (cp[linelen - 1] == '\n') {
 696       --linelen;
 697       /* (Rather IMAP/POP3 only) */
 698       if (cp[linelen - 1] == '\r')
 699          --linelen;
 700       if (linelen < _DATE_MINLEN)
 701          goto jerr;
 702    }
 703    if (linelen >= FROM_DATEBUF)
 704       goto jerr;
 705
 706    rv = 1;
 707 jleave:
 708    memcpy(datebuf, cp, linelen);
 709    datebuf[linelen] = '\0';
 710    NYD_LEAVE;
 711    return rv;
 712 jerr:
 713    cp = _("<Unknown date>");
 714    linelen = strlen(cp);
 715    if (linelen >= FROM_DATEBUF)
 716       linelen = FROM_DATEBUF;
 717    goto jleave;
 718 }
 719
 720 FL void
 721 extract_header(FILE *fp, struct header *hp, si8_t *checkaddr_err)
 722 {
 723    /* See the prototype declaration for the hairy relationship of
 724     * options&OPT_t_FLAG and/or pstate&PS_t_FLAG in here */
 725    struct header nh, *hq = &nh;
 726    char *linebuf = NULL /* TODO line pool */, *colon;
 727    size_t linesize = 0, seenfields = 0;
 728    int lc, c;
 729    char const *val, *cp;
 730    NYD_ENTER;
 731
 732    memset(hq, 0, sizeof *hq);
 733    if ((pstate & PS_t_FLAG) && (options & OPT_t_FLAG)) {
 734       hq->h_to = hp->h_to;
 735       hq->h_cc = hp->h_cc;
 736       hq->h_bcc = hp->h_bcc;
 737    }
 738
 739    for (lc = 0; readline_restart(fp, &linebuf, &linesize, 0) > 0; ++lc)
 740       ;
 741
 742    /* TODO yippieia, cat(check(lextract)) :-) */
 743    rewind(fp);
 744    while ((lc = gethfield(fp, &linebuf, &linesize, lc, &colon)) >= 0) {
 745       struct name *np;
 746
 747       /* We explicitly allow EAF_NAME for some addressees since aliases are not
 748        * yet expanded when we parse these! */
 749       if ((val = thisfield(linebuf, "to")) != NULL) {
 750          ++seenfields;
 751          hq->h_to = cat(hq->h_to, checkaddrs(lextract(val, GTO | GFULL),
 752                EACM_NORMAL | EAF_NAME, checkaddr_err));
 753       } else if ((val = thisfield(linebuf, "cc")) != NULL) {
 754          ++seenfields;
 755          hq->h_cc = cat(hq->h_cc, checkaddrs(lextract(val, GCC | GFULL),
 756                EACM_NORMAL | EAF_NAME, checkaddr_err));
 757       } else if ((val = thisfield(linebuf, "bcc")) != NULL) {
 758          ++seenfields;
 759          hq->h_bcc = cat(hq->h_bcc, checkaddrs(lextract(val, GBCC | GFULL),
 760                EACM_NORMAL | EAF_NAME, checkaddr_err));
 761       } else if ((val = thisfield(linebuf, "from")) != NULL) {
 762          if (!(pstate & PS_t_FLAG) || (options & OPT_t_FLAG)) {
 763             ++seenfields;
 764             hq->h_from = cat(hq->h_from,
 765                   checkaddrs(lextract(val, GEXTRA | GFULL | GFULLEXTRA),
 766                      EACM_STRICT, NULL));
 767          }
 768       } else if ((val = thisfield(linebuf, "reply-to")) != NULL) {
 769          ++seenfields;
 770          hq->h_replyto = cat(hq->h_replyto,
 771                checkaddrs(lextract(val, GEXTRA | GFULL), EACM_STRICT, NULL));
 772       } else if ((val = thisfield(linebuf, "sender")) != NULL) {
 773          if (!(pstate & PS_t_FLAG) || (options & OPT_t_FLAG)) {
 774             ++seenfields;
 775             hq->h_sender = cat(hq->h_sender, /* TODO cat? check! */
 776                   checkaddrs(lextract(val, GEXTRA | GFULL | GFULLEXTRA),
 777                      EACM_STRICT, NULL));
 778          }
 779       } else if ((val = thisfield(linebuf, "organization")) != NULL) {
 780          ++seenfields;
 781          for (cp = val; blankchar(*cp); ++cp)
 782             ;
 783          hq->h_organization = (hq->h_organization != NULL)
 784                ? save2str(hq->h_organization, cp) : savestr(cp);
 785       } else if ((val = thisfield(linebuf, "subject")) != NULL ||
 786             (val = thisfield(linebuf, "subj")) != NULL) {
 787          ++seenfields;
 788          for (cp = val; blankchar(*cp); ++cp)
 789             ;
 790          hq->h_subject = (hq->h_subject != NULL)
 791                ? save2str(hq->h_subject, cp) : savestr(cp);
 792       }
 793       /* The remaining are mostly hacked in and thus TODO -- at least in
 794        * TODO respect to their content checking */
 795       else if ((pstate & PS_t_FLAG) &&
 796             (val = thisfield(linebuf, "message-id")) != NULL) {
 797          np = checkaddrs(lextract(val, GREF),
 798                /*EACM_STRICT | TODO '/' valid!! */ EACM_NOLOG | EACM_NONAME,
 799                NULL);
 800          if (np == NULL || np->n_flink != NULL)
 801             goto jebadhead;
 802          ++seenfields;
 803          hq->h_message_id = np;
 804       } else if ((pstate & PS_t_FLAG) &&
 805             (val = thisfield(linebuf, "in-reply-to")) != NULL) {
 806          np = checkaddrs(lextract(val, GREF),
 807                /*EACM_STRICT | TODO '/' valid!! */ EACM_NOLOG | EACM_NONAME,
 808                NULL);
 809          if (np == NULL || np->n_flink != NULL)
 810             goto jebadhead;
 811          ++seenfields;
 812          hq->h_in_reply_to = np;
 813       } else if ((pstate & PS_t_FLAG) &&
 814             (val = thisfield(linebuf, "references")) != NULL) {
 815          ++seenfields;
 816          /* TODO Limit number of references TODO better on parser side */
 817          hq->h_ref = cat(hq->h_ref, checkaddrs(extract(val, GREF),
 818                /*EACM_STRICT | TODO '/' valid!! */ EACM_NOLOG | EACM_NONAME,
 819                NULL));
 820       /* and that is very hairy */
 821       } else if ((pstate & PS_t_FLAG) &&
 822             (val = thisfield(linebuf, "mail-followup-to")) != NULL) {
 823          ++seenfields;
 824          hq->h_mft = cat(hq->h_mft, checkaddrs(lextract(val, GEXTRA | GFULL),
 825                /*EACM_STRICT | TODO '/' valid!! | EACM_NOLOG | */ EACM_NONAME,
 826                checkaddr_err));
 827       } else
 828 jebadhead:
 829          n_err(_("Ignoring header field \"%s\"\n"), linebuf);
 830    }
 831
 832    /* In case the blank line after the header has been edited out.  Otherwise,
 833     * fetch the header separator */
 834    if (linebuf != NULL) {
 835       if (linebuf[0] != '\0') {
 836          for (cp = linebuf; *(++cp) != '\0';)
 837             ;
 838          fseek(fp, (long)-PTR2SIZE(1 + cp - linebuf), SEEK_CUR);
 839       } else {
 840          if ((c = getc(fp)) != '\n' && c != EOF)
 841             ungetc(c, fp);
 842       }
 843    }
 844
 845    if (seenfields > 0) {
 846       hp->h_to = hq->h_to;
 847       hp->h_cc = hq->h_cc;
 848       hp->h_bcc = hq->h_bcc;
 849       hp->h_from = hq->h_from;
 850       hp->h_replyto = hq->h_replyto;
 851       hp->h_sender = hq->h_sender;
 852       hp->h_organization = hq->h_organization;
 853       if (hq->h_subject != NULL || !(pstate & PS_t_FLAG) ||
 854             !(options & OPT_t_FLAG))
 855          hp->h_subject = hq->h_subject;
 856
 857       if (pstate & PS_t_FLAG) {
 858          hp->h_ref = hq->h_ref;
 859          hp->h_message_id = hq->h_message_id;
 860          hp->h_in_reply_to = hq->h_in_reply_to;
 861          hp->h_mft = hq->h_mft;
 862
 863          /* And perform additional validity checks so that we don't bail later
 864           * on TODO this is good and the place where this should occur,
 865           * TODO unfortunately a lot of other places do again and blabla */
 866          if (pstate & PS_t_FLAG) {
 867             if (hp->h_from == NULL)
 868                hp->h_from = option_r_arg;
 869             else if (hp->h_from->n_flink != NULL && hp->h_sender == NULL)
 870                hp->h_sender = lextract(ok_vlook(sender),
 871                      GEXTRA | GFULL | GFULLEXTRA);
 872          }
 873       }
 874    } else
 875       n_err(_("Restoring deleted header lines\n"));
 876
 877    if (linebuf != NULL)
 878       free(linebuf);
 879    NYD_LEAVE;
 880 }
 881
 882 FL char *
 883 hfield_mult(char const *field, struct message *mp, int mult)
 884 {
 885    FILE *ibuf;
 886    int lc;
 887    struct str hfs;
 888    size_t linesize = 0; /* TODO line pool */
 889    char *linebuf = NULL, *colon;
 890    char const *hfield;
 891    NYD_ENTER;
 892
 893    /* There are (spam) messages which have header bytes which are many KB when
 894     * joined, so resize a single heap storage until we are done if we shall
 895     * collect a field that may have multiple bodies; only otherwise use the
 896     * string dope directly */
 897    memset(&hfs, 0, sizeof hfs);
 898
 899    if ((ibuf = setinput(&mb, mp, NEED_HEADER)) == NULL)
 900       goto jleave;
 901    if ((lc = mp->m_lines - 1) < 0)
 902       goto jleave;
 903
 904    if ((mp->m_flag & MNOFROM) == 0 &&
 905          readline_restart(ibuf, &linebuf, &linesize, 0) < 0)
 906       goto jleave;
 907    while (lc > 0) {
 908       if ((lc = gethfield(ibuf, &linebuf, &linesize, lc, &colon)) < 0)
 909          break;
 910       if ((hfield = thisfield(linebuf, field)) != NULL && *hfield != '\0') {
 911          if (mult)
 912             n_str_add_buf(&hfs, hfield, strlen(hfield));
 913          else {
 914             hfs.s = savestr(hfield);
 915             break;
 916          }
 917       }
 918    }
 919
 920 jleave:
 921    if (linebuf != NULL)
 922       free(linebuf);
 923    if (mult && hfs.s != NULL) {
 924       colon = savestrbuf(hfs.s, hfs.l);
 925       free(hfs.s);
 926       hfs.s = colon;
 927    }
 928    NYD_LEAVE;
 929    return hfs.s;
 930 }
 931
 932 FL char const *
 933 thisfield(char const *linebuf, char const *field)
 934 {
 935    char const *rv = NULL;
 936    NYD2_ENTER;
 937
 938    while (lowerconv(*linebuf) == lowerconv(*field)) {
 939       ++linebuf;
 940       ++field;
 941    }
 942    if (*field != '\0')
 943       goto jleave;
 944
 945    while (blankchar(*linebuf))
 946       ++linebuf;
 947    if (*linebuf++ != ':')
 948       goto jleave;
 949
 950    while (blankchar(*linebuf)) /* TODO header parser..  strip trailing WS?!? */
 951       ++linebuf;
 952    rv = linebuf;
 953 jleave:
 954    NYD2_LEAVE;
 955    return rv;
 956 }
 957
 958 FL char *
 959 nameof(struct message *mp, int reptype)
 960 {
 961    char *cp, *cp2;
 962    NYD_ENTER;
 963
 964    cp = skin(name1(mp, reptype));
 965    if (reptype != 0 || charcount(cp, '!') < 2)
 966       goto jleave;
 967    cp2 = strrchr(cp, '!');
 968    --cp2;
 969    while (cp2 > cp && *cp2 != '!')
 970       --cp2;
 971    if (*cp2 == '!')
 972       cp = cp2 + 1;
 973 jleave:
 974    NYD_LEAVE;
 975    return cp;
 976 }
 977
 978 FL char const *
 979 skip_comment(char const *cp)
 980 {
 981    size_t nesting;
 982    NYD_ENTER;
 983
 984    for (nesting = 1; nesting > 0 && *cp; ++cp) {
 985       switch (*cp) {
 986       case '\\':
 987          if (cp[1])
 988             ++cp;
 989          break;
 990       case '(':
 991          ++nesting;
 992          break;
 993       case ')':
 994          --nesting;
 995          break;
 996       }
 997    }
 998    NYD_LEAVE;
 999    return cp;
1000 }
1001
1002 FL char const *
1003 routeaddr(char const *name)
1004 {
1005    char const *np, *rp = NULL;
1006    NYD_ENTER;
1007
1008    for (np = name; *np; np++) {
1009       switch (*np) {
1010       case '(':
1011          np = skip_comment(np + 1) - 1;
1012          break;
1013       case '"':
1014          while (*np) {
1015             if (*++np == '"')
1016                break;
1017             if (*np == '\\' && np[1])
1018                np++;
1019          }
1020          break;
1021       case '<':
1022          rp = np;
1023          break;
1024       case '>':
1025          goto jleave;
1026       }
1027    }
1028    rp = NULL;
1029 jleave:
1030    NYD_LEAVE;
1031    return rp;
1032 }
1033
1034 FL enum expand_addr_flags
1035 expandaddr_to_eaf(void)
1036 {
1037    struct eafdesc {
1038       char const  *eafd_name;
1039       bool_t      eafd_is_target;
1040       ui8_t       eafd_andoff;
1041       ui8_t       eafd_or;
1042    } const eafa[] = {
1043       {"restrict", FAL0, EAF_TARGET_MASK, EAF_RESTRICT | EAF_RESTRICT_TARGETS},
1044       {"fail", FAL0, EAF_NONE, EAF_FAIL},
1045       {"all", TRU1, EAF_NONE, EAF_TARGET_MASK},
1046          {"file", TRU1, EAF_NONE, EAF_FILE},
1047          {"pipe", TRU1, EAF_NONE, EAF_PIPE},
1048          {"name", TRU1, EAF_NONE, EAF_NAME},
1049          {"addr", TRU1, EAF_NONE, EAF_ADDR}
1050    }, *eafp;
1051
1052    char *buf;
1053    enum expand_addr_flags rv;
1054    char const *cp;
1055    NYD2_ENTER;
1056
1057    if ((cp = ok_vlook(expandaddr)) == NULL)
1058       rv = EAF_RESTRICT_TARGETS;
1059    else if (*cp == '\0')
1060       rv = EAF_TARGET_MASK;
1061    else {
1062       rv = EAF_TARGET_MASK;
1063
1064       for (buf = savestr(cp); (cp = n_strsep(&buf, ',', TRU1)) != NULL;) {
1065          bool_t minus;
1066
1067          if ((minus = (*cp == '-')) || *cp == '+')
1068             ++cp;
1069          for (eafp = eafa;; ++eafp) {
1070             if (eafp == eafa + NELEM(eafa)) {
1071                if (options & OPT_D_V)
1072                   n_err(_("Unknown *expandaddr* value: \"%s\"\n"), cp);
1073                break;
1074             } else if (!asccasecmp(cp, eafp->eafd_name)) {
1075                if (!minus) {
1076                   rv &= ~eafp->eafd_andoff;
1077                   rv |= eafp->eafd_or;
1078                } else {
1079                   if (eafp->eafd_is_target)
1080                      rv &= ~eafp->eafd_or;
1081                   else if (options & OPT_D_V)
1082                      n_err(_("\"-\" prefix invalid for *expandaddr* value: "
1083                         "\"%s\"\n"), --cp);
1084                }
1085                break;
1086             } else if (!asccasecmp(cp, "noalias")) { /* TODO v15 OBSOLETE */
1087                OBSOLETE(_("*expandaddr*: \"noalias\" is henceforth \"-name\""));
1088                rv &= ~EAF_NAME;
1089                break;
1090             }
1091          }
1092       }
1093
1094       if ((rv & EAF_RESTRICT) && (options & (OPT_INTERACTIVE | OPT_TILDE_FLAG)))
1095          rv |= EAF_TARGET_MASK;
1096       else if (options & OPT_D_V) {
1097          if (!(rv & EAF_TARGET_MASK))
1098             n_err(_("*expandaddr* doesn't allow any addresses\n"));
1099          else if ((rv & EAF_FAIL) && (rv & EAF_TARGET_MASK) == EAF_TARGET_MASK)
1100             n_err(_("*expandaddr* with \"fail\" but no restrictions\n"));
1101       }
1102    }
1103    NYD2_LEAVE;
1104    return rv;
1105 }
1106
1107 FL si8_t
1108 is_addr_invalid(struct name *np, enum expand_addr_check_mode eacm)
1109 {
1110    char cbuf[sizeof "'\\U12340'"];
1111    enum expand_addr_flags eaf;
1112    char const *cs;
1113    int f;
1114    si8_t rv;
1115    NYD_ENTER;
1116
1117    f = np->n_flags;
1118
1119    if ((rv = ((f & NAME_ADDRSPEC_INVALID) != 0))) {
1120       if ((eacm & EACM_NOLOG) || (f & NAME_ADDRSPEC_ERR_EMPTY)) {
1121          ;
1122       } else {
1123          ui32_t c;
1124          char const *fmt = "'\\x%02X'";
1125          bool_t ok8bit = TRU1;
1126
1127          if (f & NAME_ADDRSPEC_ERR_IDNA) {
1128             cs = _("Invalid domain name: \"%s\", character %s\n");
1129             fmt = "'\\U%04X'";
1130             ok8bit = FAL0;
1131          } else if (f & NAME_ADDRSPEC_ERR_ATSEQ)
1132             cs = _("\"%s\" contains invalid %s sequence\n");
1133          else
1134             cs = _("\"%s\" contains invalid character %s\n");
1135
1136          c = NAME_ADDRSPEC_ERR_GETWC(f);
1137          snprintf(cbuf, sizeof cbuf,
1138             (ok8bit && c >= 040 && c <= 0177 ? "'%c'" : fmt), c);
1139          goto jprint;
1140       }
1141       goto jleave;
1142    }
1143
1144    /* *expandaddr* stuff */
1145    if (!(rv = ((eacm & EACM_MODE_MASK) != EACM_NONE)))
1146       goto jleave;
1147
1148    eaf = expandaddr_to_eaf();
1149
1150    if ((eacm & EACM_STRICT) && (f & NAME_ADDRSPEC_ISFILEORPIPE)) {
1151       if (eaf & EAF_FAIL)
1152          rv = -rv;
1153       cs = _("\"%s\"%s: file or pipe addressees not allowed here\n");
1154       if (eacm & EACM_NOLOG)
1155          goto jleave;
1156       else
1157          goto j0print;
1158    }
1159
1160    eaf |= (eacm & EAF_TARGET_MASK);
1161    if (eacm & EACM_NONAME)
1162       eaf &= ~EAF_NAME;
1163
1164    if (eaf == EAF_NONE) {
1165       rv = FAL0;
1166       goto jleave;
1167    }
1168    if (eaf & EAF_FAIL)
1169       rv = -rv;
1170
1171    if (!(eaf & EAF_FILE) && (f & NAME_ADDRSPEC_ISFILE)) {
1172       cs = _("\"%s\"%s: *expandaddr* doesn't allow file target\n");
1173       if (eacm & EACM_NOLOG)
1174          goto jleave;
1175    } else if (!(eaf & EAF_PIPE) && (f & NAME_ADDRSPEC_ISPIPE)) {
1176       cs = _("\"%s\"%s: *expandaddr* doesn't allow command pipe target\n");
1177       if (eacm & EACM_NOLOG)
1178          goto jleave;
1179    } else if (!(eaf & EAF_NAME) && (f & NAME_ADDRSPEC_ISNAME)) {
1180       cs = _("\"%s\"%s: *expandaddr* doesn't allow user name target\n");
1181       if (eacm & EACM_NOLOG)
1182          goto jleave;
1183    } else if (!(eaf & EAF_ADDR) && (f & NAME_ADDRSPEC_ISADDR)) {
1184       cs = _("\"%s\"%s: *expandaddr* doesn't allow mail address target\n");
1185       if (eacm & EACM_NOLOG)
1186          goto jleave;
1187    } else {
1188       rv = FAL0;
1189       goto jleave;
1190    }
1191
1192 j0print:
1193    cbuf[0] = '\0';
1194 jprint:
1195    n_err(cs, np->n_name, cbuf);
1196 jleave:
1197    NYD_LEAVE;
1198    return rv;
1199 }
1200
1201 FL char *
1202 skin(char const *name)
1203 {
1204    struct addrguts ag;
1205    char *ret = NULL;
1206    NYD_ENTER;
1207
1208    if (name != NULL) {
1209       addrspec_with_guts(1, name, &ag);
1210       ret = ag.ag_skinned;
1211       if (!(ag.ag_n_flags & NAME_NAME_SALLOC))
1212          ret = savestrbuf(ret, ag.ag_slen);
1213    }
1214    NYD_LEAVE;
1215    return ret;
1216 }
1217
1218 /* TODO addrspec_with_guts: RFC 5322
1219  * TODO addrspec_with_guts: trim whitespace ETC. ETC. ETC.!!! */
1220 FL int
1221 addrspec_with_guts(int doskin, char const *name, struct addrguts *agp)
1222 {
1223    char const *cp;
1224    char *cp2, *bufend, *nbuf, c, gotlt, gotaddr, lastsp;
1225    int rv = 1;
1226    NYD_ENTER;
1227
1228    memset(agp, 0, sizeof *agp);
1229
1230    if ((agp->ag_input = name) == NULL || (agp->ag_ilen = strlen(name)) == 0) {
1231       agp->ag_skinned = UNCONST(""); /* ok: NAME_SALLOC is not set */
1232       agp->ag_slen = 0;
1233       agp->ag_n_flags |= NAME_ADDRSPEC_CHECKED;
1234       NAME_ADDRSPEC_ERR_SET(agp->ag_n_flags, NAME_ADDRSPEC_ERR_EMPTY, 0);
1235       goto jleave;
1236    }
1237
1238    if (!doskin || !anyof(name, "(< ")) {
1239       /*agp->ag_iaddr_start = 0;*/
1240       agp->ag_iaddr_aend = agp->ag_ilen;
1241       agp->ag_skinned = UNCONST(name); /* (NAME_SALLOC not set) */
1242       agp->ag_slen = agp->ag_ilen;
1243       agp->ag_n_flags = NAME_SKINNED;
1244       goto jcheck;
1245    }
1246
1247    /* Something makes us think we have to perform the skin operation */
1248    nbuf = ac_alloc(agp->ag_ilen + 1);
1249    /*agp->ag_iaddr_start = 0;*/
1250    cp2 = bufend = nbuf;
1251    gotlt = gotaddr = lastsp = 0;
1252
1253    for (cp = name++; (c = *cp++) != '\0'; ) {
1254       switch (c) {
1255       case '(':
1256          cp = skip_comment(cp);
1257          lastsp = 0;
1258          break;
1259       case '"':
1260          /* Start of a "quoted-string".
1261           * Copy it in its entirety */
1262          /* XXX RFC: quotes are "semantically invisible"
1263           * XXX But it was explicitly added (Changelog.Heirloom,
1264           * XXX [9.23] released 11/15/00, "Do not remove quotes
1265           * XXX when skinning names"?  No more info.. */
1266          *cp2++ = c;
1267          while ((c = *cp) != '\0') { /* TODO improve */
1268             cp++;
1269             if (c == '"') {
1270                *cp2++ = c;
1271                break;
1272             }
1273             if (c != '\\')
1274                *cp2++ = c;
1275             else if ((c = *cp) != '\0') {
1276                *cp2++ = c;
1277                cp++;
1278             }
1279          }
1280          lastsp = 0;
1281          break;
1282       case ' ':
1283       case '\t':
1284          if (gotaddr == 1) {
1285             gotaddr = 2;
1286             agp->ag_iaddr_aend = PTR2SIZE(cp - name);
1287          }
1288          if (cp[0] == 'a' && cp[1] == 't' && blankchar(cp[2]))
1289             cp += 3, *cp2++ = '@';
1290          else if (cp[0] == '@' && blankchar(cp[1]))
1291             cp += 2, *cp2++ = '@';
1292          else
1293             lastsp = 1;
1294          break;
1295       case '<':
1296          agp->ag_iaddr_start = PTR2SIZE(cp - (name - 1));
1297          cp2 = bufend;
1298          gotlt = gotaddr = 1;
1299          lastsp = 0;
1300          break;
1301       case '>':
1302          if (gotlt) {
1303             /* (_addrspec_check() verifies these later!) */
1304             agp->ag_iaddr_aend = PTR2SIZE(cp - name);
1305             gotlt = 0;
1306             while ((c = *cp) != '\0' && c != ',') {
1307                cp++;
1308                if (c == '(')
1309                   cp = skip_comment(cp);
1310                else if (c == '"')
1311                   while ((c = *cp) != '\0') {
1312                      cp++;
1313                      if (c == '"')
1314                         break;
1315                      if (c == '\\' && *cp != '\0')
1316                         ++cp;
1317                   }
1318             }
1319             lastsp = 0;
1320             break;
1321          }
1322          /* FALLTRHOUGH */
1323       default:
1324          if (lastsp) {
1325             lastsp = 0;
1326             if (gotaddr)
1327                *cp2++ = ' ';
1328          }
1329          *cp2++ = c;
1330          if (c == ',') {
1331             if (!gotlt) {
1332                *cp2++ = ' ';
1333                for (; blankchar(*cp); ++cp)
1334                   ;
1335                lastsp = 0;
1336                bufend = cp2;
1337             }
1338          } else if (!gotaddr) {
1339             gotaddr = 1;
1340             agp->ag_iaddr_start = PTR2SIZE(cp - name);
1341          }
1342       }
1343    }
1344    agp->ag_slen = PTR2SIZE(cp2 - nbuf);
1345    if (agp->ag_iaddr_aend == 0)
1346       agp->ag_iaddr_aend = agp->ag_ilen;
1347
1348    agp->ag_skinned = savestrbuf(nbuf, agp->ag_slen);
1349    ac_free(nbuf);
1350    agp->ag_n_flags = NAME_NAME_SALLOC | NAME_SKINNED;
1351 jcheck:
1352    rv = _addrspec_check(doskin, agp);
1353 jleave:
1354    NYD_LEAVE;
1355    return rv;
1356 }
1357
1358 FL char *
1359 realname(char const *name)
1360 {
1361    char const *cp, *cq, *cstart = NULL, *cend = NULL;
1362    char *rname, *rp;
1363    struct str in, out;
1364    int quoted, good, nogood;
1365    NYD_ENTER;
1366
1367    if ((cp = UNCONST(name)) == NULL)
1368       goto jleave;
1369    for (; *cp != '\0'; ++cp) {
1370       switch (*cp) {
1371       case '(':
1372          if (cstart != NULL) {
1373             /* More than one comment in address, doesn't make sense to display
1374              * it without context.  Return the entire field */
1375             cp = mime_fromaddr(name);
1376             goto jleave;
1377          }
1378          cstart = cp++;
1379          cp = skip_comment(cp);
1380          cend = cp--;
1381          if (cend <= cstart)
1382             cend = cstart = NULL;
1383          break;
1384       case '"':
1385          while (*cp) {
1386             if (*++cp == '"')
1387                break;
1388             if (*cp == '\\' && cp[1])
1389                ++cp;
1390          }
1391          break;
1392       case '<':
1393          if (cp > name) {
1394             cstart = name;
1395             cend = cp;
1396          }
1397          break;
1398       case ',':
1399          /* More than one address. Just use the first one */
1400          goto jbrk;
1401       }
1402    }
1403
1404 jbrk:
1405    if (cstart == NULL) {
1406       if (*name == '<') {
1407          /* If name contains only a route-addr, the surrounding angle brackets
1408           * don't serve any useful purpose when displaying, so remove */
1409          cp = prstr(skin(name));
1410       } else
1411          cp = mime_fromaddr(name);
1412       goto jleave;
1413    }
1414
1415    /* Strip quotes. Note that quotes that appear within a MIME encoded word are
1416     * not stripped. The idea is to strip only syntactical relevant things (but
1417     * this is not necessarily the most sensible way in practice) */
1418    rp = rname = ac_alloc(PTR2SIZE(cend - cstart +1));
1419    quoted = 0;
1420    for (cp = cstart; cp < cend; ++cp) {
1421       if (*cp == '(' && !quoted) {
1422          cq = skip_comment(++cp);
1423          if (PTRCMP(--cq, >, cend))
1424             cq = cend;
1425          while (cp < cq) {
1426             if (*cp == '\\' && PTRCMP(cp + 1, <, cq))
1427                ++cp;
1428             *rp++ = *cp++;
1429          }
1430       } else if (*cp == '\\' && PTRCMP(cp + 1, <, cend))
1431          *rp++ = *++cp;
1432       else if (*cp == '"') {
1433          quoted = !quoted;
1434          continue;
1435       } else
1436          *rp++ = *cp;
1437    }
1438    *rp = '\0';
1439    in.s = rname;
1440    in.l = rp - rname;
1441    mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
1442    ac_free(rname);
1443    rname = savestr(out.s);
1444    free(out.s);
1445
1446    while (blankchar(*rname))
1447       ++rname;
1448    for (rp = rname; *rp != '\0'; ++rp)
1449       ;
1450    while (PTRCMP(--rp, >=, rname) && blankchar(*rp))
1451       *rp = '\0';
1452    if (rp == rname) {
1453       cp = mime_fromaddr(name);
1454       goto jleave;
1455    }
1456
1457    /* mime_fromhdr() has converted all nonprintable characters to question
1458     * marks now. These and blanks are considered uninteresting; if the
1459     * displayed part of the real name contains more than 25% of them, it is
1460     * probably better to display the plain email address instead */
1461    good = 0;
1462    nogood = 0;
1463    for (rp = rname; *rp != '\0' && PTRCMP(rp, <, rname + 20); ++rp)
1464       if (*rp == '?' || blankchar(*rp))
1465          ++nogood;
1466       else
1467          ++good;
1468    cp = (good * 3 < nogood) ? prstr(skin(name)) : rname;
1469 jleave:
1470    NYD_LEAVE;
1471    return UNCONST(cp);
1472 }
1473
1474 FL char *
1475 name1(struct message *mp, int reptype)
1476 {
1477    char *namebuf, *cp, *cp2, *linebuf = NULL /* TODO line pool */;
1478    size_t namesize, linesize = 0;
1479    FILE *ibuf;
1480    int f1st = 1;
1481    NYD_ENTER;
1482
1483    if ((cp = hfield1("from", mp)) != NULL && *cp != '\0')
1484       goto jleave;
1485    if (reptype == 0 && (cp = hfield1("sender", mp)) != NULL && *cp != '\0')
1486       goto jleave;
1487
1488    namebuf = smalloc(namesize = 1);
1489    namebuf[0] = 0;
1490    if (mp->m_flag & MNOFROM)
1491       goto jout;
1492    if ((ibuf = setinput(&mb, mp, NEED_HEADER)) == NULL)
1493       goto jout;
1494    if (readline_restart(ibuf, &linebuf, &linesize, 0) < 0)
1495       goto jout;
1496
1497 jnewname:
1498    if (namesize <= linesize)
1499       namebuf = srealloc(namebuf, namesize = linesize +1);
1500    for (cp = linebuf; *cp != '\0' && *cp != ' '; ++cp)
1501       ;
1502    for (; blankchar(*cp); ++cp)
1503       ;
1504    for (cp2 = namebuf + strlen(namebuf);
1505         *cp && !blankchar(*cp) && PTRCMP(cp2, <, namebuf + namesize -1);)
1506       *cp2++ = *cp++;
1507    *cp2 = '\0';
1508
1509    if (readline_restart(ibuf, &linebuf, &linesize, 0) < 0)
1510       goto jout;
1511    if ((cp = strchr(linebuf, 'F')) == NULL)
1512       goto jout;
1513    if (strncmp(cp, "From", 4)) /* XXX is_head? */
1514       goto jout;
1515    if (namesize <= linesize)
1516       namebuf = srealloc(namebuf, namesize = linesize + 1);
1517
1518    while ((cp = strchr(cp, 'r')) != NULL) {
1519       if (!strncmp(cp, "remote", 6)) {
1520          if ((cp = strchr(cp, 'f')) == NULL)
1521             break;
1522          if (strncmp(cp, "from", 4) != 0)
1523             break;
1524          if ((cp = strchr(cp, ' ')) == NULL)
1525             break;
1526          cp++;
1527          if (f1st) {
1528             strncpy(namebuf, cp, namesize);
1529             f1st = 0;
1530          } else {
1531             cp2 = strrchr(namebuf, '!') + 1;
1532             strncpy(cp2, cp, PTR2SIZE(namebuf + namesize - cp2));
1533          }
1534          namebuf[namesize - 2] = '!';
1535          namebuf[namesize - 1] = '\0';
1536          goto jnewname;
1537       }
1538       cp++;
1539    }
1540 jout:
1541    if (*namebuf != '\0' || ((cp = hfield1("return-path", mp))) == NULL ||
1542          *cp == '\0')
1543       cp = savestr(namebuf);
1544
1545    if (linebuf != NULL)
1546       free(linebuf);
1547    free(namebuf);
1548 jleave:
1549    NYD_LEAVE;
1550    return cp;
1551 }
1552
1553 FL char *
1554 subject_re_trim(char *s)
1555 {
1556    struct {
1557       ui8_t len;
1558       char  dat[7];
1559    } const *pp, ignored[] = { /* Update *reply-strings* manual upon change! */
1560       { 3, "re:" },
1561       { 3, "aw:" }, { 5, "antw:" }, /* de */
1562       { 0, "" }
1563    };
1564
1565    bool_t any = FAL0;
1566    char *orig_s = s, *re_st = NULL, *re_st_x;
1567    size_t re_l = 0 /* pacify CC */;
1568    NYD_ENTER;
1569
1570    if ((re_st_x = ok_vlook(reply_strings)) != NULL &&
1571          (re_l = strlen(re_st_x)) > 0) {
1572       re_st = ac_alloc(++re_l * 2);
1573       memcpy(re_st, re_st_x, re_l);
1574    }
1575
1576 jouter:
1577    while (*s != '\0') {
1578       while (spacechar(*s))
1579          ++s;
1580
1581       for (pp = ignored; pp->len > 0; ++pp)
1582          if (is_asccaseprefix(s, pp->dat)) {
1583             s += pp->len;
1584             any = TRU1;
1585             goto jouter;
1586          }
1587
1588       if (re_st != NULL) {
1589          char *cp;
1590
1591          memcpy(re_st_x = re_st + re_l, re_st, re_l);
1592          while ((cp = n_strsep(&re_st_x, ',', TRU1)) != NULL)
1593             if (is_asccaseprefix(s, cp)) {
1594                s += strlen(cp);
1595                any = TRU1;
1596                goto jouter;
1597             }
1598       }
1599       break;
1600    }
1601
1602    if (re_st != NULL)
1603       ac_free(re_st);
1604    NYD_LEAVE;
1605    return any ? s : orig_s;
1606 }
1607
1608 FL int
1609 msgidcmp(char const *s1, char const *s2)
1610 {
1611    int q1 = 0, q2 = 0, c1, c2;
1612    NYD_ENTER;
1613
1614    do {
1615       c1 = msgidnextc(&s1, &q1);
1616       c2 = msgidnextc(&s2, &q2);
1617       if (c1 != c2)
1618          break;
1619    } while (c1 && c2);
1620    NYD_LEAVE;
1621    return c1 - c2;
1622 }
1623
1624 FL int
1625 is_ign(char const *field, size_t fieldlen, struct ignoretab igta[2])
1626 {
1627    char *realfld;
1628    int rv;
1629    NYD_ENTER;
1630
1631    rv = 0;
1632    if (igta == NULL)
1633       goto jleave;
1634    rv = 1;
1635    if (igta == allignore)
1636       goto jleave;
1637
1638    /* Lowercase it so that "Status" and "status" will hash to the same place */
1639    realfld = ac_alloc(fieldlen +1);
1640    i_strcpy(realfld, field, fieldlen +1);
1641    if (igta[1].i_count > 0)
1642       rv = !member(realfld, igta + 1);
1643    else
1644       rv = member(realfld, igta);
1645    ac_free(realfld);
1646 jleave:
1647    NYD_LEAVE;
1648    return rv;
1649 }
1650
1651 FL int
1652 member(char const *realfield, struct ignoretab *table)
1653 {
1654    struct ignored *igp;
1655    int rv = 0;
1656    NYD_ENTER;
1657
1658    for (igp = table->i_head[hash(realfield)]; igp != 0; igp = igp->i_link)
1659       if (*igp->i_field == *realfield && !strcmp(igp->i_field, realfield)) {
1660          rv = 1;
1661          break;
1662       }
1663    NYD_LEAVE;
1664    return rv;
1665 }
1666
1667 FL char const *
1668 fakefrom(struct message *mp)
1669 {
1670    char const *name;
1671    NYD_ENTER;
1672
1673    if (((name = skin(hfield1("return-path", mp))) == NULL || *name == '\0' ) &&
1674          ((name = skin(hfield1("from", mp))) == NULL || *name == '\0'))
1675       /* XXX MAILER-DAEMON is what an old MBOX manual page says.
1676        * RFC 4155 however requires a RFC 5322 (2822) conforming
1677        * "addr-spec", but we simply can't provide that */
1678       name = "MAILER-DAEMON";
1679    NYD_LEAVE;
1680    return name;
1681 }
1682
1683 FL char const *
1684 fakedate(time_t t)
1685 {
1686    char *cp, *cq;
1687    NYD_ENTER;
1688
1689    cp = ctime(&t);
1690    for (cq = cp; *cq != '\0' && *cq != '\n'; ++cq)
1691       ;
1692    *cq = '\0';
1693    cp = savestr(cp);
1694    NYD_LEAVE;
1695    return cp;
1696 }
1697
1698 #ifdef HAVE_IMAP_SEARCH
1699 FL time_t
1700 unixtime(char const *fromline)
1701 {
1702    char const *fp;
1703    char *xp;
1704    time_t t;
1705    int i, year, month, day, hour, minute, second, tzdiff;
1706    struct tm *tmptr;
1707    NYD2_ENTER;
1708
1709    for (fp = fromline; *fp != '\0' && *fp != '\n'; ++fp)
1710       ;
1711    fp -= 24;
1712    if (PTR2SIZE(fp - fromline) < 7)
1713       goto jinvalid;
1714    if (fp[3] != ' ')
1715       goto jinvalid;
1716    for (i = 0;;) {
1717       if (!strncmp(fp + 4, month_names[i], 3))
1718          break;
1719       if (month_names[++i][0] == '\0')
1720          goto jinvalid;
1721    }
1722    month = i + 1;
1723    if (fp[7] != ' ')
1724       goto jinvalid;
1725    day = strtol(fp + 8, &xp, 10);
1726    if (*xp != ' ' || xp != fp + 10)
1727       goto jinvalid;
1728    hour = strtol(fp + 11, &xp, 10);
1729    if (*xp != ':' || xp != fp + 13)
1730       goto jinvalid;
1731    minute = strtol(fp + 14, &xp, 10);
1732    if (*xp != ':' || xp != fp + 16)
1733       goto jinvalid;
1734    second = strtol(fp + 17, &xp, 10);
1735    if (*xp != ' ' || xp != fp + 19)
1736       goto jinvalid;
1737    year = strtol(fp + 20, &xp, 10);
1738    if (xp != fp + 24)
1739       goto jinvalid;
1740    if ((t = combinetime(year, month, day, hour, minute, second)) == (time_t)-1)
1741       goto jinvalid;
1742    tzdiff = t - mktime(gmtime(&t));
1743    tmptr = localtime(&t);
1744    if (tmptr->tm_isdst > 0)
1745       tzdiff += 3600;
1746    t -= tzdiff;
1747 jleave:
1748    NYD2_LEAVE;
1749    return t;
1750 jinvalid:
1751    t = n_time_epoch();
1752    goto jleave;
1753 }
1754 #endif /* HAVE_IMAP_SEARCH */
1755
1756 FL time_t
1757 rfctime(char const *date)
1758 {
1759    char const *cp = date;
1760    char *x;
1761    time_t t;
1762    int i, year, month, day, hour, minute, second;
1763    NYD2_ENTER;
1764
1765    if ((cp = nexttoken(cp)) == NULL)
1766       goto jinvalid;
1767    if (alphachar(cp[0]) && alphachar(cp[1]) && alphachar(cp[2]) &&
1768          cp[3] == ',') {
1769       if ((cp = nexttoken(&cp[4])) == NULL)
1770          goto jinvalid;
1771    }
1772    day = strtol(cp, &x, 10); /* XXX strtol */
1773    if ((cp = nexttoken(x)) == NULL)
1774       goto jinvalid;
1775    for (i = 0;;) {
1776       if (!strncmp(cp, month_names[i], 3))
1777          break;
1778       if (month_names[++i][0] == '\0')
1779          goto jinvalid;
1780    }
1781    month = i + 1;
1782    if ((cp = nexttoken(&cp[3])) == NULL)
1783       goto jinvalid;
1784    /* RFC 5322, 4.3:
1785     *  Where a two or three digit year occurs in a date, the year is to be
1786     *  interpreted as follows: If a two digit year is encountered whose
1787     *  value is between 00 and 49, the year is interpreted by adding 2000,
1788     *  ending up with a value between 2000 and 2049.  If a two digit year
1789     *  is encountered with a value between 50 and 99, or any three digit
1790     *  year is encountered, the year is interpreted by adding 1900 */
1791    year = strtol(cp, &x, 10); /* XXX strtol */
1792    i = (int)PTR2SIZE(x - cp);
1793    if (i == 2 && year >= 0 && year <= 49)
1794       year += 2000;
1795    else if (i == 3 || (i == 2 && year >= 50 && year <= 99))
1796       year += 1900;
1797    if ((cp = nexttoken(x)) == NULL)
1798       goto jinvalid;
1799    hour = strtol(cp, &x, 10); /* XXX strtol */
1800    if (*x != ':')
1801       goto jinvalid;
1802    cp = &x[1];
1803    minute = strtol(cp, &x, 10);
1804    if (*x == ':') {
1805       cp = x + 1;
1806       second = strtol(cp, &x, 10);
1807    } else
1808       second = 0;
1809
1810    if ((t = combinetime(year, month, day, hour, minute, second)) == (time_t)-1)
1811       goto jinvalid;
1812    if ((cp = nexttoken(x)) != NULL) {
1813       char buf[3];
1814       int sign = 1;
1815
1816       switch (*cp) {
1817       case '+':
1818          sign = -1;
1819          /* FALLTHRU */
1820       case '-':
1821          ++cp;
1822          break;
1823       }
1824       if (digitchar(cp[0]) && digitchar(cp[1]) && digitchar(cp[2]) &&
1825             digitchar(cp[3])) {
1826          long tadj;
1827          buf[2] = '\0';
1828          buf[0] = cp[0];
1829          buf[1] = cp[1];
1830          tadj = strtol(buf, NULL, 10) * 3600;/*XXX strtrol*/
1831          buf[0] = cp[2];
1832          buf[1] = cp[3];
1833          tadj += strtol(buf, NULL, 10) * 60; /* XXX strtol*/
1834          if (sign < 0)
1835             tadj = -tadj;
1836          t += tadj;
1837       }
1838       /* TODO WE DO NOT YET PARSE (OBSOLETE) ZONE NAMES
1839        * TODO once again, Christos Zoulas and NetBSD Mail have done
1840        * TODO a really good job already, but using strptime(3), which
1841        * TODO is not portable.  Nonetheless, WE must improve, not
1842        * TODO at last because we simply ignore obsolete timezones!!
1843        * TODO See RFC 5322, 4.3! */
1844    }
1845 jleave:
1846    NYD2_LEAVE;
1847    return t;
1848 jinvalid:
1849    t = 0;
1850    goto jleave;
1851 }
1852
1853 #define is_leapyear(Y)  ((((Y) % 100 ? (Y) : (Y) / 100) & 3) == 0)
1854
1855 FL time_t
1856 combinetime(int year, int month, int day, int hour, int minute, int second)
1857 {
1858    time_t t;
1859    NYD2_ENTER;
1860
1861    if (second < 0 || minute < 0 || hour < 0 || day < 1) {
1862       t = (time_t)-1;
1863       goto jleave;
1864    }
1865
1866    t = second + minute * 60 + hour * 3600 + (day - 1) * 86400;
1867    if (month > 1)
1868       t += 86400 * 31;
1869    if (month > 2)
1870       t += 86400 * (is_leapyear(year) ? 29 : 28);
1871    if (month > 3)
1872       t += 86400 * 31;
1873    if (month > 4)
1874       t += 86400 * 30;
1875    if (month > 5)
1876       t += 86400 * 31;
1877    if (month > 6)
1878       t += 86400 * 30;
1879    if (month > 7)
1880       t += 86400 * 31;
1881    if (month > 8)
1882       t += 86400 * 31;
1883    if (month > 9)
1884       t += 86400 * 30;
1885    if (month > 10)
1886       t += 86400 * 31;
1887    if (month > 11)
1888       t += 86400 * 30;
1889    year -= 1900;
1890    t += (year - 70) * 31536000 + ((year - 69) / 4) * 86400 -
1891          ((year - 1) / 100) * 86400 + ((year + 299) / 400) * 86400;
1892 jleave:
1893    NYD2_LEAVE;
1894    return t;
1895 }
1896
1897 FL void
1898 substdate(struct message *m)
1899 {
1900    char const *cp;
1901    NYD_ENTER;
1902
1903    /* Determine the date to print in faked 'From ' lines. This is traditionally
1904     * the date the message was written to the mail file. Try to determine this
1905     * using RFC message header fields, or fall back to current time */
1906    if ((cp = hfield1("received", m)) != NULL) {
1907       while ((cp = nexttoken(cp)) != NULL && *cp != ';') {
1908          do
1909             ++cp;
1910          while (alnumchar(*cp));
1911       }
1912       if (cp && *++cp)
1913          m->m_time = rfctime(cp);
1914    }
1915    if (m->m_time == 0 || m->m_time > time_current.tc_time) {
1916       if ((cp = hfield1("date", m)) != NULL)
1917          m->m_time = rfctime(cp);
1918    }
1919    if (m->m_time == 0 || m->m_time > time_current.tc_time)
1920       m->m_time = time_current.tc_time;
1921    NYD_LEAVE;
1922 }
1923
1924 FL struct name const *
1925 check_from_and_sender(struct name const *fromfield,
1926    struct name const *senderfield)
1927 {
1928    struct name const *rv = NULL;
1929    NYD_ENTER;
1930
1931    if (senderfield != NULL) {
1932       if (senderfield->n_flink != NULL) {
1933          n_err(_("The \"Sender:\" field may contain only one address\n"));
1934          goto jleave;
1935       }
1936       rv = senderfield;
1937    }
1938
1939    if (fromfield != NULL) {
1940       if (fromfield->n_flink != NULL && senderfield == NULL) {
1941          n_err(_("A \"Sender:\" field is required with multiple "
1942             "addresses in \"From:\" field\n"));
1943          goto jleave;
1944       }
1945       if (rv == NULL)
1946          rv = fromfield;
1947    }
1948
1949    if (rv == NULL)
1950       rv = (struct name*)0x1;
1951 jleave:
1952    NYD_LEAVE;
1953    return rv;
1954 }
1955
1956 #ifdef HAVE_OPENSSL
1957 FL char *
1958 getsender(struct message *mp)
1959 {
1960    char *cp;
1961    struct name *np;
1962    NYD_ENTER;
1963
1964    if ((cp = hfield1("from", mp)) == NULL ||
1965          (np = lextract(cp, GEXTRA | GSKIN)) == NULL)
1966       cp = NULL;
1967    else
1968       cp = (np->n_flink != NULL) ? skin(hfield1("sender", mp)) : np->n_name;
1969    NYD_LEAVE;
1970    return cp;
1971 }
1972 #endif
1973
1974 FL int
1975 grab_headers(struct header *hp, enum gfield gflags, int subjfirst)
1976 {
1977    /* TODO grab_headers: again, check counts etc. against RFC;
1978     * TODO (now assumes check_from_and_sender() is called afterwards ++ */
1979    int errs;
1980    int volatile comma;
1981    NYD_ENTER;
1982
1983    errs = 0;
1984    comma = (ok_blook(bsdcompat) || ok_blook(bsdmsgs)) ? 0 : GCOMMA;
1985
1986    if (gflags & GTO)
1987       hp->h_to = grab_names("To: ", hp->h_to, comma, GTO | GFULL);
1988    if (subjfirst && (gflags & GSUBJECT))
1989       hp->h_subject = n_input_cp_addhist("Subject: ", hp->h_subject, TRU1);
1990    if (gflags & GCC)
1991       hp->h_cc = grab_names("Cc: ", hp->h_cc, comma, GCC | GFULL);
1992    if (gflags & GBCC)
1993       hp->h_bcc = grab_names("Bcc: ", hp->h_bcc, comma, GBCC | GFULL);
1994
1995    if (gflags & GEXTRA) {
1996       if (hp->h_from == NULL)
1997          hp->h_from = lextract(myaddrs(hp), GEXTRA | GFULL | GFULLEXTRA);
1998       hp->h_from = grab_names("From: ", hp->h_from, comma,
1999             GEXTRA | GFULL | GFULLEXTRA);
2000       if (hp->h_replyto == NULL)
2001          hp->h_replyto = lextract(ok_vlook(replyto), GEXTRA | GFULL);
2002       hp->h_replyto = grab_names("Reply-To: ", hp->h_replyto, comma,
2003             GEXTRA | GFULL);
2004       if (hp->h_sender == NULL)
2005          hp->h_sender = extract(ok_vlook(sender), GEXTRA | GFULL);
2006       hp->h_sender = grab_names("Sender: ", hp->h_sender, comma,
2007             GEXTRA | GFULL);
2008       if (hp->h_organization == NULL)
2009          hp->h_organization = ok_vlook(ORGANIZATION);
2010       hp->h_organization = n_input_cp_addhist("Organization: ",
2011             hp->h_organization, TRU1);
2012    }
2013
2014    if (!subjfirst && (gflags & GSUBJECT))
2015       hp->h_subject = n_input_cp_addhist("Subject: ", hp->h_subject, TRU1);
2016
2017    NYD_LEAVE;
2018    return errs;
2019 }
2020
2021 FL bool_t
2022 header_match(struct message *mp, struct search_expr const *sep)
2023 {
2024    struct str in, out;
2025    FILE *ibuf;
2026    int lc;
2027    size_t linesize = 0; /* TODO line pool */
2028    char *linebuf = NULL, *colon;
2029    bool_t rv = FAL0;
2030    NYD_ENTER;
2031
2032    if ((ibuf = setinput(&mb, mp, NEED_HEADER)) == NULL)
2033       goto jleave;
2034    if ((lc = mp->m_lines - 1) < 0)
2035       goto jleave;
2036
2037    if ((mp->m_flag & MNOFROM) == 0 &&
2038          readline_restart(ibuf, &linebuf, &linesize, 0) < 0)
2039       goto jleave;
2040    while (lc > 0) {
2041       if (gethfield(ibuf, &linebuf, &linesize, lc, &colon) <= 0)
2042          break;
2043       if (blankchar(*++colon))
2044          ++colon;
2045       in.l = strlen(in.s = colon);
2046       mime_fromhdr(&in, &out, TD_ICONV);
2047 #ifdef HAVE_REGEX
2048       if (sep->ss_sexpr == NULL)
2049          rv = (regexec(&sep->ss_regex, out.s, 0,NULL, 0) != REG_NOMATCH);
2050       else
2051 #endif
2052          rv = substr(out.s, sep->ss_sexpr);
2053       free(out.s);
2054       if (rv)
2055          break;
2056    }
2057
2058 jleave:
2059    if (linebuf != NULL)
2060       free(linebuf);
2061    NYD_LEAVE;
2062    return rv;
2063 }
2064
2065 /* s-it-mode */