lex.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ (Lexical processing of) Commands, and the event mainloop.
   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 #include <fcntl.h>
  45
  46 struct cmd {
  47    char const     *name;         /* Name of command */
  48    int            (*func)(void*); /* Implementor of command */
  49    enum argtype   argtype;       /* Arglist type (see below) */
  50    short          msgflag;       /* Required flags of msgs*/
  51    short          msgmask;       /* Relevant flags of msgs */
  52 #ifdef HAVE_DOCSTRINGS
  53    int            docid;         /* Translation id of .doc */
  54    char const     *doc;          /* One line doc for command */
  55 #endif
  56 };
  57 /* Yechh, can't initialize unions */
  58 #define minargs   msgflag        /* Minimum argcount for RAWLIST */
  59 #define maxargs   msgmask        /* Max argcount for RAWLIST */
  60
  61 struct cmd_ghost {
  62    struct cmd_ghost  *next;
  63    struct str        cmd;        /* Data follows after .name */
  64    char              name[VFIELD_SIZE(sizeof(size_t))];
  65 };
  66
  67 static int              *_msgvec;
  68 static int              _reset_on_stop;   /* do a reset() if stopped */
  69 static sighandler_type  _oldpipe;
  70 static struct cmd_ghost *_cmd_ghosts;
  71 /* _cmd_tab[] after fun protos */
  72
  73 /* Update mailname (if name != NULL) and displayname, return wether displayname
  74  * was large enough to swallow mailname */
  75 static bool_t  _update_mailname(char const *name);
  76 #ifdef HAVE_C90AMEND1 /* TODO unite __narrow_{pre,suf}fix() into one fun! */
  77 SINLINE size_t __narrow_prefix(char const *cp, size_t maxl);
  78 SINLINE size_t __narrow_suffix(char const *cp, size_t cpl, size_t maxl);
  79 #endif
  80
  81 /* Isolate the command from the arguments */
  82 static char *  _lex_isolate(char const *comm);
  83
  84 /* Get first-fit, or NULL */
  85 static struct cmd const * _lex(char const *comm);
  86
  87 /* Command ghost handling */
  88 static int     _ghost(void *v);
  89 static int     _unghost(void *v);
  90
  91 /* Print a list of all commands */
  92 static int     _pcmdlist(void *v);
  93 static int     __pcmd_cmp(void const *s1, void const *s2);
  94
  95 /* Print the binaries compiled-in features */
  96 static int     _features(void *v);
  97
  98 /* Print the binaries version number */
  99 static int     _version(void *v);
 100
 101 static void stop(int s);
 102 static void hangup(int s);
 103
 104 /* List of all commands */
 105 static struct cmd const _cmd_tab[] = {
 106 #include "cmd_tab.h"
 107 };
 108
 109 #ifdef HAVE_C90AMEND1
 110 SINLINE size_t
 111 __narrow_prefix(char const *cp, size_t maxl)
 112 {
 113         int err;
 114         size_t i, ok;
 115
 116         for (err = ok = i = 0; i < maxl;) {
 117                 int ml = mblen(cp, maxl - i);
 118                 if (ml < 0) { /* XXX _narrow_prefix(): mblen() error; action? */
 119                         (void)mblen(NULL, 0);
 120                         err = 1;
 121                         ml = 1;
 122                 } else {
 123                         if (! err)
 124                                 ok = i;
 125                         err = 0;
 126                         if (ml == 0)
 127                                 break;
 128                 }
 129                 cp += ml;
 130                 i += ml;
 131         }
 132         return ok;
 133 }
 134
 135 SINLINE size_t
 136 __narrow_suffix(char const *cp, size_t cpl, size_t maxl)
 137 {
 138         int err;
 139         size_t i, ok;
 140
 141         for (err = ok = i = 0; cpl > maxl || err;) {
 142                 int ml = mblen(cp, cpl);
 143                 if (ml < 0) { /* XXX _narrow_suffix(): mblen() error; action? */
 144                         (void)mblen(NULL, 0);
 145                         err = 1;
 146                         ml = 1;
 147                 } else {
 148                         if (! err)
 149                                 ok = i;
 150                         err = 0;
 151                         if (ml == 0)
 152                                 break;
 153                 }
 154                 cp += ml;
 155                 i += ml;
 156                 cpl -= ml;
 157         }
 158         return ok;
 159 }
 160 #endif /* HAVE_C90AMEND1 */
 161
 162 static bool_t
 163 _update_mailname(char const *name)
 164 {
 165    char tbuf[MAXPATHLEN], *mailp, *dispp;
 166    size_t i, j;
 167    bool_t rv;
 168
 169    /* Don't realpath(3) if it's only an update request */
 170    if (name != NULL) {
 171 #ifdef HAVE_REALPATH
 172       enum protocol p = which_protocol(name);
 173       if (p == PROTO_FILE || p == PROTO_MAILDIR) {
 174          if (realpath(name, mailname) == NULL) {
 175             fprintf(stderr, tr(151, "Can't canonicalize `%s'\n"), name);
 176             rv = FAL0;
 177             goto jleave;
 178          }
 179       } else
 180 #endif
 181          n_strlcpy(mailname, name, sizeof(mailname));
 182    }
 183
 184    mailp = mailname;
 185    dispp = displayname;
 186
 187    /* Don't display an absolute path but "+FOLDER" if under *folder* */
 188    if (getfold(tbuf, sizeof tbuf)) {
 189       i = strlen(tbuf);
 190       if (i < sizeof(tbuf) - 1)
 191          tbuf[i++] = '/';
 192       if (strncmp(tbuf, mailp, i) == 0) {
 193          mailp += i;
 194          *dispp++ = '+';
 195       }
 196    }
 197
 198    /* We want to see the name of the folder .. on the screen */
 199    i = strlen(mailp);
 200    if ((rv = (i < sizeof(displayname) - 1)))
 201       memcpy(dispp, mailp, i + 1);
 202    else {
 203       /* Avoid disrupting multibyte sequences (if possible) */
 204 #ifndef HAVE_C90AMEND1
 205       j = sizeof(displayname) / 3 - 1;
 206       i -= sizeof(displayname) - (1/* + */ + 3) - j;
 207 #else
 208       j = __narrow_prefix(mailp, sizeof(displayname) / 3);
 209       i = j + __narrow_suffix(mailp + j, i - j,
 210          sizeof(displayname) - (1/* + */ + 3 + 1) - j);
 211 #endif
 212       snprintf(dispp, sizeof(displayname), "%.*s...%s",
 213          (int)j, mailp, mailp + i);
 214    }
 215 #ifdef HAVE_REALPATH
 216 jleave:
 217 #endif
 218    return rv;
 219 }
 220
 221 static char *
 222 _lex_isolate(char const *comm)
 223 {
 224    while (*comm && strchr(" \t0123456789$^.:/-+*'\",;(`", *comm) == NULL)
 225       ++comm;
 226    return UNCONST(comm);
 227 }
 228
 229 static struct cmd const *
 230 _lex(char const *comm) /* TODO **command hashtable**! linear list search!!! */
 231 {
 232    struct cmd const *cp;
 233
 234    for (cp = _cmd_tab; cp->name != NULL; ++cp)
 235       if (*comm == *cp->name && is_prefix(comm, cp->name))
 236          goto jleave;
 237    cp = NULL;
 238 jleave:
 239    return cp;
 240 }
 241
 242 static int
 243 _ghost(void *v)
 244 {
 245    char const **argv = (char const **)v;
 246    struct cmd_ghost *lcg, *cg;
 247    size_t nl, cl;
 248
 249    /* Show the list? */
 250    if (*argv == NULL) {
 251       printf(tr(144, "Command ghosts are:\n"));
 252       for (nl = 0, cg = _cmd_ghosts; cg != NULL; cg = cg->next) {
 253          cl = strlen(cg->name) + 5 + cg->cmd.l + 3;
 254          if ((nl += cl) >= (size_t)scrnwidth) {
 255             nl = cl;
 256             printf("\n");
 257          }
 258          printf((cg->next != NULL ? "%s -> <%s>, " : "%s -> <%s>\n"),
 259             cg->name, cg->cmd.s);
 260       }
 261       v = NULL;
 262       goto jleave;
 263    }
 264
 265    /* Request to add new ghost */
 266    if (argv[1] == NULL || argv[1][0] == '\0' || argv[2] != NULL) {
 267       fprintf(stderr, tr(159, "Usage: %s\n"),
 268          tr(425, "Define a <ghost> of <command>, or list all ghosts"));
 269       v = NULL;
 270       goto jleave;
 271    }
 272
 273    /* Check that we can deal with this one */
 274    switch (argv[0][0]) {
 275    case '|':
 276    case '~':
 277    case '?':
 278    case '#':
 279       /* FALLTHRU */
 280    case '\0':
 281       goto jecanon;
 282    default:
 283       if (argv[0] == _lex_isolate(argv[0])) {
 284 jecanon:
 285          fprintf(stderr, tr(151, "Can't canonicalize `%s'\n"), argv[0]);
 286          v = NULL;
 287          goto jleave;
 288       }
 289       break;
 290    }
 291
 292    /* Always recreate */
 293    for (lcg = NULL, cg = _cmd_ghosts; cg != NULL; lcg = cg, cg = cg->next)
 294       if (strcmp(cg->name, argv[0]) == 0) {
 295          if (lcg != NULL)
 296             lcg->next = cg->next;
 297          else
 298             _cmd_ghosts = cg->next;
 299          free(cg);
 300          break;
 301       }
 302
 303    /* Need a new one */
 304    nl = strlen(argv[0]) + 1;
 305    cl = strlen(argv[1]) + 1;
 306    cg = smalloc(sizeof(*cg) - VFIELD_SIZEOF(struct cmd_ghost, name) + nl + cl);
 307    cg->next = _cmd_ghosts;
 308    memcpy(cg->name, argv[0], nl);
 309    cg->cmd.s = cg->name + nl;
 310    cg->cmd.l = cl - 1;
 311    memcpy(cg->cmd.s, argv[1], cl);
 312
 313    _cmd_ghosts = cg;
 314 jleave:
 315    return (v == NULL);
 316 }
 317
 318 static int
 319 _unghost(void *v)
 320 {
 321    int rv = 0;
 322    char const **argv = v, *cp;
 323    struct cmd_ghost *lcg, *cg;
 324
 325    while ((cp = *argv++) != NULL) {
 326       for (lcg = NULL, cg = _cmd_ghosts; cg != NULL; lcg = cg, cg = cg->next)
 327          if (strcmp(cg->name, cp) == 0) {
 328             if (lcg != NULL)
 329                lcg->next = cg->next;
 330             else
 331                _cmd_ghosts = cg->next;
 332             free(cg);
 333             goto jouter;
 334          }
 335       fprintf(stderr, tr(91, "Unknown command: `%s'\n"), cp);
 336       rv = 1;
 337 jouter:
 338       ;
 339    }
 340    return rv;
 341 }
 342
 343 static int
 344 __pcmd_cmp(void const *s1, void const *s2)
 345 {
 346    struct cmd const * const *c1 = s1, * const *c2 = s2;
 347    return (strcmp((*c1)->name, (*c2)->name));
 348 }
 349
 350 static int
 351 _pcmdlist(void *v)
 352 {
 353    struct cmd const **cpa, *cp, **cursor;
 354    size_t i;
 355    (void)v;
 356
 357    for (i = 0; _cmd_tab[i].name != NULL; ++i)
 358       ;
 359    ++i;
 360    cpa = ac_alloc(sizeof(cp) * i);
 361
 362    for (i = 0; (cp = _cmd_tab + i)->name != NULL; ++i)
 363       cpa[i] = cp;
 364    cpa[i] = NULL;
 365
 366    qsort(cpa, i, sizeof(cp), &__pcmd_cmp);
 367
 368    printf(tr(14, "Commands are:\n"));
 369    for (i = 0, cursor = cpa; (cp = *cursor++) != NULL;) {
 370       size_t j;
 371       if (cp->func == &ccmdnotsupp)
 372          continue;
 373       j = strlen(cp->name) + 2;
 374       if ((i += j) > 72) {
 375          i = j;
 376          printf("\n");
 377       }
 378       printf((*cursor != NULL ? "%s, " : "%s\n"), cp->name);
 379    }
 380
 381    ac_free(cpa);
 382    return 0;
 383 }
 384
 385 static int
 386 _features(void *v)
 387 {
 388    UNUSED(v);
 389    printf(tr(523, "Features: %s\n"), features);
 390    return 0;
 391 }
 392
 393 static int
 394 _version(void *v)
 395 {
 396    UNUSED(v);
 397    printf(tr(111, "Version %s\n"), version);
 398    return 0;
 399 }
 400
 401 /*
 402  * Set up editing on the given file name.
 403  * If the first character of name is %, we are considered to be
 404  * editing the file, otherwise we are reading our mail which has
 405  * signficance for mbox and so forth.
 406  *
 407  * nmail: Check for new mail in the current folder only.
 408  */
 409 FL int
 410 setfile(char const *name, int nmail)
 411 {
 412         FILE *ibuf;
 413         int i, compressed = 0;
 414         struct stat stb;
 415         bool_t isedit;
 416         char const *who = name[1] ? name + 1 : myname;
 417         static int shudclob;
 418         size_t offset;
 419         int omsgCount = 0;
 420         struct shortcut *sh;
 421         struct flock    flp;
 422
 423         /* Note we don't 'userid(myname) != getuid()', preliminary steps are usually
 424          * necessary to make a mailbox accessible by a different user, and if that
 425          * has happened, let's just let the usual file perms decide */
 426         isedit = (*name != '%' && ((sh = get_shortcut(name)) == NULL ||
 427                         *sh->sh_long != '%'));
 428         if ((name = expand(name)) == NULL)
 429                 return (-1);
 430
 431         switch (which_protocol(name)) {
 432         case PROTO_FILE:
 433                 break;
 434         case PROTO_MAILDIR:
 435                 return (maildir_setfile(name, nmail, isedit));
 436 #ifdef HAVE_POP3
 437         case PROTO_POP3:
 438                 shudclob = 1;
 439                 return (pop3_setfile(name, nmail, isedit));
 440 #endif
 441 #ifdef HAVE_IMAP
 442         case PROTO_IMAP:
 443                 shudclob = 1;
 444                 if (nmail) {
 445                         if (mb.mb_type == MB_CACHE)
 446                                 return 1;
 447                 }
 448                 return imap_setfile(name, nmail, isedit);
 449 #endif
 450         default:
 451                 fprintf(stderr, tr(217, "Cannot handle protocol: %s\n"), name);
 452                 return (-1);
 453         }
 454
 455         if ((ibuf = Zopen(name, "r", &compressed)) == NULL) {
 456                 if ((!isedit && errno == ENOENT) || nmail) {
 457                         if (nmail)
 458                                 goto jnonmail;
 459                         goto nomail;
 460                 }
 461                 perror(name);
 462                 return(-1);
 463         }
 464
 465         if (fstat(fileno(ibuf), &stb) < 0) {
 466                 Fclose(ibuf);
 467                 if (nmail)
 468                         goto jnonmail;
 469                 perror("fstat");
 470                 return (-1);
 471         }
 472
 473         if (S_ISDIR(stb.st_mode)) {
 474                 Fclose(ibuf);
 475                 if (nmail)
 476                         goto jnonmail;
 477                 errno = EISDIR;
 478                 perror(name);
 479                 return (-1);
 480         } else if (S_ISREG(stb.st_mode)) {
 481                 /*EMPTY*/
 482         } else {
 483                 Fclose(ibuf);
 484                 if (nmail)
 485                         goto jnonmail;
 486                 errno = EINVAL;
 487                 perror(name);
 488                 return (-1);
 489         }
 490
 491         /*
 492          * Looks like all will be well.  We must now relinquish our
 493          * hold on the current set of stuff.  Must hold signals
 494          * while we are reading the new file, else we will ruin
 495          * the message[] data structure.
 496          */
 497
 498         hold_sigs(); /* TODO note on this one in quit.c:quit() */
 499         if (shudclob && !nmail)
 500                 quit();
 501 #ifdef HAVE_SOCKETS
 502         if (!nmail && mb.mb_sock.s_fd >= 0)
 503                 sclose(&mb.mb_sock);
 504 #endif
 505
 506         /*
 507          * Copy the messages into /tmp
 508          * and set pointers.
 509          */
 510
 511         flp.l_type = F_RDLCK;
 512         flp.l_start = 0;
 513         flp.l_whence = SEEK_SET;
 514         if (!nmail) {
 515                 mb.mb_type = MB_FILE;
 516                 mb.mb_perm = (options & OPT_R_FLAG) ? 0 : MB_DELE|MB_EDIT;
 517                 mb.mb_compressed = compressed;
 518                 if (compressed) {
 519                         if (compressed & 0200)
 520                                 mb.mb_perm = 0;
 521                 } else {
 522                         if ((i = open(name, O_WRONLY)) < 0)
 523                                 mb.mb_perm = 0;
 524                         else
 525                                 close(i);
 526                 }
 527                 if (shudclob) {
 528                         if (mb.mb_itf) {
 529                                 fclose(mb.mb_itf);
 530                                 mb.mb_itf = NULL;
 531                         }
 532                         if (mb.mb_otf) {
 533                                 fclose(mb.mb_otf);
 534                                 mb.mb_otf = NULL;
 535                         }
 536                 }
 537                 shudclob = 1;
 538                 edit = isedit;
 539                 initbox(name);
 540                 offset = 0;
 541                 flp.l_len = 0;
 542                 if (!edit && fcntl(fileno(ibuf), F_SETLKW, &flp) < 0) {
 543                         perror("Unable to lock mailbox");
 544                         Fclose(ibuf);
 545                         return -1;
 546                 }
 547         } else /* nmail */{
 548                 fseek(mb.mb_otf, 0L, SEEK_END);
 549                 fseek(ibuf, mailsize, SEEK_SET);
 550                 offset = mailsize;
 551                 omsgCount = msgCount;
 552                 flp.l_len = offset;
 553                 if (!edit && fcntl(fileno(ibuf), F_SETLKW, &flp) < 0)
 554                         goto jnonmail;
 555         }
 556         mailsize = fsize(ibuf);
 557         if (nmail && (size_t)mailsize <= offset) {
 558                 rele_sigs();
 559                 goto jnonmail;
 560         }
 561         setptr(ibuf, offset);
 562         setmsize(msgCount);
 563         if (nmail && mb.mb_sorted) {
 564                 mb.mb_threaded = 0;
 565                 sort((void *)-1);
 566         }
 567         Fclose(ibuf);
 568         rele_sigs();
 569         if (!nmail)
 570                 sawcom = FAL0;
 571         if ((!edit || nmail) && msgCount == 0) {
 572 jnonmail:
 573                 if (!nmail) {
 574                         if (!ok_blook(emptystart))
 575 nomail:                         fprintf(stderr, tr(88, "No mail for %s\n"),
 576                                         who);
 577                 }
 578                 return 1;
 579         }
 580         if (nmail)
 581                 newmailinfo(omsgCount);
 582         return 0;
 583 }
 584
 585 FL int
 586 newmailinfo(int omsgCount)
 587 {
 588         int     mdot;
 589         int     i;
 590
 591         for (i = 0; i < omsgCount; i++)
 592                 message[i].m_flag &= ~MNEWEST;
 593         if (msgCount > omsgCount) {
 594                 for (i = omsgCount; i < msgCount; i++)
 595                         message[i].m_flag |= MNEWEST;
 596                 printf(tr(158, "New mail has arrived.\n"));
 597                 if (msgCount - omsgCount == 1)
 598                         printf(tr(214, "Loaded 1 new message.\n"));
 599                 else
 600                         printf(tr(215, "Loaded %d new messages.\n"),
 601                                 msgCount - omsgCount);
 602         } else
 603                 printf(tr(224, "Loaded %d messages.\n"), msgCount);
 604         callhook(mailname, 1);
 605         mdot = getmdot(1);
 606         if (ok_blook(header))
 607                 print_headers(omsgCount + 1, msgCount);
 608         return mdot;
 609 }
 610
 611 FL void
 612 commands(void)
 613 {
 614    struct eval_ctx ev;
 615    int n;
 616
 617    if (!sourcing) {
 618       if (safe_signal(SIGINT, SIG_IGN) != SIG_IGN)
 619          safe_signal(SIGINT, onintr);
 620       if (safe_signal(SIGHUP, SIG_IGN) != SIG_IGN)
 621          safe_signal(SIGHUP, hangup);
 622       /* TODO We do a lot of redundant signal handling, especially
 623        * TODO with the command line editor(s); try to merge this */
 624       safe_signal(SIGTSTP, stop);
 625       safe_signal(SIGTTOU, stop);
 626       safe_signal(SIGTTIN, stop);
 627    }
 628    _oldpipe = safe_signal(SIGPIPE, SIG_IGN);
 629    safe_signal(SIGPIPE, _oldpipe);
 630
 631    memset(&ev, 0, sizeof ev);
 632
 633    setexit();
 634    for (;;) {
 635       interrupts = 0;
 636       handlerstacktop = NULL;
 637
 638       if (!sourcing && (options & OPT_INTERACTIVE)) {
 639          char *cp;
 640
 641          if ((cp = ok_vlook(newmail)) == NULL)
 642             cp = ok_vlook(autoinc); /* TODO legacy */
 643          if ((options & OPT_TTYIN) && (cp != NULL || mb.mb_type == MB_IMAP)) {
 644             struct stat st;
 645
 646             n = (cp != NULL && strcmp(cp, "noimap") && strcmp(cp, "nopoll"));
 647             if ((mb.mb_type == MB_FILE && stat(mailname, &st) == 0 &&
 648                      st.st_size > mailsize) ||
 649 #ifdef HAVE_IMAP
 650                   (mb.mb_type == MB_IMAP && imap_newmail(n) > (cp == NULL)) ||
 651 #endif
 652                   (mb.mb_type == MB_MAILDIR && n != 0)) {
 653                size_t odot = PTR2SIZE(dot - message);
 654                bool_t odid = did_print_dot;
 655
 656                setfile(mailname, 1);
 657                if (mb.mb_type != MB_IMAP) {
 658                   dot = message + odot;
 659                   did_print_dot = odid;
 660                }
 661             }
 662          }
 663
 664          _reset_on_stop = 1;
 665          exit_status = 0;
 666       }
 667
 668 #ifdef HAVE_COLOUR
 669       colour_table = NULL; /* XXX intermediate hack */
 670 #endif
 671       sreset(sourcing);
 672       if (!sourcing) {
 673          char *cp;
 674
 675          /* TODO Note: this buffer may contain a password.  We should redefine
 676           * TODO the code flow which has to do that */
 677          if ((cp = termios_state.ts_linebuf) != NULL) {
 678             termios_state.ts_linebuf = NULL;
 679             termios_state.ts_linesize = 0;
 680             free(cp); /* TODO pool give-back */
 681          }
 682          /* TODO Due to expand-on-tab of NCL the buffer may grow */
 683          if (ev.ev_line.l > LINESIZE * 3) {
 684             free(ev.ev_line.s); /* TODO pool! but what? */
 685             ev.ev_line.s = NULL;
 686             ev.ev_line.l = 0;
 687          }
 688       }
 689
 690       /* Read a line of commands and handle end of file specially */
 691 jreadline:
 692       n = readline_input(NULL, TRU1, &ev.ev_line.s, &ev.ev_line.l,
 693             ev.ev_new_content);
 694       _reset_on_stop = 0;
 695       if (n < 0) {
 696          /* EOF */
 697          if (loading)
 698             break;
 699          if (sourcing) {
 700             unstack();
 701             continue;
 702          }
 703          if ((options & OPT_INTERACTIVE) && ok_blook(ignoreeof)) {
 704             printf(tr(89, "Use `quit' to quit.\n"));
 705             continue;
 706          }
 707          break;
 708       }
 709
 710       inhook = 0;
 711       if (evaluate(&ev))
 712          break;
 713       if (exit_status != EXIT_OK && (options & OPT_BATCH_FLAG) &&
 714             ok_blook(batch_exit_on_error))
 715          break;
 716       if (!sourcing && (options & OPT_INTERACTIVE)) {
 717          if (ev.ev_new_content != NULL)
 718             goto jreadline;
 719          if (ev.ev_add_history)
 720             tty_addhist(ev.ev_line.s);
 721       }
 722    }
 723
 724    if (ev.ev_line.s != NULL)
 725       free(ev.ev_line.s);
 726    if (sourcing)
 727       sreset(FAL0);
 728 }
 729
 730 FL int
 731 execute(char *linebuf, int contxt, size_t linesize) /* XXX LEGACY */
 732 {
 733    struct eval_ctx ev;
 734 #ifdef HAVE_COLOUR
 735    struct colour_table *ct_save;
 736 #endif
 737    int rv;
 738
 739    /* TODO Maybe recursion from within collect.c!  As long as we don't have
 740     * TODO a value carrier that transports the entire state of a recursion
 741     * TODO we need to save away also the colour table */
 742 #ifdef HAVE_COLOUR
 743    ct_save = colour_table;
 744    colour_table = NULL;
 745 #endif
 746
 747    memset(&ev, 0, sizeof ev);
 748    ev.ev_line.s = linebuf;
 749    ev.ev_line.l = linesize;
 750    ev.ev_is_recursive = (contxt != 0);
 751    rv = evaluate(&ev);
 752
 753 #ifdef HAVE_COLOUR
 754    colour_table = ct_save;
 755 #endif
 756
 757    return rv;
 758 }
 759
 760 FL int
 761 evaluate(struct eval_ctx *evp)
 762 {
 763    struct str line;
 764    char _wordbuf[2], *arglist[MAXARGC], *cp, *word;
 765    struct cmd_ghost *cg = NULL;
 766    struct cmd const *com = NULL;
 767    int muvec[2], c, e = 1;
 768
 769    line = evp->ev_line; /* XXX don't change original (buffer pointer) */
 770    evp->ev_add_history = FAL0;
 771    evp->ev_new_content = NULL;
 772
 773    /* Command ghosts that refer to shell commands or macro expansion restart */
 774 jrestart:
 775
 776    /* Strip the white space away from the beginning of the command */
 777    for (cp = line.s; whitechar(*cp); ++cp)
 778       ;
 779    line.l -= PTR2SIZE(cp - line.s);
 780
 781    /* Ignore comments */
 782    if (*cp == '#')
 783       goto jleave0;
 784
 785    /* Handle ! differently to get the correct lexical conventions */
 786    if (*cp == '!') {
 787       if (sourcing) {
 788          fprintf(stderr, tr(90, "Can't `!' while sourcing\n"));
 789          goto jleave;
 790       }
 791       shell(++cp);
 792       goto jleave0;
 793    }
 794
 795    /* Isolate the actual command; since it may not necessarily be
 796     * separated from the arguments (as in `p1') we need to duplicate it to
 797     * be able to create a NUL terminated version.
 798     * We must be aware of several special one letter commands here */
 799    arglist[0] = cp;
 800    switch (*cp) {
 801    case '|':
 802    case '~':
 803    case '?':
 804       ++cp;
 805       /* FALLTHRU */
 806    case '\0':
 807       break;
 808    default:
 809       cp = _lex_isolate(cp);
 810       break;
 811    }
 812    c = (int)PTR2SIZE(cp - arglist[0]);
 813    line.l -= c;
 814    word = (c < (int)sizeof _wordbuf) ? _wordbuf : salloc(c + 1);
 815    memcpy(word, arglist[0], c);
 816    word[c] = '\0';
 817
 818    /* Look up the command; if not found, bitch.
 819     * Normally, a blank command would map to the first command in the
 820     * table; while sourcing, however, we ignore blank lines to eliminate
 821     * confusion; act just the same for ghosts */
 822    if (*word == '\0') {
 823       if (sourcing || cg != NULL)
 824          goto jleave0;
 825       com = _cmd_tab + 0;
 826       goto jexec;
 827    }
 828
 829    /* If this is the first evaluation, check command ghosts */
 830    if (cg == NULL) {
 831       /* TODO relink list head, so it's sorted on usage over time?
 832        * TODO in fact, there should be one hashmap over all commands and ghosts
 833        * TODO so that the lookup could be made much more efficient than it is
 834        * TODO now (two adjacent list searches! */
 835       for (cg = _cmd_ghosts; cg != NULL; cg = cg->next)
 836          if (strcmp(word, cg->name) == 0) {
 837             if (line.l > 0) {
 838                size_t i = cg->cmd.l;
 839                line.s = salloc(i + 1 + line.l +1);
 840                memcpy(line.s, cg->cmd.s, i);
 841                line.s[i++] = ' ';
 842                memcpy(line.s + i, cp, line.l);
 843                line.s[i += line.l] = '\0';
 844                line.l = i;
 845             } else {
 846                line.s = cg->cmd.s;
 847                line.l = cg->cmd.l;
 848             }
 849             goto jrestart;
 850          }
 851    }
 852
 853    if ((com = _lex(word)) == NULL || com->func == &ccmdnotsupp) {
 854       fprintf(stderr, tr(91, "Unknown command: `%s'\n"), word);
 855       if (com != NULL) {
 856          ccmdnotsupp(NULL);
 857          com = NULL;
 858       }
 859       goto jleave;
 860    }
 861
 862    /* See if we should execute the command -- if a conditional we always
 863     * execute it, otherwise, check the state of cond */
 864 jexec:
 865    if (!(com->argtype & ARG_F)) {
 866       switch (cond_state) {
 867       case COND_RCV:
 868          if (options & OPT_SENDMODE)
 869                goto jleave0;
 870          break;
 871       case COND_SEND:
 872             if (!(options & OPT_SENDMODE))
 873                goto jleave0;
 874          break;
 875       case COND_TERM:
 876             if (!(options & OPT_TTYIN))
 877                goto jleave0;
 878          break;
 879       case COND_NOTERM:
 880             if (options & OPT_TTYIN)
 881                goto jleave0;
 882          break;
 883       case COND_ANY:
 884       case COND_EXEC:
 885          break;
 886       case COND_NOEXEC:
 887          goto jleave0;
 888       }
 889    }
 890
 891    /* Process the arguments to the command, depending on the type he expects.
 892     * Default to an error.
 893     * If we are sourcing an interactive command, it's an error */
 894    if ((options & OPT_SENDMODE) && !(com->argtype & ARG_M)) {
 895       fprintf(stderr, tr(92, "May not execute `%s' while sending\n"),
 896          com->name);
 897       goto jleave;
 898    }
 899    if (sourcing && (com->argtype & ARG_I)) {
 900       fprintf(stderr, tr(93, "May not execute `%s' while sourcing\n"),
 901          com->name);
 902       goto jleave;
 903    }
 904    if (!(mb.mb_perm & MB_DELE) && (com->argtype & ARG_W)) {
 905       fprintf(stderr, tr(94, "May not execute `%s' -- "
 906          "message file is read only\n"), com->name);
 907       goto jleave;
 908    }
 909    if (evp->ev_is_recursive && (com->argtype & ARG_R)) {
 910       fprintf(stderr, tr(95, "Cannot recursively invoke `%s'\n"), com->name);
 911       goto jleave;
 912    }
 913    if (mb.mb_type == MB_VOID && (com->argtype & ARG_A)) {
 914       fprintf(stderr, tr(257, "Cannot execute `%s' without active mailbox\n"),
 915          com->name);
 916       goto jleave;
 917    }
 918
 919    if (com->argtype & ARG_V)
 920       temporary_arg_v_store = NULL;
 921
 922    switch (com->argtype & ARG_ARGMASK) {
 923    case ARG_MSGLIST:
 924       /* Message list defaulting to nearest forward legal message */
 925       if (_msgvec == 0)
 926          goto je96;
 927       if ((c = getmsglist(cp, _msgvec, com->msgflag)) < 0)
 928          break;
 929       if (c == 0) {
 930          *_msgvec = first(com->msgflag, com->msgmask);
 931          if (*_msgvec != 0)
 932             _msgvec[1] = 0;
 933       }
 934       if (*_msgvec == 0) {
 935          if (!inhook)
 936             printf(tr(97, "No applicable messages\n"));
 937          break;
 938       }
 939       e = (*com->func)(_msgvec);
 940       break;
 941
 942    case ARG_NDMLIST:
 943       /* Message list with no defaults, but no error if none exist */
 944       if (_msgvec == 0) {
 945 je96:
 946          fprintf(stderr, tr(96, "Illegal use of `message list'\n"));
 947          break;
 948       }
 949       if ((c = getmsglist(cp, _msgvec, com->msgflag)) < 0)
 950          break;
 951       e = (*com->func)(_msgvec);
 952       break;
 953
 954    case ARG_STRLIST:
 955       /* Just the straight string, with leading blanks removed */
 956       while (whitechar(*cp))
 957          cp++;
 958       e = (*com->func)(cp);
 959       break;
 960
 961    case ARG_RAWLIST:
 962    case ARG_ECHOLIST:
 963       /* A vector of strings, in shell style */
 964       if ((c = getrawlist(cp, line.l, arglist, NELEM(arglist),
 965             ((com->argtype & ARG_ARGMASK) == ARG_ECHOLIST))) < 0)
 966          break;
 967       if (c < com->minargs) {
 968          fprintf(stderr, tr(99, "`%s' requires at least %d arg(s)\n"),
 969             com->name, com->minargs);
 970          break;
 971       }
 972       if (c > com->maxargs) {
 973          fprintf(stderr, tr(100, "`%s' takes no more than %d arg(s)\n"),
 974             com->name, com->maxargs);
 975          break;
 976       }
 977       e = (*com->func)(arglist);
 978       break;
 979
 980    case ARG_NOLIST:
 981       /* Just the constant zero, for exiting, eg. */
 982       e = (*com->func)(0);
 983       break;
 984
 985    default:
 986       panic(tr(101, "Unknown argument type"));
 987    }
 988
 989    if (e == 0 && (com->argtype & ARG_V) &&
 990          (cp = temporary_arg_v_store) != NULL) {
 991       temporary_arg_v_store = NULL;
 992       evp->ev_new_content = cp;
 993       goto jleave0;
 994    }
 995
 996 jleave:
 997    /* Exit the current source file on error */
 998    if ((exec_last_comm_error = (e != 0))) {
 999       if (e < 0)
1000          return 1;
1001       if (loading)
1002          return 1;
1003       if (sourcing)
1004          unstack();
1005       return 0;
1006    }
1007    if (com == NULL)
1008       return 0;
1009    if ((com->argtype & ARG_P) && ok_blook(autoprint))
1010       if (visible(dot)) {
1011          muvec[0] = (int)PTR2SIZE(dot - message + 1);
1012          muvec[1] = 0;
1013          type(muvec);
1014       }
1015    if (!sourcing && !inhook && (com->argtype & ARG_T) == 0)
1016       sawcom = TRU1;
1017 jleave0:
1018    exec_last_comm_error = 0;
1019    return 0;
1020 }
1021
1022 /*
1023  * Set the size of the message vector used to construct argument
1024  * lists to message list functions.
1025  */
1026 FL void
1027 setmsize(int sz)
1028 {
1029
1030         if (_msgvec != 0)
1031                 free(_msgvec);
1032         _msgvec = (int*)scalloc(sz + 1, sizeof *_msgvec);
1033 }
1034
1035 /*
1036  * The following gets called on receipt of an interrupt.  This is
1037  * to abort printout of a command, mainly.
1038  * Dispatching here when command() is inactive crashes rcv.
1039  * Close all open files except 0, 1, 2, and the temporary.
1040  * Also, unstack all source files.
1041  */
1042
1043 static int      inithdr;                /* am printing startup headers */
1044
1045 /*ARGSUSED*/
1046 FL void
1047 onintr(int s)
1048 {
1049         if (handlerstacktop != NULL) {
1050                 handlerstacktop(s);
1051                 return;
1052         }
1053         safe_signal(SIGINT, onintr);
1054         noreset = 0;
1055         if (!inithdr)
1056                 sawcom = TRU1;
1057         inithdr = 0;
1058         while (sourcing)
1059                 unstack();
1060
1061         termios_state_reset();
1062         close_all_files();
1063
1064         if (image >= 0) {
1065                 close(image);
1066                 image = -1;
1067         }
1068         if (interrupts != 1)
1069                 fprintf(stderr, tr(102, "Interrupt\n"));
1070         safe_signal(SIGPIPE, _oldpipe);
1071         reset(0);
1072 }
1073
1074 /*
1075  * When we wake up after ^Z, reprint the prompt.
1076  */
1077 static void
1078 stop(int s)
1079 {
1080         sighandler_type old_action = safe_signal(s, SIG_DFL);
1081         sigset_t nset;
1082
1083         sigemptyset(&nset);
1084         sigaddset(&nset, s);
1085         sigprocmask(SIG_UNBLOCK, &nset, (sigset_t *)NULL);
1086         kill(0, s);
1087         sigprocmask(SIG_BLOCK, &nset, (sigset_t *)NULL);
1088         safe_signal(s, old_action);
1089         if (_reset_on_stop) {
1090                 _reset_on_stop = 0;
1091                 reset(0);
1092         }
1093 }
1094
1095 /*
1096  * Branch here on hangup signal and simulate "exit".
1097  */
1098 /*ARGSUSED*/
1099 static void
1100 hangup(int s)
1101 {
1102         (void)s;
1103         /* nothing to do? */
1104         exit(1);
1105 }
1106
1107 /*
1108  * Announce the presence of the current Mail version,
1109  * give the message count, and print a header listing.
1110  */
1111 FL void
1112 announce(int printheaders)
1113 {
1114         int vec[2], mdot;
1115
1116         mdot = newfileinfo();
1117         vec[0] = mdot;
1118         vec[1] = 0;
1119         dot = &message[mdot - 1];
1120         if (printheaders && msgCount > 0 && ok_blook(header)) {
1121                 inithdr++;
1122                 headers(vec);
1123                 inithdr = 0;
1124         }
1125 }
1126
1127 /*
1128  * Announce information about the file we are editing.
1129  * Return a likely place to set dot.
1130  */
1131 FL int
1132 newfileinfo(void)
1133 {
1134         struct message *mp;
1135         int u, n, mdot, d, s, hidden, moved;
1136
1137         if (mb.mb_type == MB_VOID)
1138                 return 1;
1139         mdot = getmdot(0);
1140         s = d = hidden = moved =0;
1141         for (mp = &message[0], n = 0, u = 0; mp < &message[msgCount]; mp++) {
1142                 if (mp->m_flag & MNEW)
1143                         n++;
1144                 if ((mp->m_flag & MREAD) == 0)
1145                         u++;
1146                 if ((mp->m_flag & (MDELETED|MSAVED)) == (MDELETED|MSAVED))
1147                         moved++;
1148                 if ((mp->m_flag & (MDELETED|MSAVED)) == MDELETED)
1149                         d++;
1150                 if ((mp->m_flag & (MDELETED|MSAVED)) == MSAVED)
1151                         s++;
1152                 if (mp->m_flag & MHIDDEN)
1153                         hidden++;
1154         }
1155
1156         /* If displayname gets truncated the user effectively has no option to see
1157          * the full pathname of the mailbox, so print it at least for '? fi' */
1158         printf(tr(103, "\"%s\": "),
1159                 (_update_mailname(NULL) ? displayname : mailname));
1160         if (msgCount == 1)
1161                 printf(tr(104, "1 message"));
1162         else
1163                 printf(tr(105, "%d messages"), msgCount);
1164         if (n > 0)
1165                 printf(tr(106, " %d new"), n);
1166         if (u-n > 0)
1167                 printf(tr(107, " %d unread"), u);
1168         if (d > 0)
1169                 printf(tr(108, " %d deleted"), d);
1170         if (s > 0)
1171                 printf(tr(109, " %d saved"), s);
1172         if (moved > 0)
1173                 printf(tr(136, " %d moved"), moved);
1174         if (hidden > 0)
1175                 printf(tr(139, " %d hidden"), hidden);
1176         if (mb.mb_type == MB_CACHE)
1177                 printf(" [Disconnected]");
1178         else if (mb.mb_perm == 0)
1179                 printf(tr(110, " [Read only]"));
1180         printf("\n");
1181         return(mdot);
1182 }
1183
1184 FL int
1185 getmdot(int nmail)
1186 {
1187         struct message  *mp;
1188         char    *cp;
1189         int     mdot;
1190         enum mflag      avoid = MHIDDEN|MDELETED;
1191
1192         if (!nmail) {
1193                 if (ok_blook(autothread))
1194                         thread(NULL);
1195                 else if ((cp = ok_vlook(autosort)) != NULL) {
1196                         free(mb.mb_sorted);
1197                         mb.mb_sorted = sstrdup(cp);
1198                         sort(NULL);
1199                 }
1200         }
1201         if (mb.mb_type == MB_VOID)
1202                 return 1;
1203         if (nmail)
1204                 for (mp = &message[0]; mp < &message[msgCount]; mp++)
1205                         if ((mp->m_flag & (MNEWEST|avoid)) == MNEWEST)
1206                                 break;
1207         if (!nmail || mp >= &message[msgCount]) {
1208                 for (mp = mb.mb_threaded ? threadroot : &message[0];
1209                                 mb.mb_threaded ?
1210                                         mp != NULL : mp < &message[msgCount];
1211                                 mb.mb_threaded ?
1212                                         mp = next_in_thread(mp) : mp++)
1213                         if ((mp->m_flag & (MNEW|avoid)) == MNEW)
1214                                 break;
1215         }
1216         if (mb.mb_threaded ? mp == NULL : mp >= &message[msgCount])
1217                 for (mp = mb.mb_threaded ? threadroot : &message[0];
1218                                 mb.mb_threaded ? mp != NULL:
1219                                         mp < &message[msgCount];
1220                                 mb.mb_threaded ? mp = next_in_thread(mp) : mp++)
1221                         if (mp->m_flag & MFLAGGED)
1222                                 break;
1223         if (mb.mb_threaded ? mp == NULL : mp >= &message[msgCount])
1224                 for (mp = mb.mb_threaded ? threadroot : &message[0];
1225                                 mb.mb_threaded ? mp != NULL:
1226                                         mp < &message[msgCount];
1227                                 mb.mb_threaded ? mp = next_in_thread(mp) : mp++)
1228                         if ((mp->m_flag & (MREAD|avoid)) == 0)
1229                                 break;
1230         if (mb.mb_threaded ? mp != NULL : mp < &message[msgCount])
1231                 mdot = mp - &message[0] + 1;
1232         else if (ok_blook(showlast)) {
1233                 if (mb.mb_threaded) {
1234                         for (mp = this_in_thread(threadroot, -1); mp;
1235                                         mp = prev_in_thread(mp))
1236                                 if ((mp->m_flag & avoid) == 0)
1237                                         break;
1238                         mdot = mp ? mp - &message[0] + 1 : msgCount;
1239                 } else {
1240                         for (mp = &message[msgCount-1]; mp >= &message[0]; mp--)
1241                                 if ((mp->m_flag & avoid) == 0)
1242                                         break;
1243                         mdot = mp >= &message[0] ? mp-&message[0]+1 : msgCount;
1244                 }
1245         } else if (mb.mb_threaded) {
1246                 for (mp = threadroot; mp; mp = next_in_thread(mp))
1247                         if ((mp->m_flag & avoid) == 0)
1248                                 break;
1249                 mdot = mp ? mp - &message[0] + 1 : 1;
1250         } else {
1251                 for (mp = &message[0]; mp < &message[msgCount]; mp++)
1252                         if ((mp->m_flag & avoid) == 0)
1253                                 break;
1254                 mdot = mp < &message[msgCount] ? mp-&message[0]+1 : 1;
1255         }
1256         return mdot;
1257 }
1258
1259 FL void
1260 initbox(const char *name)
1261 {
1262         char *tempMesg;
1263         int dummy;
1264
1265         if (mb.mb_type != MB_VOID)
1266                 (void)n_strlcpy(prevfile, mailname, MAXPATHLEN);
1267         _update_mailname(name != mailname ? name : NULL);
1268         if ((mb.mb_otf = Ftemp(&tempMesg, "tmpbox", "w", 0600, 0)) == NULL) {
1269                 perror(tr(87, "temporary mail message file"));
1270                 exit(1);
1271         }
1272         (void)fcntl(fileno(mb.mb_otf), F_SETFD, FD_CLOEXEC);
1273         if ((mb.mb_itf = safe_fopen(tempMesg, "r", &dummy)) == NULL) {
1274                 perror(tr(87, "temporary mail message file"));
1275                 exit(1);
1276         }
1277         (void)fcntl(fileno(mb.mb_itf), F_SETFD, FD_CLOEXEC);
1278         rm(tempMesg);
1279         Ftfree(&tempMesg);
1280         msgCount = 0;
1281         if (message) {
1282                 free(message);
1283                 message = NULL;
1284                 msgspace = 0;
1285         }
1286         mb.mb_threaded = 0;
1287         if (mb.mb_sorted != NULL) {
1288                 free(mb.mb_sorted);
1289                 mb.mb_sorted = NULL;
1290         }
1291 #ifdef HAVE_IMAP
1292         mb.mb_flags = MB_NOFLAGS;
1293 #endif
1294         prevdot = NULL;
1295         dot = NULL;
1296         did_print_dot = FAL0;
1297 }
1298
1299 #ifdef HAVE_DOCSTRINGS
1300 FL bool_t
1301 print_comm_docstr(char const *comm)
1302 {
1303    bool_t rv = FAL0;
1304    struct cmd_ghost *cg;
1305    struct cmd const *cp;
1306
1307    /* Ghosts take precedence */
1308    for (cg = _cmd_ghosts; cg != NULL; cg = cg->next)
1309       if (strcmp(comm, cg->name) == 0) {
1310          printf("%s -> <%s>\n", comm, cg->cmd.s);
1311          rv = TRU1;
1312          goto jleave;
1313       }
1314
1315    for (cp = _cmd_tab; cp->name != NULL; ++cp) {
1316       if (cp->func == &ccmdnotsupp)
1317          continue;
1318       if (strcmp(comm, cp->name) == 0)
1319          printf("%s: %s\n", comm, tr(cp->docid, cp->doc));
1320       else if (is_prefix(comm, cp->name))
1321          printf("%s (%s): %s\n", comm, cp->name, tr(cp->docid, cp->doc));
1322       else
1323          continue;
1324       rv = TRU1;
1325       break;
1326    }
1327 jleave:
1328    return rv;
1329 }
1330 #endif
1331
1332 /* vim:set fenc=utf-8:s-it-mode (TODO only partial true) */