list.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Message (search a.k.a. argument) list handling.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2014 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. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *    This product includes software developed by the University of
  22  *    California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  */
  39
  40 #ifndef HAVE_AMALGAMATION
  41 # include "nail.h"
  42 #endif
  43
  44 /* Token values returned by the scanner used for argument lists.
  45  * Also, sizes of scanner-related things */
  46 enum ltoken {
  47    TEOL           = 0,        /* End of the command line */
  48    TNUMBER        = 1,        /* A message number */
  49    TDASH          = 2,        /* A simple dash */
  50    TSTRING        = 3,        /* A string (possibly containing -) */
  51    TDOT           = 4,        /* A "." */
  52    TUP            = 5,        /* A "^" */
  53    TDOLLAR        = 6,        /* A "$" */
  54    TSTAR          = 7,        /* A "*" */
  55    TOPEN          = 8,        /* A '(' */
  56    TCLOSE         = 9,        /* A ')' */
  57    TPLUS          = 10,       /* A '+' */
  58    TERROR         = 11,       /* A lexical error */
  59    TCOMMA         = 12,       /* A ',' */
  60    TSEMI          = 13,       /* A ';' */
  61    TBACK          = 14        /* A '`' */
  62 };
  63
  64 #define REGDEP          2     /* Maximum regret depth. */
  65
  66 enum idfield {
  67    ID_REFERENCES,
  68    ID_IN_REPLY_TO
  69 };
  70
  71 enum {
  72    CMNEW    = 1<<0,  /* New messages */
  73    CMOLD    = 1<<1,  /* Old messages */
  74    CMUNREAD = 1<<2,  /* Unread messages */
  75    CMDELETED =1<<3,  /* Deleted messages */
  76    CMREAD   = 1<<4,  /* Read messages */
  77    CMFLAG   = 1<<5,  /* Flagged messages */
  78    CMANSWER = 1<<6,  /* Answered messages */
  79    CMDRAFT  = 1<<7,  /* Draft messages */
  80    CMSPAM   = 1<<8   /* Spam messages */
  81 };
  82
  83 struct coltab {
  84    char  co_char;    /* What to find past : */
  85    int   co_bit;     /* Associated modifier bit */
  86    int   co_mask;    /* m_status bits to mask */
  87    int   co_equal;   /* ... must equal this */
  88 };
  89
  90 struct lex {
  91    char        l_char;
  92    enum ltoken l_token;
  93 };
  94
  95 static struct coltab const _coltab[] = {
  96    { 'n',   CMNEW,      MNEW,       MNEW },
  97    { 'o',   CMOLD,      MNEW,       0 },
  98    { 'u',   CMUNREAD,   MREAD,      0 },
  99    { 'd',   CMDELETED,  MDELETED,   MDELETED },
 100    { 'r',   CMREAD,     MREAD,      MREAD },
 101    { 'f',   CMFLAG,     MFLAGGED,   MFLAGGED },
 102    { 'a',   CMANSWER,   MANSWERED,  MANSWERED },
 103    { 't',   CMDRAFT,    MDRAFTED,   MDRAFTED },
 104    { 's',   CMSPAM,     MSPAM,      MSPAM },
 105    { '\0',  0,          0,          0 }
 106 };
 107
 108 static struct lex const    _singles[] = {
 109    { '$',   TDOLLAR },
 110    { '.',   TDOT },
 111    { '^',   TUP },
 112    { '*',   TSTAR },
 113    { '-',   TDASH },
 114    { '+',   TPLUS },
 115    { '(',   TOPEN },
 116    { ')',   TCLOSE },
 117    { ',',   TCOMMA },
 118    { ';',   TSEMI },
 119    { '`',   TBACK },
 120    { '\0',  0 }
 121 };
 122
 123 static int     lastcolmod;
 124 static size_t  STRINGLEN;
 125 static int     lexnumber;              /* Number of TNUMBER from scan() */
 126 static char    *lexstring;             /* String from TSTRING, scan() */
 127 static int     regretp;                /* Pointer to TOS of regret tokens */
 128 static int     regretstack[REGDEP];    /* Stack of regretted tokens */
 129 static char    *string_stack[REGDEP];  /* Stack of regretted strings */
 130 static int     numberstack[REGDEP];    /* Stack of regretted numbers */
 131 static int     threadflag;             /* mark entire threads */
 132
 133 /* Append, taking care of resizes */
 134 static char ** add_to_namelist(char ***namelist, size_t *nmlsize,
 135                   char **np, char *string);
 136
 137 /* Mark all messages that the user wanted from the command line in the message
 138  * structure.  Return 0 on success, -1 on error */
 139 static int     markall(char *buf, int f);
 140
 141 /* Turn the character after a colon modifier into a bit value */
 142 static int     evalcol(int col);
 143
 144 /* Check the passed message number for legality and proper flags.  If f is
 145  * MDELETED, then either kind will do.  Otherwise, the message has to be
 146  * undeleted */
 147 static int     check(int mesg, int f);
 148
 149 /* Scan out a single lexical item and return its token number, updating the
 150  * string pointer passed **sp.  Also, store the value of the number or string
 151  * scanned in lexnumber or lexstring as appropriate.  In any event, store the
 152  * scanned `thing' in lexstring */
 153 static int     scan(char **sp);
 154
 155 /* Unscan the named token by pushing it onto the regret stack */
 156 static void    regret(int token);
 157
 158 /* Reset all the scanner global variables */
 159 static void    scaninit(void);
 160
 161 /* See if the passed name sent the passed message */
 162 static bool_t  _matchsender(struct message *mp, char const *str, bool_t allnet);
 163
 164 static bool_t  _matchmid(struct message *mp, char *id, enum idfield idfield);
 165
 166 /* See if the given string matches.
 167  * For the purpose of the scan, we ignore case differences.
 168  * This is the engine behind the `/' search */
 169 static bool_t  _match_dash(struct message *mp, char const *str);
 170
 171 /* See if the given search expression matches.
 172  * For the purpose of the scan, we ignore case differences.
 173  * This is the engine behind the `@[..]@' search */
 174 static bool_t  _match_at(struct message *mp, struct search_expr *sep);
 175
 176 /* Unmark the named message */
 177 static void    unmark(int mesg);
 178
 179 /* Return the message number corresponding to the passed meta character */
 180 static int     metamess(int meta, int f);
 181
 182 static char **
 183 add_to_namelist(char ***namelist, size_t *nmlsize, char **np, char *string)
 184 {
 185    size_t idx;
 186    NYD_ENTER;
 187
 188    if ((idx = PTR2SIZE(np - *namelist)) >= *nmlsize) {
 189       *namelist = srealloc(*namelist, (*nmlsize += 8) * sizeof *np);
 190       np = *namelist + idx;
 191    }
 192    *np++ = string;
 193    NYD_LEAVE;
 194    return np;
 195 }
 196
 197 static int
 198 markall(char *buf, int f)
 199 {
 200 #define markall_ret(i) do { rv = i; goto jleave; } while (0);
 201
 202    /* TODO use a bit carrier for all the states */
 203    char **np, **nq, **namelist, *bufp, *id = NULL, *cp;
 204    int rv = 0, i, tok, beg, other, valdot, colmod, colresult;
 205    struct message *mp, *mx;
 206    bool_t mc, star, topen, tback;
 207    size_t j, nmlsize;
 208    enum idfield idfield = ID_REFERENCES;
 209 #ifdef HAVE_IMAP
 210    int gotheaders;
 211 #endif
 212    NYD_ENTER;
 213
 214    lexstring = ac_alloc(STRINGLEN = 2 * strlen(buf) +1);
 215    valdot = (int)PTR2SIZE(dot - message + 1);
 216    colmod = 0;
 217
 218    for (i = 1; i <= msgCount; ++i) {
 219       enum mflag mf;
 220
 221       mf = message[i - 1].m_flag;
 222       if (mf & MMARK)
 223          mf |= MOLDMARK;
 224       else
 225          mf &= ~MOLDMARK;
 226       mf &= ~MMARK;
 227       message[i - 1].m_flag = mf;
 228    }
 229
 230    np = namelist = smalloc((nmlsize = 8) * sizeof *namelist);
 231    scaninit();
 232    bufp = buf;
 233    mc = FAL0;
 234    beg = star = other = topen = tback = FAL0;
 235 #ifdef HAVE_IMAP
 236    gotheaders = 0;
 237 #endif
 238
 239    for (tok = scan(&bufp); tok != TEOL;) {
 240       switch (tok) {
 241       case TNUMBER:
 242 number:
 243          if (star) {
 244             fprintf(stderr, _("No numbers mixed with *\n"));
 245             markall_ret(-1)
 246          }
 247          list_saw_numbers = TRU1;
 248          mc = TRU1;
 249          ++other;
 250          if (beg != 0) {
 251             if (check(lexnumber, f))
 252                markall_ret(-1)
 253             i = beg;
 254             while (mb.mb_threaded ? 1 : i <= lexnumber) {
 255                if (!(message[i - 1].m_flag & MHIDDEN) &&
 256                      (f == MDELETED || !(message[i - 1].m_flag & MDELETED)))
 257                   mark(i, f);
 258                if (mb.mb_threaded) {
 259                   if (i == lexnumber)
 260                      break;
 261                   mx = next_in_thread(&message[i - 1]);
 262                   if (mx == NULL)
 263                      markall_ret(-1)
 264                   i = (int)PTR2SIZE(mx - message + 1);
 265                } else
 266                   ++i;
 267             }
 268             beg = 0;
 269             break;
 270          }
 271          beg = lexnumber;
 272          if (check(beg, f))
 273             markall_ret(-1)
 274          tok = scan(&bufp);
 275          regret(tok);
 276          if (tok != TDASH) {
 277             mark(beg, f);
 278             beg = 0;
 279          }
 280          break;
 281
 282       case TPLUS:
 283          msglist_is_single = FAL0;
 284          if (beg != 0) {
 285             printf(_("Non-numeric second argument\n"));
 286             markall_ret(-1)
 287          }
 288          i = valdot;
 289          do {
 290             if (mb.mb_threaded) {
 291                mx = next_in_thread(message + i - 1);
 292                i = mx ? (int)PTR2SIZE(mx - message + 1) : msgCount + 1;
 293             } else
 294                ++i;
 295             if (i > msgCount) {
 296                fprintf(stderr, _("Referencing beyond EOF\n"));
 297                markall_ret(-1)
 298             }
 299          } while (message[i - 1].m_flag == MHIDDEN ||
 300                (message[i - 1].m_flag & MDELETED) != (unsigned)f);
 301          mark(i, f);
 302          break;
 303
 304       case TDASH:
 305          msglist_is_single = FAL0;
 306          if (beg == 0) {
 307             i = valdot;
 308             do {
 309                if (mb.mb_threaded) {
 310                   mx = prev_in_thread(message + i - 1);
 311                   i = mx ? (int)PTR2SIZE(mx - message + 1) : 0;
 312                } else
 313                   --i;
 314                if (i <= 0) {
 315                   fprintf(stderr, _("Referencing before 1\n"));
 316                   markall_ret(-1)
 317                }
 318             } while ((message[i - 1].m_flag & MHIDDEN) ||
 319                   (message[i - 1].m_flag & MDELETED) != (unsigned)f);
 320             mark(i, f);
 321          }
 322          break;
 323
 324       case TSTRING:
 325          msglist_is_single = FAL0;
 326          if (beg != 0) {
 327             fprintf(stderr, _("Non-numeric second argument\n"));
 328             markall_ret(-1)
 329          }
 330          ++other;
 331          if (lexstring[0] == ':') {
 332             colresult = evalcol(lexstring[1]);
 333             if (colresult == 0) {
 334                fprintf(stderr, _("Unknown colon modifier \"%s\"\n"),
 335                   lexstring);
 336                markall_ret(-1)
 337             }
 338             colmod |= colresult;
 339          }
 340          else
 341             np = add_to_namelist(&namelist, &nmlsize, np, savestr(lexstring));
 342          break;
 343
 344       case TOPEN:
 345 #ifdef HAVE_IMAP_SEARCH
 346          msglist_is_single = FAL0;
 347          if (imap_search(lexstring, f) == STOP)
 348             markall_ret(-1)
 349          topen = TRU1;
 350 #else
 351          fprintf(stderr, _(
 352             "`%s': the used selector is optional and not available\n"),
 353             lexstring);
 354          markall_ret(-1)
 355 #endif
 356          break;
 357
 358       case TDOLLAR:
 359       case TUP:
 360       case TDOT:
 361       case TSEMI:
 362          msglist_is_single = FAL0;
 363          lexnumber = metamess(lexstring[0], f);
 364          if (lexnumber == -1)
 365             markall_ret(-1)
 366          goto number;
 367
 368       case TBACK:
 369          msglist_is_single = FAL0;
 370          tback = TRU1;
 371          for (i = 1; i <= msgCount; i++) {
 372             if ((message[i - 1].m_flag & MHIDDEN) ||
 373                   (message[i - 1].m_flag & MDELETED) != (unsigned)f)
 374                continue;
 375             if (message[i - 1].m_flag & MOLDMARK)
 376                mark(i, f);
 377          }
 378          break;
 379
 380       case TSTAR:
 381          msglist_is_single = FAL0;
 382          if (other) {
 383             fprintf(stderr, _("Can't mix \"*\" with anything\n"));
 384             markall_ret(-1)
 385          }
 386          star = TRU1;
 387          break;
 388
 389       case TCOMMA:
 390          msglist_is_single = FAL0;
 391 #ifdef HAVE_IMAP
 392          if (mb.mb_type == MB_IMAP && gotheaders++ == 0)
 393             imap_getheaders(1, msgCount);
 394 #endif
 395          if (id == NULL && (cp = hfield1("in-reply-to", dot)) != NULL) {
 396             id = savestr(cp);
 397             idfield = ID_IN_REPLY_TO;
 398          }
 399          if (id == NULL && (cp = hfield1("references", dot)) != NULL) {
 400             struct name *enp;
 401
 402             if ((enp = extract(cp, GREF)) != NULL) {
 403                while (enp->n_flink != NULL)
 404                   enp = enp->n_flink;
 405                id = savestr(enp->n_name);
 406                idfield = ID_REFERENCES;
 407             }
 408          }
 409          if (id == NULL) {
 410             printf(_(
 411                "Cannot determine parent Message-ID of the current message\n"));
 412             markall_ret(-1)
 413          }
 414          break;
 415
 416       case TERROR:
 417          list_saw_numbers = TRU1;
 418          msglist_is_single = FAL0;
 419          markall_ret(-1)
 420       }
 421       threadflag = 0;
 422       tok = scan(&bufp);
 423    }
 424
 425    lastcolmod = colmod;
 426    np = add_to_namelist(&namelist, &nmlsize, np, NULL);
 427    --np;
 428    mc = FAL0;
 429    if (star) {
 430       for (i = 0; i < msgCount; ++i) {
 431          if (!(message[i].m_flag & MHIDDEN) &&
 432                (message[i].m_flag & MDELETED) == (unsigned)f) {
 433             mark(i + 1, f);
 434             mc = TRU1;
 435          }
 436       }
 437       if (!mc) {
 438          if (!inhook)
 439             printf(_("No applicable messages.\n"));
 440          markall_ret(-1)
 441       }
 442       markall_ret(0)
 443    }
 444
 445    if ((topen || tback) && !mc) {
 446       for (i = 0; i < msgCount; ++i)
 447          if (message[i].m_flag & MMARK)
 448             mc = TRU1;
 449       if (!mc) {
 450          if (!inhook) {
 451             if (tback)
 452                fprintf(stderr, _("No previously marked messages.\n"));
 453             else
 454                printf("No messages satisfy (criteria).\n");/*TODO tr*/
 455          }
 456          markall_ret(-1)
 457       }
 458    }
 459
 460    /* If no numbers were given, mark all messages, so that we can unmark
 461     * any whose sender was not selected if any user names were given */
 462    if ((np > namelist || colmod != 0 || id) && !mc)
 463       for (i = 1; i <= msgCount; ++i) {
 464          if (!(message[i - 1].m_flag & MHIDDEN) &&
 465                (message[i - 1].m_flag & MDELETED) == (unsigned)f)
 466             mark(i, f);
 467       }
 468
 469    /* If any names were given, eliminate any messages which don't match */
 470    if (np > namelist || id) {
 471       struct search_expr *sep = NULL;
 472       bool_t allnet;
 473
 474       /* The `@' search works with struct search_expr, so build an array.
 475        * To simplify array, i.e., regex_t destruction, and optimize for the
 476        * common case we walk the entire array even in case of errors */
 477       if (np > namelist) {
 478          sep = scalloc(PTR2SIZE(np - namelist), sizeof(*sep));
 479          for (j = 0, nq = namelist; *nq != NULL; ++j, ++nq) {
 480             char *x = *nq, *y;
 481
 482             sep[j].ss_sexpr = x;
 483             if (*x != '@' || rv < 0)
 484                continue;
 485
 486             for (y = x + 1;; ++y) {
 487                if (*y == '\0' || !fieldnamechar(*y)) {
 488                   x = NULL;
 489                   break;
 490                }
 491                if (*y == '@') {
 492                   x = y;
 493                   break;
 494                }
 495             }
 496             sep[j].ss_where = (x == NULL || x - 1 == *nq)
 497                   ? "subject" : savestrbuf(*nq + 1, PTR2SIZE(x - *nq) - 1);
 498
 499             x = (x == NULL ? *nq : x) + 1;
 500             if (*x == '\0') { /* XXX Simply remove from list instead? */
 501                fprintf(stderr, _("Empty `[@..]@' search expression\n"));
 502                rv = -1;
 503                continue;
 504             }
 505 #ifdef HAVE_REGEX
 506             if (anyof("^.[]*+?(){}|$", x)) {
 507                sep[j].ss_sexpr = NULL;
 508                if (regcomp(&sep[j].ss_reexpr, x,
 509                      REG_EXTENDED | REG_ICASE | REG_NOSUB) != 0) {
 510                   fprintf(stderr, _(
 511                      "Invalid regular expression: >>> %s <<<\n"), x);
 512                   rv = -1;
 513                   continue;
 514                }
 515             } else
 516 #endif
 517                sep[j].ss_sexpr = x;
 518          }
 519          if (rv < 0)
 520             goto jnamesearch_sepfree;
 521       }
 522
 523 #ifdef HAVE_IMAP
 524       if (mb.mb_type == MB_IMAP && gotheaders++ == 0)
 525          imap_getheaders(1, msgCount);
 526 #endif
 527       srelax_hold();
 528       allnet = ok_blook(allnet);
 529       for (i = 1; i <= msgCount; ++i) {
 530          mp = message + i - 1;
 531          j = 0;
 532          if (np > namelist) {
 533             for (nq = namelist; *nq != NULL; ++nq) {
 534                if (**nq == '@') {
 535                   if (_match_at(mp, sep + PTR2SIZE(nq - namelist))) {
 536                      ++j;
 537                      break;
 538                   }
 539                } else if (**nq == '/') {
 540                   if (_match_dash(mp, *nq)) {
 541                      ++j;
 542                      break;
 543                   }
 544                } else if (_matchsender(mp, *nq, allnet)) {
 545                   ++j;
 546                   break;
 547                }
 548             }
 549          }
 550          if (j == 0 && id && _matchmid(mp, id, idfield))
 551             ++j;
 552          if (j == 0)
 553             mp->m_flag &= ~MMARK;
 554          srelax();
 555       }
 556       srelax_rele();
 557
 558       /* Make sure we got some decent messages */
 559       j = 0;
 560       for (i = 1; i <= msgCount; ++i)
 561          if (message[i - 1].m_flag & MMARK) {
 562             ++j;
 563             break;
 564          }
 565       if (j == 0) {
 566          if (!inhook && np > namelist) {
 567             printf(_("No applicable messages from {%s"), namelist[0]);
 568             for (nq = namelist + 1; *nq != NULL; ++nq)
 569                printf(_(", %s"), *nq);
 570             printf(_("}\n"));
 571          } else if (id)
 572             printf(_("Parent message not found\n"));
 573          rv = -1;
 574          goto jnamesearch_sepfree;
 575       }
 576
 577 jnamesearch_sepfree:
 578       if (sep != NULL) {
 579 #ifdef HAVE_REGEX
 580          for (j = PTR2SIZE(np - namelist); j-- != 0;)
 581             if (sep[j].ss_sexpr == NULL)
 582                regfree(&sep[j].ss_reexpr);
 583 #endif
 584          free(sep);
 585       }
 586       if (rv < 0)
 587          goto jleave;
 588    }
 589
 590    /* If any colon modifiers were given, go through and unmark any
 591     * messages which do not satisfy the modifiers */
 592    if (colmod != 0) {
 593       for (i = 1; i <= msgCount; ++i) {
 594          struct coltab const *colp;
 595          bool_t bad = TRU1;
 596
 597          mp = message + i - 1;
 598          for (colp = _coltab; colp->co_char != '\0'; ++colp)
 599             if ((colp->co_bit & colmod) &&
 600                   ((mp->m_flag & colp->co_mask) == (unsigned)colp->co_equal))
 601                bad = FAL0;
 602          if (bad)
 603             unmark(i);
 604       }
 605       for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
 606          if (mp->m_flag & MMARK)
 607             break;
 608       if (PTRCMP(mp, >=, message + msgCount)) {
 609          struct coltab const *colp;
 610
 611          if (!inhook) {
 612             printf(_("No messages satisfy"));
 613             for (colp = _coltab; colp->co_char != '\0'; ++colp)
 614                if (colp->co_bit & colmod)
 615                   printf(" :%c", colp->co_char);
 616             printf("\n");
 617          }
 618          markall_ret(-1)
 619       }
 620    }
 621
 622    markall_ret(0)
 623 jleave:
 624    free(namelist);
 625    ac_free(lexstring);
 626    NYD_LEAVE;
 627    return rv;
 628
 629 #undef markall_ret
 630 }
 631
 632 static int
 633 evalcol(int col)
 634 {
 635    struct coltab const *colp;
 636    int rv;
 637    NYD_ENTER;
 638
 639    if (col == 0)
 640       rv = lastcolmod;
 641    else {
 642       rv = 0;
 643       for (colp = _coltab; colp->co_char != '\0'; ++colp)
 644          if (colp->co_char == col) {
 645             rv = colp->co_bit;
 646             break;
 647          }
 648    }
 649    NYD_LEAVE;
 650    return rv;
 651 }
 652
 653 static int
 654 check(int mesg, int f)
 655 {
 656    struct message *mp;
 657    NYD_ENTER;
 658
 659    if (mesg < 1 || mesg > msgCount) {
 660       printf(_("%d: Invalid message number\n"), mesg);
 661       goto jem1;
 662    }
 663    mp = message + mesg - 1;
 664    if (mp->m_flag & MHIDDEN ||
 665          (f != MDELETED && (mp->m_flag & MDELETED) != 0)) {
 666       fprintf(stderr, _("%d: Inappropriate message\n"), mesg);
 667       goto jem1;
 668    }
 669    f = 0;
 670 jleave:
 671    NYD_LEAVE;
 672    return f;
 673 jem1:
 674    f = -1;
 675    goto jleave;
 676 }
 677
 678 static int
 679 scan(char **sp)
 680 {
 681    char *cp, *cp2;
 682    int rv, c, inquote, quotec;
 683    struct lex const *lp;
 684    NYD_ENTER;
 685
 686    if (regretp >= 0) {
 687       strncpy(lexstring, string_stack[regretp], STRINGLEN);
 688       lexstring[STRINGLEN -1] = '\0';
 689       lexnumber = numberstack[regretp];
 690       rv = regretstack[regretp--];
 691       goto jleave;
 692    }
 693
 694    cp = *sp;
 695    cp2 = lexstring;
 696    c = *cp++;
 697
 698    /* strip away leading white space */
 699    while (blankchar(c))
 700       c = *cp++;
 701
 702    /* If no characters remain, we are at end of line, so report that */
 703    if (c == '\0') {
 704       *sp = --cp;
 705       rv = TEOL;
 706       goto jleave;
 707    }
 708
 709    /* Select members of a message thread */
 710    if (c == '&') {
 711       threadflag = 1;
 712       if (*cp == '\0' || spacechar(*cp)) {
 713          lexstring[0] = '.';
 714          lexstring[1] = '\0';
 715          *sp = cp;
 716          rv = TDOT;
 717          goto jleave;
 718       }
 719       c = *cp++;
 720    }
 721
 722    /* If the leading character is a digit, scan the number and convert it
 723     * on the fly.  Return TNUMBER when done */
 724    if (digitchar(c)) {
 725       lexnumber = 0;
 726       while (digitchar(c)) {
 727          lexnumber = lexnumber*10 + c - '0';
 728          *cp2++ = c;
 729          c = *cp++;
 730       }
 731       *cp2 = '\0';
 732       *sp = --cp;
 733       rv = TNUMBER;
 734       goto jleave;
 735    }
 736
 737    /* An IMAP SEARCH list. Note that TOPEN has always been included in
 738     * singles[] in Mail and mailx. Thus although there is no formal
 739     * definition for (LIST) lists, they do not collide with historical
 740     * practice because a subject string (LIST) could never been matched
 741     * this way */
 742    if (c == '(') {
 743       ui32_t level = 1;
 744       inquote = 0;
 745       *cp2++ = c;
 746       do {
 747          if ((c = *cp++&0377) == '\0') {
 748 jmtop:
 749             fprintf(stderr, "Missing \")\".\n");
 750             rv = TERROR;
 751             goto jleave;
 752          }
 753          if (inquote && c == '\\') {
 754             *cp2++ = c;
 755             c = *cp++&0377;
 756             if (c == '\0')
 757                goto jmtop;
 758          } else if (c == '"')
 759             inquote = !inquote;
 760          else if (inquote)
 761             /*EMPTY*/;
 762          else if (c == '(')
 763             ++level;
 764          else if (c == ')')
 765             --level;
 766          else if (spacechar(c)) {
 767             /* Replace unquoted whitespace by single space characters, to make
 768              * the string IMAP SEARCH conformant */
 769             c = ' ';
 770             if (cp2[-1] == ' ')
 771                --cp2;
 772          }
 773          *cp2++ = c;
 774       } while (c != ')' || level > 0);
 775       *cp2 = '\0';
 776       *sp = cp;
 777       rv = TOPEN;
 778       goto jleave;
 779    }
 780
 781    /* Check for single character tokens; return such if found */
 782    for (lp = _singles; lp->l_char != '\0'; ++lp)
 783       if (c == lp->l_char) {
 784          lexstring[0] = c;
 785          lexstring[1] = '\0';
 786          *sp = cp;
 787          rv = lp->l_token;
 788          goto jleave;
 789       }
 790
 791    /* We've got a string!  Copy all the characters of the string into
 792     * lexstring, until we see a null, space, or tab.  If the lead character is
 793     * a " or ', save it and scan until you get another */
 794    quotec = 0;
 795    if (c == '\'' || c == '"') {
 796       quotec = c;
 797       c = *cp++;
 798    }
 799    while (c != '\0') {
 800       if (quotec == 0 && c == '\\' && *cp != '\0')
 801          c = *cp++;
 802       if (c == quotec) {
 803          ++cp;
 804          break;
 805       }
 806       if (quotec == 0 && blankchar(c))
 807          break;
 808       if (PTRCMP(cp2 - lexstring, <, STRINGLEN - 1))
 809          *cp2++ = c;
 810       c = *cp++;
 811    }
 812    if (quotec && c == 0) {
 813       fprintf(stderr, _("Missing %c\n"), quotec);
 814       rv = TERROR;
 815       goto jleave;
 816    }
 817    *sp = --cp;
 818    *cp2 = '\0';
 819    rv = TSTRING;
 820 jleave:
 821    NYD_LEAVE;
 822    return rv;
 823 }
 824
 825 static void
 826 regret(int token)
 827 {
 828    NYD_ENTER;
 829    if (++regretp >= REGDEP)
 830       panic(_("Too many regrets"));
 831    regretstack[regretp] = token;
 832    lexstring[STRINGLEN -1] = '\0';
 833    string_stack[regretp] = savestr(lexstring);
 834    numberstack[regretp] = lexnumber;
 835    NYD_LEAVE;
 836 }
 837
 838 static void
 839 scaninit(void)
 840 {
 841    NYD_ENTER;
 842    regretp = -1;
 843    threadflag = 0;
 844    NYD_LEAVE;
 845 }
 846
 847 static bool_t
 848 _matchsender(struct message *mp, char const *str, bool_t allnet)
 849 {
 850    bool_t rv;
 851    NYD_ENTER;
 852
 853    if (allnet) {
 854       char *cp = nameof(mp, 0);
 855
 856       do {
 857          if ((*cp == '@' || *cp == '\0') && (*str == '@' || *str == '\0')) {
 858             rv = TRU1;
 859             goto jleave;
 860          }
 861          if (*cp != *str)
 862             break;
 863       } while (++cp, *str++ != '\0');
 864       rv = FAL0;
 865       goto jleave;
 866    }
 867    rv = !strcmp(str, (*(ok_blook(showname) ? &realname : &skin))(name1(mp, 0)));
 868 jleave:
 869    NYD_LEAVE;
 870    return rv;
 871 }
 872
 873 static bool_t
 874 _matchmid(struct message *mp, char *id, enum idfield idfield)
 875 {
 876    char *cp;
 877    bool_t rv;
 878    NYD_ENTER;
 879
 880    if ((cp = hfield1("message-id", mp)) != NULL) {
 881       switch (idfield) {
 882       case ID_REFERENCES:
 883          rv = !msgidcmp(id, cp);
 884          goto jleave;
 885       case ID_IN_REPLY_TO: {
 886          struct name *np;
 887
 888          if ((np = extract(id, GREF)) != NULL)
 889             do {
 890                if (!msgidcmp(np->n_name, cp)) {
 891                   rv = TRU1;
 892                   goto jleave;
 893                }
 894             } while ((np = np->n_flink) != NULL);
 895          break;
 896       }
 897       }
 898    }
 899    rv = FAL0;
 900 jleave:
 901    NYD_LEAVE;
 902    return rv;
 903 }
 904
 905 static bool_t
 906 _match_dash(struct message *mp, char const *str)
 907 {
 908    static char lastscan[128];
 909
 910    struct str in, out;
 911    char *hfield, *hbody;
 912    bool_t rv;
 913    NYD_ENTER;
 914
 915    if (*++str == '\0') {
 916       str = lastscan;
 917    } else {
 918       strncpy(lastscan, str, sizeof lastscan); /* XXX use new n_str object! */
 919       lastscan[sizeof lastscan -1] = '\0';
 920    }
 921
 922    /* Now look, ignoring case, for the word in the string */
 923    if (ok_blook(searchheaders) && (hfield = strchr(str, ':'))) {
 924       size_t l = PTR2SIZE(hfield - str);
 925       hfield = ac_alloc(l +1);
 926       memcpy(hfield, str, l);
 927       hfield[l] = '\0';
 928       hbody = hfieldX(hfield, mp);
 929       ac_free(hfield);
 930       hfield = UNCONST(str + l + 1);
 931    } else {
 932       hfield = UNCONST(str);
 933       hbody = hfield1("subject", mp);
 934    }
 935    if (hbody == NULL) {
 936       rv = FAL0;
 937       goto jleave;
 938    }
 939
 940    in.s = hbody;
 941    in.l = strlen(hbody);
 942    mime_fromhdr(&in, &out, TD_ICONV);
 943    rv = substr(out.s, hfield);
 944    free(out.s);
 945 jleave:
 946    NYD_LEAVE;
 947    return rv;
 948 }
 949
 950 static bool_t
 951 _match_at(struct message *mp, struct search_expr *sep)
 952 {
 953    struct str in, out;
 954    char *nfield, *cfield;
 955    bool_t rv = FAL0;
 956    NYD_ENTER;
 957
 958    nfield = savestr(sep->ss_where);
 959
 960    while ((cfield = n_strsep(&nfield, ',', TRU1)) != NULL) {
 961       if (!asccasecmp(cfield, "body") ||
 962             (cfield[1] == '\0' && cfield[0] == '>')) {
 963          rv = FAL0;
 964 jmsg:
 965          if ((rv = message_match(mp, sep, rv)))
 966             break;
 967       } else if (!asccasecmp(cfield, "text") ||
 968             (cfield[1] == '\0' && cfield[0] == '=')) {
 969          rv = TRU1;
 970          goto jmsg;
 971       } else if (!asccasecmp(cfield, "header") ||
 972             (cfield[1] == '\0' && cfield[0] == '<')) {
 973          if ((rv = header_match(mp, sep)))
 974             break;
 975       } else if ((in.s = hfieldX(cfield, mp)) == NULL)
 976          continue;
 977       else {
 978          in.l = strlen(in.s);
 979          mime_fromhdr(&in, &out, TD_ICONV);
 980 #ifdef HAVE_REGEX
 981          if (sep->ss_sexpr == NULL)
 982             rv = (regexec(&sep->ss_reexpr, out.s, 0,NULL, 0) != REG_NOMATCH);
 983          else
 984 #endif
 985             rv = substr(out.s, sep->ss_sexpr);
 986          free(out.s);
 987          if (rv)
 988             break;
 989       }
 990    }
 991    NYD_LEAVE;
 992    return rv;
 993 }
 994
 995 static void
 996 unmark(int mesg)
 997 {
 998    size_t i;
 999    NYD_ENTER;
1000
1001    i = (size_t)mesg;
1002    if (i < 1 || UICMP(z, i, >, msgCount))
1003       panic(_("Bad message number to unmark"));
1004    message[i - 1].m_flag &= ~MMARK;
1005    NYD_LEAVE;
1006 }
1007
1008 static int
1009 metamess(int meta, int f)
1010 {
1011    int c, m;
1012    struct message *mp;
1013    NYD_ENTER;
1014
1015    c = meta;
1016    switch (c) {
1017    case '^': /* First 'good' message left */
1018       mp = mb.mb_threaded ? threadroot : message;
1019       while (PTRCMP(mp, <, message + msgCount)) {
1020          if (!(mp->m_flag & MHIDDEN) && (mp->m_flag & MDELETED) == (ui32_t)f) {
1021             c = (int)PTR2SIZE(mp - message + 1);
1022             goto jleave;
1023          }
1024          if (mb.mb_threaded) {
1025             mp = next_in_thread(mp);
1026             if (mp == NULL)
1027                break;
1028          } else
1029             ++mp;
1030       }
1031       if (!inhook)
1032          printf(_("No applicable messages\n"));
1033       goto jem1;
1034
1035    case '$': /* Last 'good message left */
1036       mp = mb.mb_threaded
1037             ? this_in_thread(threadroot, -1) : message + msgCount - 1;
1038       while (mp >= message) {
1039          if (!(mp->m_flag & MHIDDEN) && (mp->m_flag & MDELETED) == (ui32_t)f) {
1040             c = (int)PTR2SIZE(mp - message + 1);
1041             goto jleave;
1042          }
1043          if (mb.mb_threaded) {
1044             mp = prev_in_thread(mp);
1045             if (mp == NULL)
1046                break;
1047          } else
1048             --mp;
1049       }
1050       if (!inhook)
1051          printf(_("No applicable messages\n"));
1052       goto jem1;
1053
1054    case '.':
1055       /* Current message */
1056       m = dot - message + 1;
1057       if ((dot->m_flag & MHIDDEN) || (dot->m_flag & MDELETED) != (ui32_t)f) {
1058          printf(_("%d: Inappropriate message\n"), m);
1059          goto jem1;
1060       }
1061       c = m;
1062       break;
1063
1064    case ';':
1065       /* Previously current message */
1066       if (prevdot == NULL) {
1067          fprintf(stderr, _("No previously current message\n"));
1068          goto jem1;
1069       }
1070       m = prevdot - message + 1;
1071       if ((prevdot->m_flag & MHIDDEN) ||
1072             (prevdot->m_flag & MDELETED) != (ui32_t)f) {
1073          fprintf(stderr, _("%d: Inappropriate message\n"), m);
1074          goto jem1;
1075       }
1076       c = m;
1077       break;
1078
1079    default:
1080       fprintf(stderr, _("Unknown metachar (%c)\n"), c);
1081       goto jem1;
1082    }
1083 jleave:
1084    NYD_LEAVE;
1085    return c;
1086 jem1:
1087    c = -1;
1088    goto jleave;
1089 }
1090
1091 FL int
1092 getmsglist(char *buf, int *vector, int flags)
1093 {
1094    int *ip, mc;
1095    struct message *mp;
1096    NYD_ENTER;
1097
1098    list_saw_numbers =
1099    msglist_is_single = FAL0;
1100
1101    if (msgCount == 0) {
1102       *vector = 0;
1103       mc = 0;
1104       goto jleave;
1105    }
1106
1107    msglist_is_single = TRU1;
1108    if (markall(buf, flags) < 0) {
1109       mc = -1;
1110       goto jleave;
1111    }
1112
1113    ip = vector;
1114    if (inhook & 2) {
1115       mc = 0;
1116       for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1117          if (mp->m_flag & MMARK) {
1118             if (!(mp->m_flag & MNEWEST))
1119                unmark((int)PTR2SIZE(mp - message + 1));
1120             else
1121                ++mc;
1122          }
1123       if (mc == 0) {
1124          mc = -1;
1125          goto jleave;
1126       }
1127    }
1128
1129    if (mb.mb_threaded == 0) {
1130       for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1131          if (mp->m_flag & MMARK)
1132             *ip++ = (int)PTR2SIZE(mp - message + 1);
1133    } else {
1134       for (mp = threadroot; mp != NULL; mp = next_in_thread(mp))
1135          if (mp->m_flag & MMARK)
1136             *ip++ = (int)PTR2SIZE(mp - message + 1);
1137    }
1138    *ip = 0;
1139    mc = (int)PTR2SIZE(ip - vector);
1140    msglist_is_single = (mc == 1);
1141 jleave:
1142    NYD_LEAVE;
1143    return mc;
1144 }
1145
1146 FL int
1147 getrawlist(char const *line, size_t linesize, char **argv, int argc,
1148    int echolist)
1149 {
1150    char c, *cp2, quotec, *linebuf;
1151    char const *cp;
1152    int argn;
1153    NYD_ENTER;
1154
1155    list_saw_numbers = FAL0;
1156
1157    argn = 0;
1158    cp = line;
1159    linebuf = ac_alloc(linesize +1);
1160    for (;;) {
1161       for (; blankchar(*cp); ++cp)
1162          ;
1163       if (*cp == '\0')
1164          break;
1165       if (argn >= argc - 1) {
1166          fprintf(stderr, _(
1167             "Too many elements in the list; excess discarded.\n"));
1168          break;
1169       }
1170       cp2 = linebuf;
1171       quotec = '\0';
1172       while ((c = *cp) != '\0') {
1173          cp++;
1174          if (quotec != '\0') {
1175             if (c == quotec) {
1176                quotec = '\0';
1177                if (echolist)
1178                   *cp2++ = c;
1179             } else if (c == '\\')
1180                switch (c = *cp++) {
1181                case '\0':
1182                   *cp2++ = '\\';
1183                   cp--;
1184                   break;
1185                /*
1186                case '0': case '1': case '2': case '3':
1187                case '4': case '5': case '6': case '7':
1188                   c -= '0';
1189                   if (*cp >= '0' && *cp <= '7')
1190                      c = c * 8 + *cp++ - '0';
1191                   if (*cp >= '0' && *cp <= '7')
1192                      c = c * 8 + *cp++ - '0';
1193                   *cp2++ = c;
1194                   break;
1195                case 'b':
1196                   *cp2++ = '\b';
1197                   break;
1198                case 'f':
1199                   *cp2++ = '\f';
1200                   break;
1201                case 'n':
1202                   *cp2++ = '\n';
1203                   break;
1204                case 'r':
1205                   *cp2++ = '\r';
1206                   break;
1207                case 't':
1208                   *cp2++ = '\t';
1209                   break;
1210                case 'v':
1211                   *cp2++ = '\v';
1212                   break;
1213                */
1214                default:
1215                   if (cp[-1] != quotec || echolist)
1216                      *cp2++ = '\\';
1217                   *cp2++ = c;
1218                }
1219             /*else if (c == '^') {
1220                c = *cp++;
1221                if (c == '?')
1222                   *cp2++ = '\177';
1223                /\* null doesn't show up anyway *\/
1224                else if ((c >= 'A' && c <= '_') ||
1225                    (c >= 'a' && c <= 'z'))
1226                   *cp2++ = c & 037;
1227                else {
1228                   *cp2++ = '^';
1229                   cp--;
1230                }
1231             }*/ else
1232                *cp2++ = c;
1233          } else if (c == '"' || c == '\'') {
1234             if (echolist)
1235                *cp2++ = c;
1236             quotec = c;
1237          } else if (c == '\\' && !echolist) {
1238             if (*cp)
1239                *cp2++ = *cp++;
1240             else
1241                *cp2++ = c;
1242          } else if (blankchar(c))
1243             break;
1244          else
1245             *cp2++ = c;
1246       }
1247       *cp2 = '\0';
1248       argv[argn++] = savestr(linebuf);
1249    }
1250    argv[argn] = NULL;
1251    ac_free(linebuf);
1252    NYD_LEAVE;
1253    return argn;
1254 }
1255
1256 FL int
1257 first(int f, int m)
1258 {
1259    struct message *mp;
1260    int rv;
1261    NYD_ENTER;
1262
1263    if (msgCount == 0) {
1264       rv = 0;
1265       goto jleave;
1266    }
1267
1268    f &= MDELETED;
1269    m &= MDELETED;
1270    for (mp = dot;
1271          mb.mb_threaded ? (mp != NULL) : PTRCMP(mp, <, message + msgCount);
1272          mb.mb_threaded ? (mp = next_in_thread(mp)) : ++mp) {
1273       if (!(mp->m_flag & MHIDDEN) && (mp->m_flag & m) == (ui32_t)f) {
1274          rv = (int)PTR2SIZE(mp - message + 1);
1275          goto jleave;
1276       }
1277    }
1278
1279    if (dot > message) {
1280       for (mp = dot - 1; (mb.mb_threaded ? (mp != NULL) : (mp >= message));
1281             mb.mb_threaded ? (mp = prev_in_thread(mp)) : --mp) {
1282          if (!(mp->m_flag & MHIDDEN) && (mp->m_flag & m) == (ui32_t)f) {
1283             rv = (int)PTR2SIZE(mp - message + 1);
1284             goto jleave;
1285          }
1286       }
1287    }
1288    rv = 0;
1289 jleave:
1290    NYD_LEAVE;
1291    return rv;
1292 }
1293
1294 FL void
1295 mark(int mesg, int f)
1296 {
1297    struct message *mp;
1298    int i;
1299    NYD_ENTER;
1300
1301    i = mesg;
1302    if (i < 1 || i > msgCount)
1303       panic(_("Bad message number to mark"));
1304    if (mb.mb_threaded == 1 && threadflag) {
1305       if (!(message[i - 1].m_flag & MHIDDEN)) {
1306          if (f == MDELETED || !(message[i - 1].m_flag & MDELETED))
1307          message[i - 1].m_flag |= MMARK;
1308       }
1309
1310       if (message[i - 1].m_child) {
1311          mp = message[i - 1].m_child;
1312          mark((int)PTR2SIZE(mp - message + 1), f);
1313          for (mp = mp->m_younger; mp != NULL; mp = mp->m_younger)
1314             mark((int)PTR2SIZE(mp - message + 1), f);
1315       }
1316    } else
1317       message[i - 1].m_flag |= MMARK;
1318    NYD_LEAVE;
1319 }
1320
1321 /* s-it-mode */