cmd2.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ More user commands.
   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 cmd2
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 /* Save/copy the indicated messages at the end of the passed file name.
  43  * If mark is true, mark the message "saved" */
  44 static int     save1(char *str, int domark, char const *cmd,
  45                   struct ignoretab *ignoret, int convert, int sender_record,
  46                   int domove);
  47
  48 /* Snarf the file from the end of the command line and return a pointer to it.
  49  * If there is no file attached, return the mbox file.  Put a null in front of
  50  * the file name so that the message list processing won't see it, unless the
  51  * file name is the only thing on the line, in which case, return 0 in the
  52  * reference flag variable */
  53 static char *  snarf(char *linebuf, bool_t *flag, bool_t usembox);
  54
  55 /* Delete the indicated messages.  Set dot to some nice place afterwards */
  56 static int     delm(int *msgvec);
  57
  58 static int     ignore1(char **list, struct ignoretab *tab, char const *which);
  59
  60 /* Print out all currently retained fields */
  61 static int     igshow(struct ignoretab *tab, char const *which);
  62
  63 /* Compare two names for sorting ignored field list */
  64 static int     igcomp(void const *l, void const *r);
  65
  66 /*  */
  67 static int     _unignore(char **list, struct ignoretab *tab, char const *which);
  68 static void    __unign_all(struct ignoretab *tab);
  69 static void    __unign_one(struct ignoretab *tab, char const *name);
  70
  71 static int
  72 save1(char *str, int domark, char const *cmd, struct ignoretab *ignoret,
  73    int convert, int sender_record, int domove)
  74 {
  75    ui64_t mstats[1], tstats[2];
  76    struct stat st;
  77    int newfile = 0, last = 0, *msgvec, *ip;
  78    struct message *mp;
  79    char *file = NULL, *cp, *cq;
  80    char const *disp = "", *shell = NULL;
  81    FILE *obuf;
  82    bool_t success = FAL0, f;
  83    NYD_ENTER;
  84
  85    msgvec = salloc((msgCount + 2) * sizeof *msgvec);
  86    if (sender_record) {
  87       for (cp = str; *cp != '\0' && spacechar(*cp); ++cp)
  88          ;
  89       f = (*cp != '\0');
  90    } else {
  91       if ((file = snarf(str, &f, convert != SEND_TOFILE)) == NULL)
  92          goto jleave;
  93       while(spacechar(*file))
  94          ++file;
  95       if (*file == '|') {
  96          ++file;
  97          if ((shell = ok_vlook(SHELL)) == NULL)
  98             shell = XSHELL;
  99       }
 100    }
 101
 102    if (!f) {
 103       *msgvec = first(0, MMNORM);
 104       msgvec[1] = 0;
 105    } else if (getmsglist(str, msgvec, 0) < 0)
 106       goto jleave;
 107    if (*msgvec == 0) {
 108       if (pstate & PS_HOOK_MASK) {
 109          success = TRU1;
 110          goto jleave;
 111       }
 112       printf(_("No messages to %s.\n"), cmd);
 113       goto jleave;
 114    }
 115
 116    if (sender_record) {
 117       if ((cp = nameof(message + *msgvec - 1, 0)) == NULL) {
 118          printf(_("Cannot determine message sender to %s.\n"), cmd);
 119          goto jleave;
 120       }
 121
 122       for (cq = cp; *cq != '\0' && *cq != '@'; cq++)
 123          ;
 124       *cq = '\0';
 125       if (ok_blook(outfolder)) {
 126          size_t sz = strlen(cp) +1;
 127          file = salloc(sz + 1);
 128          file[0] = '+';
 129          memcpy(file + 1, cp, sz);
 130       } else
 131          file = cp;
 132    }
 133
 134    /* Pipe target is special TODO hacked in later, normalize flow! */
 135    if (shell != NULL) {
 136       if ((obuf = Popen(file, "w", shell, NULL, 1)) == NULL) {
 137          int esave = errno;
 138          n_perr(file, esave);
 139          errno = esave;
 140          goto jleave;
 141       }
 142       disp = _("[Piped]");
 143       goto jsend;
 144    }
 145
 146    if ((file = expand(file)) == NULL)
 147       goto jleave;
 148    if (access(file, F_OK) >= 0) {
 149       newfile = 0;
 150       disp = _("[Appended]");
 151    } else {
 152       newfile = 1;
 153       disp = _("[New file]");
 154    }
 155
 156    obuf = ((convert == SEND_TOFILE) ? Fopen(file, "a+") : Zopen(file, "a+"));
 157    if (obuf == NULL) {
 158       obuf = ((convert == SEND_TOFILE) ? Fopen(file, "wx") : Zopen(file, "wx"));
 159       if (obuf == NULL) {
 160          n_perr(file, 0);
 161          goto jleave;
 162       }
 163    } else {
 164       if (!newfile && !fstat(fileno(obuf), &st) && S_ISREG(st.st_mode) &&
 165             fseek(obuf, -2L, SEEK_END) == 0) {
 166          char buf[2];
 167          int prependnl = 0;
 168
 169          switch (fread(buf, sizeof *buf, 2, obuf)) {
 170          case 2:
 171             if (buf[1] != '\n') {
 172                prependnl = 1;
 173                break;
 174             }
 175             /* FALLTHRU */
 176          case 1:
 177             if (buf[0] != '\n')
 178                prependnl = 1;
 179             break;
 180          default:
 181             if (ferror(obuf)) {
 182                n_perr(file, 0);
 183                goto jleave;
 184             }
 185             prependnl = 0;
 186          }
 187
 188          fflush(obuf);
 189          if (prependnl) {
 190             putc('\n', obuf);
 191             fflush(obuf);
 192          }
 193       }
 194    }
 195
 196 jsend:
 197    success = TRU1;
 198    tstats[0] = tstats[1] = 0;
 199
 200    srelax_hold();
 201    for (ip = msgvec; *ip != 0 && UICMP(z, PTR2SIZE(ip - msgvec), <, msgCount);
 202          ++ip) {
 203       mp = message + *ip - 1;
 204       if (sendmp(mp, obuf, ignoret, NULL, convert, mstats) < 0) {
 205          success = FAL0;
 206          goto jferr;
 207       }
 208       srelax();
 209
 210       touch(mp);
 211       if (domark)
 212          mp->m_flag |= MSAVED;
 213       if (domove) {
 214          mp->m_flag |= MDELETED | MSAVED;
 215          last = *ip;
 216       }
 217
 218       tstats[0] += mstats[0];
 219       tstats[1] += mp->m_lines;/* TODO won't work, need target! v15!! */
 220    }
 221    srelax_rele();
 222
 223    fflush(obuf);
 224    if (ferror(obuf)) {
 225 jferr:
 226       n_perr(file, 0);
 227       if (!success)
 228          srelax_rele();
 229       success = FAL0;
 230    }
 231    if (shell != NULL) {
 232       if (!Pclose(obuf, TRU1))
 233          success = FAL0;
 234    } else if (Fclose(obuf) != 0)
 235       success = FAL0;
 236
 237    if (success) {
 238       printf("\"%s\" %s %" /*PRIu64 "/%"*/ PRIu64 " bytes\n",
 239          file, disp, /*tstats[1], TODO v15: lines written */ tstats[0]);
 240    } else if (domark) {
 241       newfile = ~MSAVED;
 242       goto jiterand;
 243    } else if (domove) {
 244       newfile = ~(MSAVED | MDELETED);
 245 jiterand:
 246       for (ip = msgvec; *ip != 0 &&
 247             UICMP(z, PTR2SIZE(ip - msgvec), <, msgCount); ++ip) {
 248          mp = message + *ip - 1;
 249          mp->m_flag &= newfile;
 250       }
 251    }
 252
 253    if (domove && last && success) {
 254       setdot(message + last - 1);
 255       last = first(0, MDELETED);
 256       setdot(message + (last != 0 ? last - 1 : 0));
 257    }
 258 jleave:
 259    NYD_LEAVE;
 260    return (success == FAL0);
 261 }
 262
 263 static char *
 264 snarf(char *linebuf, bool_t *flag, bool_t usembox)
 265 {
 266    char *cp;
 267    NYD_ENTER;
 268
 269    if ((cp = laststring(linebuf, flag, TRU1)) == NULL) {
 270       if (usembox) {
 271          *flag = FAL0;
 272          cp = expand("&");
 273       } else
 274          n_err(_("No file specified\n"));
 275    }
 276    NYD_LEAVE;
 277    return cp;
 278 }
 279
 280 static int
 281 delm(int *msgvec)
 282 {
 283    struct message *mp;
 284    int rv = -1, *ip, last;
 285    NYD_ENTER;
 286
 287    last = 0;
 288    for (ip = msgvec; *ip != 0; ++ip) {
 289       mp = message + *ip - 1;
 290       touch(mp);
 291       mp->m_flag |= MDELETED | MTOUCH;
 292       mp->m_flag &= ~(MPRESERVE | MSAVED | MBOX);
 293       last = *ip;
 294    }
 295    if (last != 0) {
 296       setdot(message + last - 1);
 297       last = first(0, MDELETED);
 298       if (last != 0) {
 299          setdot(message + last - 1);
 300          rv = 0;
 301       } else {
 302          setdot(message);
 303       }
 304    }
 305    NYD_LEAVE;
 306    return rv;
 307 }
 308
 309 static int
 310 ignore1(char **list, struct ignoretab *tab, char const *which)
 311 {
 312    int h;
 313    struct ignored *igp;
 314    char **ap;
 315    NYD_ENTER;
 316
 317    if (*list == NULL) {
 318       h = igshow(tab, which);
 319       goto jleave;
 320    }
 321
 322    for (ap = list; *ap != 0; ++ap) {
 323       char *field;
 324       size_t sz;
 325
 326       sz = strlen(*ap) +1;
 327       field = ac_alloc(sz);
 328       i_strcpy(field, *ap, sz);
 329       if (member(field, tab))
 330          goto jnext;
 331
 332       h = hash(field);
 333       igp = scalloc(1, sizeof *igp);
 334       sz = strlen(field) +1;
 335       igp->i_field = smalloc(sz);
 336       memcpy(igp->i_field, field, sz);
 337       igp->i_link = tab->i_head[h];
 338       tab->i_head[h] = igp;
 339       ++tab->i_count;
 340 jnext:
 341       ac_free(field);
 342    }
 343    h = 0;
 344 jleave:
 345    NYD_LEAVE;
 346    return h;
 347 }
 348
 349 static int
 350 igshow(struct ignoretab *tab, char const *which)
 351 {
 352    int h;
 353    struct ignored *igp;
 354    char **ap, **ring;
 355    NYD_ENTER;
 356
 357    if (tab->i_count == 0) {
 358       printf(_("No fields currently being %s.\n"), which);
 359       goto jleave;
 360    }
 361
 362    ring = salloc((tab->i_count + 1) * sizeof *ring);
 363    ap = ring;
 364    for (h = 0; h < HSHSIZE; ++h)
 365       for (igp = tab->i_head[h]; igp != 0; igp = igp->i_link)
 366          *ap++ = igp->i_field;
 367    *ap = 0;
 368
 369    qsort(ring, tab->i_count, sizeof *ring, igcomp);
 370
 371    for (ap = ring; *ap != NULL; ++ap)
 372       printf("%s\n", *ap);
 373 jleave:
 374    NYD_LEAVE;
 375    return 0;
 376 }
 377
 378 static int
 379 igcomp(void const *l, void const *r)
 380 {
 381    int rv;
 382    NYD_ENTER;
 383
 384    rv = strcmp(*(char**)UNCONST(l), *(char**)UNCONST(r));
 385    NYD_LEAVE;
 386    return rv;
 387 }
 388
 389 static int
 390 _unignore(char **list, struct ignoretab *tab, char const *which)
 391 {
 392    char *field;
 393    NYD_ENTER;
 394
 395    if (tab->i_count == 0)
 396       printf(_("No fields currently being %s.\n"), which);
 397    else
 398       while ((field = *list++) != NULL)
 399          if (field[0] == '*' && field[1] == '\0') {
 400             __unign_all(tab);
 401             break;
 402          } else
 403             __unign_one(tab, field);
 404    NYD_LEAVE;
 405    return 0;
 406 }
 407
 408 static void
 409 __unign_all(struct ignoretab *tab)
 410 {
 411    size_t i;
 412    struct ignored *n, *x;
 413    NYD_ENTER;
 414
 415    for (i = 0; i < NELEM(tab->i_head); ++i)
 416       for (n = tab->i_head[i]; n != NULL; n = x) {
 417          x = n->i_link;
 418          free(n->i_field);
 419          free(n);
 420       }
 421    memset(tab, 0, sizeof *tab);
 422    NYD_LEAVE;
 423 }
 424
 425 static void
 426 __unign_one(struct ignoretab *tab, char const *name)
 427 {
 428    struct ignored *ip, *iq;
 429    int h;
 430    NYD_ENTER;
 431
 432    h = hash(name);
 433    for (iq = NULL, ip = tab->i_head[h]; ip != NULL; ip = ip->i_link) {
 434       if (!asccasecmp(ip->i_field, name)) {
 435          free(ip->i_field);
 436          if (iq != NULL)
 437             iq->i_link = ip->i_link;
 438          else
 439             tab->i_head[h] = ip->i_link;
 440          free(ip);
 441          --tab->i_count;
 442          break;
 443       }
 444       iq = ip;
 445    }
 446    NYD_LEAVE;
 447 }
 448
 449 FL int
 450 c_next(void *v)
 451 {
 452    int list[2], *ip, *ip2, mdot, *msgvec = v, rv = 1;
 453    struct message *mp;
 454    NYD_ENTER;
 455
 456    if (*msgvec != 0) {
 457       /* If some messages were supplied, find the first applicable one
 458        * following dot using wrap around */
 459       mdot = (int)PTR2SIZE(dot - message + 1);
 460
 461       /* Find first message in supplied message list which follows dot */
 462       for (ip = msgvec; *ip != 0; ++ip) {
 463          if ((mb.mb_threaded ? message[*ip - 1].m_threadpos > dot->m_threadpos
 464                : *ip > mdot))
 465             break;
 466       }
 467       if (*ip == 0)
 468          ip = msgvec;
 469       ip2 = ip;
 470       do {
 471          mp = message + *ip2 - 1;
 472          if (!(mp->m_flag & MMNDEL)) {
 473             setdot(mp);
 474             goto jhitit;
 475          }
 476          if (*ip2 != 0)
 477             ++ip2;
 478          if (*ip2 == 0)
 479             ip2 = msgvec;
 480       } while (ip2 != ip);
 481       printf(_("No messages applicable\n"));
 482       goto jleave;
 483    }
 484
 485    /* If this is the first command, select message 1.  Note that this must
 486     * exist for us to get here at all */
 487    if (!(pstate & PS_SAW_COMMAND)) {
 488       if (msgCount == 0)
 489          goto jateof;
 490       goto jhitit;
 491    }
 492
 493    /* Just find the next good message after dot, no wraparound */
 494    if (mb.mb_threaded == 0) {
 495       for (mp = dot + !!(pstate & PS_DID_PRINT_DOT);
 496             PTRCMP(mp, <, message + msgCount); ++mp)
 497          if (!(mp->m_flag & MMNORM))
 498             break;
 499    } else {
 500       /* TODO The threading code had some bugs that caused crashes.
 501        * TODO The last thing (before the deep look) happens here,
 502        * TODO so let's not trust PS_DID_PRINT_DOT but check & hope it fixes */
 503       if ((mp = dot) != NULL && (pstate & PS_DID_PRINT_DOT))
 504          mp = next_in_thread(mp);
 505       while (mp != NULL && (mp->m_flag & MMNORM))
 506          mp = next_in_thread(mp);
 507    }
 508    if (mp == NULL || PTRCMP(mp, >=, message + msgCount)) {
 509 jateof:
 510       printf(_("At EOF\n"));
 511       rv = 0;
 512       goto jleave;
 513    }
 514    setdot(mp);
 515
 516    /* Print dot */
 517 jhitit:
 518    list[0] = (int)PTR2SIZE(dot - message + 1);
 519    list[1] = 0;
 520    rv = c_type(list);
 521 jleave:
 522    NYD_LEAVE;
 523    return rv;
 524 }
 525
 526 FL int
 527 c_dotmove(void *v)
 528 {
 529    char const *args;
 530    int msgvec[2], rv;
 531    NYD_ENTER;
 532
 533    if (*(args = v) == '\0' || args[1] != '\0') {
 534 jerr:
 535       n_err(_("Synopsis: dotmove: up <-> or down <+> by one message\n"));
 536       rv = 1;
 537    } else switch (args[0]) {
 538    case '-':
 539    case '+':
 540       if (msgCount == 0) {
 541          printf(_("At EOF\n"));
 542          rv = 0;
 543       } else if (getmsglist(UNCONST(/*TODO*/ args), msgvec, 0) > 0) {
 544          setdot(message + msgvec[0] - 1);
 545          msgvec[1] = 0;
 546          rv = c_headers(msgvec);
 547       } else
 548          rv = 1;
 549       break;
 550    default:
 551       goto jerr;
 552    }
 553    NYD_LEAVE;
 554    return rv;
 555 }
 556
 557 FL int
 558 c_save(void *v)
 559 {
 560    char *str = v;
 561    int rv;
 562    NYD_ENTER;
 563
 564    rv = save1(str, 1, "save", saveignore, SEND_MBOX, 0, 0);
 565    NYD_LEAVE;
 566    return rv;
 567 }
 568
 569 FL int
 570 c_Save(void *v)
 571 {
 572    char *str = v;
 573    int rv;
 574    NYD_ENTER;
 575
 576    rv = save1(str, 1, "save", saveignore, SEND_MBOX, 1, 0);
 577    NYD_LEAVE;
 578    return rv;
 579 }
 580
 581 FL int
 582 c_copy(void *v)
 583 {
 584    char *str = v;
 585    int rv;
 586    NYD_ENTER;
 587
 588    rv = save1(str, 0, "copy", saveignore, SEND_MBOX, 0, 0);
 589    NYD_LEAVE;
 590    return rv;
 591 }
 592
 593 FL int
 594 c_Copy(void *v)
 595 {
 596    char *str = v;
 597    int rv;
 598    NYD_ENTER;
 599
 600    rv = save1(str, 0, "copy", saveignore, SEND_MBOX, 1, 0);
 601    NYD_LEAVE;
 602    return rv;
 603 }
 604
 605 FL int
 606 c_move(void *v)
 607 {
 608    char *str = v;
 609    int rv;
 610    NYD_ENTER;
 611
 612    rv = save1(str, 0, "move", saveignore, SEND_MBOX, 0, 1);
 613    NYD_LEAVE;
 614    return rv;
 615 }
 616
 617 FL int
 618 c_Move(void *v)
 619 {
 620    char *str = v;
 621    int rv;
 622    NYD_ENTER;
 623
 624    rv = save1(str, 0, "move", saveignore, SEND_MBOX, 1, 1);
 625    NYD_LEAVE;
 626    return rv;
 627 }
 628
 629 FL int
 630 c_decrypt(void *v)
 631 {
 632    char *str = v;
 633    int rv;
 634    NYD_ENTER;
 635
 636    rv = save1(str, 0, "decrypt", saveignore, SEND_DECRYPT, 0, 0);
 637    NYD_LEAVE;
 638    return rv;
 639 }
 640
 641 FL int
 642 c_Decrypt(void *v)
 643 {
 644    char *str = v;
 645    int rv;
 646    NYD_ENTER;
 647
 648    rv = save1(str, 0, "decrypt", saveignore, SEND_DECRYPT, 1, 0);
 649    NYD_LEAVE;
 650    return rv;
 651 }
 652
 653 FL int
 654 c_write(void *v)
 655 {
 656    char *str = v;
 657    int rv;
 658    NYD_ENTER;
 659
 660    if (str == NULL || *str == '\0')
 661       str = savestr("/dev/null");
 662    rv = save1(str, 0, "write", allignore, SEND_TOFILE, 0, 0);
 663    NYD_LEAVE;
 664    return rv;
 665 }
 666
 667 FL int
 668 c_delete(void *v)
 669 {
 670    int *msgvec = v;
 671    NYD_ENTER;
 672
 673    delm(msgvec);
 674    NYD_LEAVE;
 675    return 0;
 676 }
 677
 678 FL int
 679 c_deltype(void *v)
 680 {
 681    int list[2], rv = 0, *msgvec = v, lastdot;
 682    NYD_ENTER;
 683
 684    lastdot = (int)PTR2SIZE(dot - message + 1);
 685    if (delm(msgvec) >= 0) {
 686       list[0] = (int)PTR2SIZE(dot - message + 1);
 687       if (list[0] > lastdot) {
 688          touch(dot);
 689          list[1] = 0;
 690          rv = c_type(list);
 691          goto jleave;
 692       }
 693       printf(_("At EOF\n"));
 694    } else
 695       printf(_("No more messages\n"));
 696 jleave:
 697    NYD_LEAVE;
 698    return rv;
 699 }
 700
 701 FL int
 702 c_undelete(void *v)
 703 {
 704    int *msgvec = v, *ip;
 705    struct message *mp;
 706    NYD_ENTER;
 707
 708    for (ip = msgvec; *ip != 0 && UICMP(z, PTR2SIZE(ip - msgvec), <, msgCount);
 709          ++ip) {
 710       mp = message + *ip - 1;
 711       touch(mp);
 712       setdot(mp);
 713       if (mp->m_flag & (MDELETED | MSAVED))
 714          mp->m_flag &= ~(MDELETED | MSAVED);
 715       else
 716          mp->m_flag &= ~MDELETED;
 717    }
 718    NYD_LEAVE;
 719    return 0;
 720 }
 721
 722 FL int
 723 c_retfield(void *v)
 724 {
 725    char **list = v;
 726    int rv;
 727    NYD_ENTER;
 728
 729    rv = ignore1(list, ignore + 1, "retained");
 730    NYD_LEAVE;
 731    return rv;
 732 }
 733
 734 FL int
 735 c_igfield(void *v)
 736 {
 737    char **list = v;
 738    int rv;
 739    NYD_ENTER;
 740
 741    rv = ignore1(list, ignore, "ignored");
 742    NYD_LEAVE;
 743    return rv;
 744 }
 745
 746 FL int
 747 c_saveretfield(void *v)
 748 {
 749    char **list = v;
 750    int rv;
 751    NYD_ENTER;
 752
 753    rv = ignore1(list, saveignore + 1, "retained");
 754    NYD_LEAVE;
 755    return rv;
 756 }
 757
 758 FL int
 759 c_saveigfield(void *v)
 760 {
 761    char **list = v;
 762    int rv;
 763    NYD_ENTER;
 764
 765    rv = ignore1(list, saveignore, "ignored");
 766    NYD_LEAVE;
 767    return rv;
 768 }
 769
 770 FL int
 771 c_fwdretfield(void *v)
 772 {
 773    char **list = v;
 774    int rv;
 775    NYD_ENTER;
 776
 777    rv = ignore1(list, fwdignore + 1, "retained");
 778    NYD_LEAVE;
 779    return rv;
 780 }
 781
 782 FL int
 783 c_fwdigfield(void *v)
 784 {
 785    char **list = v;
 786    int rv;
 787    NYD_ENTER;
 788
 789    rv = ignore1(list, fwdignore, "ignored");
 790    NYD_LEAVE;
 791    return rv;
 792 }
 793
 794 FL int
 795 c_unignore(void *v)
 796 {
 797    int rv;
 798    NYD_ENTER;
 799
 800    rv = _unignore((char**)v, ignore, "ignored");
 801    NYD_LEAVE;
 802    return rv;
 803 }
 804
 805 FL int
 806 c_unretain(void *v)
 807 {
 808    int rv;
 809    NYD_ENTER;
 810
 811    rv = _unignore((char**)v, ignore + 1, "retained");
 812    NYD_LEAVE;
 813    return rv;
 814 }
 815
 816 FL int
 817 c_unsaveignore(void *v)
 818 {
 819    int rv;
 820    NYD_ENTER;
 821
 822    rv = _unignore((char**)v, saveignore, "ignored");
 823    NYD_LEAVE;
 824    return rv;
 825 }
 826
 827 FL int
 828 c_unsaveretain(void *v)
 829 {
 830    int rv;
 831    NYD_ENTER;
 832
 833    rv = _unignore((char**)v, saveignore + 1, "retained");
 834    NYD_LEAVE;
 835    return rv;
 836 }
 837
 838 FL int
 839 c_unfwdignore(void *v)
 840 {
 841    int rv;
 842    NYD_ENTER;
 843
 844    rv = _unignore((char**)v, fwdignore, "ignored");
 845    NYD_LEAVE;
 846    return rv;
 847 }
 848
 849 FL int
 850 c_unfwdretain(void *v)
 851 {
 852    int rv;
 853    NYD_ENTER;
 854
 855    rv = _unignore((char**)v, fwdignore + 1, "retained");
 856    NYD_LEAVE;
 857    return rv;
 858 }
 859
 860 /* s-it-mode */