cmd2.c

   1 /*
   2  * S-nail - a mail user agent derived from Berkeley Mail.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 Steffen "Daode" Nurpmeso.
   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 #include "rcv.h"
  41 #include "extern.h"
  42 #include <sys/wait.h>
  43 #include <sys/stat.h>
  44 #include <unistd.h>
  45
  46 /*
  47  * Mail -- a mail program
  48  *
  49  * More user commands.
  50  */
  51
  52 static int      save1(char *str, int mark, char *cmd, struct ignoretab *ignore,
  53                         int convert, int sender_record, int domove);
  54 static char *   snarf(char *linebuf, int *flag, int usembox);
  55 static int      delm(int *msgvec);
  56 #ifdef HAVE_ASSERTS
  57 static void     clob1(int n);
  58 #endif
  59 static int      ignore1(char **list, struct ignoretab *tab, char *which);
  60 static int      igshow(struct ignoretab *tab, char *which);
  61 static int      igcomp(const void *l, const void *r);
  62 static void     unignore_one(const char *name, struct ignoretab *tab);
  63 static int      unignore1(char **list, struct ignoretab *tab, char *which);
  64
  65 /*
  66  * If any arguments were given, go to the next applicable argument
  67  * following dot, otherwise, go to the next applicable message.
  68  * If given as first command with no arguments, print first message.
  69  */
  70 int
  71 next(void *v)
  72 {
  73         int *msgvec = v;
  74         struct message *mp;
  75         int *ip, *ip2;
  76         int list[2], mdot;
  77
  78         if (*msgvec != 0) {
  79
  80                 /*
  81                  * If some messages were supplied, find the
  82                  * first applicable one following dot using
  83                  * wrap around.
  84                  */
  85
  86                 mdot = dot - &message[0] + 1;
  87
  88                 /*
  89                  * Find the first message in the supplied
  90                  * message list which follows dot.
  91                  */
  92
  93                 for (ip = msgvec; *ip != 0; ip++) {
  94 #ifdef  _CRAY
  95 /*
  96  * Work around an optimizer bug in Cray Standard C Version 4.0.3  (057126).
  97  * Otherwise, SIGFPE is received when mb.mb_threaded != 0.
  98  */
  99 #pragma _CRI suppress ip
 100 #endif  /* _CRAY */
 101                         if (mb.mb_threaded ? message[*ip-1].m_threadpos >
 102                                                 dot->m_threadpos :
 103                                         *ip > mdot)
 104                                 break;
 105                 }
 106                 if (*ip == 0)
 107                         ip = msgvec;
 108                 ip2 = ip;
 109                 do {
 110                         mp = &message[*ip2 - 1];
 111                         if ((mp->m_flag & (MDELETED|MHIDDEN)) == 0) {
 112                                 setdot(mp);
 113                                 goto hitit;
 114                         }
 115                         if (*ip2 != 0)
 116                                 ip2++;
 117                         if (*ip2 == 0)
 118                                 ip2 = msgvec;
 119                 } while (ip2 != ip);
 120                 printf(catgets(catd, CATSET, 21, "No messages applicable\n"));
 121                 return(1);
 122         }
 123
 124         /*
 125          * If this is the first command, select message 1.
 126          * Note that this must exist for us to get here at all.
 127          */
 128
 129         if (!sawcom) {
 130                 if (msgCount == 0)
 131                         goto ateof;
 132                 goto hitit;
 133         }
 134
 135         /*
 136          * Just find the next good message after dot, no
 137          * wraparound.
 138          */
 139
 140         if (mb.mb_threaded == 0) {
 141                 for (mp = dot + did_print_dot; mp < &message[msgCount]; mp++)
 142                         if ((mp->m_flag & (MDELETED|MSAVED|MHIDDEN|MKILL)) == 0)
 143                                 break;
 144         } else {
 145                 mp = dot;
 146                 if (did_print_dot)
 147                         mp = next_in_thread(mp);
 148                 while (mp && mp->m_flag & (MDELETED|MSAVED|MHIDDEN|MKILL))
 149                         mp = next_in_thread(mp);
 150         }
 151         if (mp == NULL || mp >= &message[msgCount]) {
 152 ateof:
 153                 printf(catgets(catd, CATSET, 22, "At EOF\n"));
 154                 return(0);
 155         }
 156         setdot(mp);
 157 hitit:
 158         /*
 159          * Print dot.
 160          */
 161
 162         list[0] = dot - &message[0] + 1;
 163         list[1] = 0;
 164         return(type(list));
 165 }
 166
 167 /*
 168  * Save a message in a file.  Mark the message as saved
 169  * so we can discard when the user quits.
 170  */
 171 int
 172 save(void *v)
 173 {
 174         char *str = v;
 175
 176         return save1(str, 1, "save", saveignore, SEND_MBOX, 0, 0);
 177 }
 178
 179 int
 180 Save(void *v)
 181 {
 182         char *str = v;
 183
 184         return save1(str, 1, "save", saveignore, SEND_MBOX, 1, 0);
 185 }
 186
 187 /*
 188  * Copy a message to a file without affected its saved-ness
 189  */
 190 int
 191 copycmd(void *v)
 192 {
 193         char *str = v;
 194
 195         return save1(str, 0, "copy", saveignore, SEND_MBOX, 0, 0);
 196 }
 197
 198 int
 199 Copycmd(void *v)
 200 {
 201         char *str = v;
 202
 203         return save1(str, 0, "copy", saveignore, SEND_MBOX, 1, 0);
 204 }
 205
 206 /*
 207  * Move a message to a file.
 208  */
 209 int
 210 cmove(void *v)
 211 {
 212         char *str = v;
 213
 214         return save1(str, 0, "move", saveignore, SEND_MBOX, 0, 1);
 215 }
 216
 217 int
 218 cMove(void *v)
 219 {
 220         char *str = v;
 221
 222         return save1(str, 0, "move", saveignore, SEND_MBOX, 1, 1);
 223 }
 224
 225 /*
 226  * Decrypt and copy a message to a file.
 227  */
 228 int
 229 cdecrypt(void *v)
 230 {
 231         char *str = v;
 232
 233         return save1(str, 0, "decrypt", saveignore, SEND_DECRYPT, 0, 0);
 234 }
 235
 236 int
 237 cDecrypt(void *v)
 238 {
 239         char *str = v;
 240
 241         return save1(str, 0, "decrypt", saveignore, SEND_DECRYPT, 1, 0);
 242 }
 243
 244 /*
 245  * Save/copy the indicated messages at the end of the passed file name.
 246  * If mark is true, mark the message "saved."
 247  */
 248 static int
 249 save1(char *str, int mark, char *cmd, struct ignoretab *ignore,
 250                 int convert, int sender_record, int domove)
 251 {
 252         struct stat     st;
 253         int *ip;
 254         struct message *mp;
 255         char *file = NULL, *disp = "";
 256         int f, *msgvec;
 257         FILE *obuf;
 258         int newfile = 0;
 259         char *cp, *cq;
 260         off_t mstats[2], tstats[2];
 261         int compressed = 0;
 262         enum protocol prot;
 263         int success = 1, last = 0;
 264
 265         /*LINTED*/
 266         msgvec = (int *)salloc((msgCount + 2) * sizeof *msgvec);
 267         if (sender_record) {
 268                 for (cp = str; *cp && blankchar(*cp & 0377); cp++);
 269                 f = (*cp != '\0');
 270         } else {
 271                 if ((file = snarf(str, &f, convert != SEND_TOFILE)) == NULL)
 272                         return(1);
 273         }
 274         if (!f) {
 275                 *msgvec = first(0, MMNORM);
 276                 if (*msgvec == 0) {
 277                         if (inhook)
 278                                 return 0;
 279                         printf(catgets(catd, CATSET, 23,
 280                                         "No messages to %s.\n"), cmd);
 281                         return(1);
 282                 }
 283                 msgvec[1] = 0;
 284         }
 285         if (f && getmsglist(str, msgvec, 0) < 0)
 286                 return(1);
 287         if (*msgvec == 0) {
 288                 if (inhook)
 289                         return 0;
 290                 printf("No applicable messages.\n");
 291                 return 1;
 292         }
 293         if (sender_record) {
 294                 if ((cp = nameof(&message[*msgvec - 1], 0)) == NULL) {
 295                         printf(catgets(catd, CATSET, 24,
 296                                 "Cannot determine message sender to %s.\n"),
 297                                 cmd);
 298                         return 1;
 299                 }
 300                 for (cq = cp; *cq && *cq != '@'; cq++);
 301                 *cq = '\0';
 302                 if (value("outfolder")) {
 303                         file = salloc(strlen(cp) + 2);
 304                         file[0] = '+';
 305                         strcpy(&file[1], cp);
 306                 } else
 307                         file = cp;
 308         }
 309         if ((file = expand(file)) == NULL)
 310                 return(1);
 311         prot = which_protocol(file);
 312         if (prot != PROTO_IMAP) {
 313                 if (access(file, 0) >= 0) {
 314                         newfile = 0;
 315                         disp = catgets(catd, CATSET, 25, "[Appended]");
 316                 } else {
 317                         newfile = 1;
 318                         disp = catgets(catd, CATSET, 26, "[New file]");
 319                 }
 320         }
 321         if ((obuf = convert == SEND_TOFILE ? Fopen(file, "a+") :
 322                         Zopen(file, "a+", &compressed)) == NULL) {
 323                 if ((obuf = convert == SEND_TOFILE ? Fopen(file, "wx") :
 324                                 Zopen(file, "wx", &compressed)) == NULL) {
 325                         perror(file);
 326                         return(1);
 327                 }
 328         } else {
 329                 if (compressed) {
 330                         newfile = 0;
 331                         disp = catgets(catd, CATSET, 25, "[Appended]");
 332                 }
 333                 if (!newfile && fstat(fileno(obuf), &st) &&
 334                                 S_ISREG(st.st_mode) &&
 335                                 fseek(obuf, -2L, SEEK_END) == 0) {
 336                         char buf[2];
 337                         int prependnl = 0;
 338
 339                         switch (fread(buf, sizeof *buf, 2, obuf)) {
 340                         case 2:
 341                                 if (buf[1] != '\n') {
 342                                         prependnl = 1;
 343                                         break;
 344                                 }
 345                                 /*FALLTHRU*/
 346                         case 1:
 347                                 if (buf[0] != '\n')
 348                                         prependnl = 1;
 349                                 break;
 350                         default:
 351                                 if (ferror(obuf)) {
 352                                         perror(file);
 353                                         return(1);
 354                                 }
 355                                 prependnl = 0;
 356                         }
 357                         fflush(obuf);
 358                         if (prependnl) {
 359                                 putc('\n', obuf);
 360                                 fflush(obuf);
 361                         }
 362                 }
 363         }
 364         tstats[0] = tstats[1] = 0;
 365         imap_created_mailbox = 0;
 366         for (ip = msgvec; *ip && ip-msgvec < msgCount; ip++) {
 367                 mp = &message[*ip - 1];
 368                 if (prot == PROTO_IMAP &&
 369                                 ignore[0].i_count == 0 &&
 370                                 ignore[1].i_count == 0 &&
 371                                 imap_thisaccount(file)) {
 372                         if (imap_copy(mp, *ip, file) == STOP)
 373                                 goto ferr;
 374                         mstats[0] = -1;
 375                         mstats[1] = mp->m_xsize;
 376                 } else if (send(mp, obuf, ignore, NULL,
 377                                         convert, mstats) < 0) {
 378                         perror(file);
 379                         goto ferr;
 380                 }
 381                 touch(mp);
 382                 if (mark)
 383                         mp->m_flag |= MSAVED;
 384                 if (domove) {
 385                         mp->m_flag |= MDELETED|MSAVED;
 386                         last = *ip;
 387                 }
 388                 tstats[0] += mstats[0];
 389                 tstats[1] += mstats[1];
 390         }
 391         fflush(obuf);
 392         if (ferror(obuf)) {
 393                 perror(file);
 394         ferr:   success = 0;
 395         }
 396         if (Fclose(obuf) != 0)
 397                 success = 0;
 398         if (success) {
 399                 if (prot == PROTO_IMAP || prot == PROTO_MAILDIR)
 400                         disp = prot == PROTO_IMAP && disconnected(file) ?
 401                                 "[Queued]" : imap_created_mailbox ?
 402                                         "[New file]" : "[Appended]";
 403                 printf("\"%s\" %s ", file, disp);
 404                 if (tstats[0] >= 0)
 405                         printf("%lu", (long)tstats[0]);
 406                 else
 407                         printf(catgets(catd, CATSET, 27, "binary"));
 408                 printf("/%lu\n", (long)tstats[1]);
 409         } else if (mark) {
 410                 for (ip = msgvec; *ip && ip-msgvec < msgCount; ip++) {
 411                         mp = &message[*ip - 1];
 412                         mp->m_flag &= ~MSAVED;
 413                 }
 414         } else if (domove) {
 415                 for (ip = msgvec; *ip && ip-msgvec < msgCount; ip++) {
 416                         mp = &message[*ip - 1];
 417                         mp->m_flag &= ~(MSAVED|MDELETED);
 418                 }
 419         }
 420         if (domove && last && success) {
 421                 setdot(&message[last-1]);
 422                 last = first(0, MDELETED);
 423                 setdot(&message[last ? last-1 : 0]);
 424         }
 425         return(success == 0);
 426 }
 427
 428 /*
 429  * Write the indicated messages at the end of the passed
 430  * file name, minus header and trailing blank line.
 431  * This is the MIME save function.
 432  */
 433 int
 434 cwrite(void *v)
 435 {
 436         char *str = v;
 437
 438         if (str == NULL || *str == '\0')
 439                 str = savestr("/dev/null");
 440         return (save1(str, 0, "write", allignore, SEND_TOFILE, 0, 0));
 441 }
 442
 443 /*
 444  * Snarf the file from the end of the command line and
 445  * return a pointer to it.  If there is no file attached,
 446  * return the mbox file.  Put a null in front of the file
 447  * name so that the message list processing won't see it,
 448  * unless the file name is the only thing on the line, in
 449  * which case, return 0 in the reference flag variable.
 450  */
 451
 452 static char *
 453 snarf(char *linebuf, int *flag, int usembox)
 454 {
 455         char *cp;
 456
 457         *flag = 1;
 458         if ((cp = laststring(linebuf, flag, 0)) == NULL) {
 459                 if (usembox) {
 460                         *flag = 0;
 461                         cp = expand("&");
 462                 } else
 463                         printf(tr(28, "No file specified.\n"));
 464         }
 465         return (cp);
 466 }
 467
 468 /*
 469  * Delete messages.
 470  */
 471 int
 472 delete(void *v)
 473 {
 474         int *msgvec = v;
 475         delm(msgvec);
 476         return 0;
 477 }
 478
 479 /*
 480  * Delete messages, then type the new dot.
 481  */
 482 int
 483 deltype(void *v)
 484 {
 485         int *msgvec = v;
 486         int list[2];
 487         int lastdot;
 488
 489         lastdot = dot - &message[0] + 1;
 490         if (delm(msgvec) >= 0) {
 491                 list[0] = dot - &message[0] + 1;
 492                 if (list[0] > lastdot) {
 493                         touch(dot);
 494                         list[1] = 0;
 495                         return(type(list));
 496                 }
 497                 printf(catgets(catd, CATSET, 29, "At EOF\n"));
 498         } else
 499                 printf(catgets(catd, CATSET, 30, "No more messages\n"));
 500         return(0);
 501 }
 502
 503 /*
 504  * Delete the indicated messages.
 505  * Set dot to some nice place afterwards.
 506  * Internal interface.
 507  */
 508 static int
 509 delm(int *msgvec)
 510 {
 511         struct message *mp;
 512         int *ip;
 513         int last;
 514
 515         last = 0;
 516         for (ip = msgvec; *ip != 0; ip++) {
 517                 mp = &message[*ip - 1];
 518                 touch(mp);
 519                 mp->m_flag |= MDELETED|MTOUCH;
 520                 mp->m_flag &= ~(MPRESERVE|MSAVED|MBOX);
 521                 last = *ip;
 522         }
 523         if (last != 0) {
 524                 setdot(&message[last-1]);
 525                 last = first(0, MDELETED);
 526                 if (last != 0) {
 527                         setdot(&message[last-1]);
 528                         return(0);
 529                 }
 530                 else {
 531                         setdot(&message[0]);
 532                         return(-1);
 533                 }
 534         }
 535
 536         /*
 537          * Following can't happen -- it keeps lint happy
 538          */
 539
 540         return(-1);
 541 }
 542
 543 /*
 544  * Undelete the indicated messages.
 545  */
 546 int
 547 undeletecmd(void *v)
 548 {
 549         int *msgvec = v;
 550         struct message *mp;
 551         int *ip;
 552
 553         for (ip = msgvec; *ip && ip-msgvec < msgCount; ip++) {
 554                 mp = &message[*ip - 1];
 555                 touch(mp);
 556                 setdot(mp);
 557                 if (mp->m_flag & (MDELETED|MSAVED))
 558                         mp->m_flag &= ~(MDELETED|MSAVED);
 559                 else
 560                         mp->m_flag &= ~MDELETED;
 561                 if (mb.mb_type == MB_IMAP || mb.mb_type == MB_CACHE)
 562                         imap_undelete(mp, *ip);
 563         }
 564         return 0;
 565 }
 566
 567 #ifdef HAVE_ASSERTS
 568 /*
 569  * Interactively dump core on "core"
 570  */
 571 /*ARGSUSED*/
 572 int
 573 core(void *v)
 574 {
 575         int pid;
 576 # ifdef WCOREDUMP
 577         extern int wait_status;
 578 # endif
 579         (void)v;
 580
 581         switch (pid = fork()) {
 582         case -1:
 583                 perror("fork");
 584                 return (1);
 585         case 0:
 586                 abort();
 587                 _exit(1);
 588         }
 589         (void)printf(tr(31, "Okie dokie"));
 590         (void)fflush(stdout);
 591         (void)wait_child(pid);
 592 # ifdef WCOREDUMP
 593         if (WCOREDUMP(wait_status))
 594                 (void)printf(tr(32, " -- Core dumped.\n"));
 595         else
 596                 (void)printf(tr(33, " -- Can't dump core.\n"));
 597 # endif
 598         return (0);
 599 }
 600
 601 static void
 602 clob1(int n)
 603 {
 604         char buf[512], *cp;
 605
 606         if (n <= 0)
 607                 return;
 608         for (cp = buf; cp < &buf[512]; *cp++ = (char)0xFF)
 609                 ;
 610         clob1(n - 1);
 611 }
 612
 613 /*
 614  * Clobber as many bytes of stack as the user requests.
 615  */
 616 int
 617 clobber(void *v)
 618 {
 619         char **argv = v;
 620         int times;
 621
 622         if (argv[0] == 0)
 623                 times = 1;
 624         else
 625                 times = (atoi(argv[0]) + 511) / 512;
 626         clob1(times);
 627         return (0);
 628 }
 629 #endif /* HAVE_ASSERTS */
 630
 631 /*
 632  * Add the given header fields to the retained list.
 633  * If no arguments, print the current list of retained fields.
 634  */
 635 int
 636 retfield(void *v)
 637 {
 638         char **list = v;
 639
 640         return ignore1(list, ignore + 1, "retained");
 641 }
 642
 643 /*
 644  * Add the given header fields to the ignored list.
 645  * If no arguments, print the current list of ignored fields.
 646  */
 647 int
 648 igfield(void *v)
 649 {
 650         char **list = v;
 651
 652         return ignore1(list, ignore, "ignored");
 653 }
 654
 655 int
 656 saveretfield(void *v)
 657 {
 658         char **list = v;
 659
 660         return ignore1(list, saveignore + 1, "retained");
 661 }
 662
 663 int
 664 saveigfield(void *v)
 665 {
 666         char **list = v;
 667
 668         return ignore1(list, saveignore, "ignored");
 669 }
 670
 671 int
 672 fwdretfield(void *v)
 673 {
 674         char **list = v;
 675
 676         return ignore1(list, fwdignore + 1, "retained");
 677 }
 678
 679 int
 680 fwdigfield(void *v)
 681 {
 682         char **list = v;
 683
 684         return ignore1(list, fwdignore, "ignored");
 685 }
 686
 687 static int
 688 ignore1(char **list, struct ignoretab *tab, char *which)
 689 {
 690         int h;
 691         struct ignore *igp;
 692         char **ap;
 693
 694         if (*list == NULL)
 695                 return igshow(tab, which);
 696         for (ap = list; *ap != 0; ap++) {
 697                 char *field;
 698                 size_t sz;
 699
 700                 sz = strlen(*ap);
 701                 field = ac_alloc(sz + 1);
 702                 i_strcpy(field, *ap, sz + 1);
 703                 field[sz]='\0';
 704                 if (member(field, tab)) {
 705                         ac_free(field);
 706                         continue;
 707                 }
 708                 h = hash(field);
 709                 igp = (struct ignore *)scalloc(1, sizeof (struct ignore));
 710                 igp->i_field = smalloc(strlen(field) + 1);
 711                 strcpy(igp->i_field, field);
 712                 igp->i_link = tab->i_head[h];
 713                 tab->i_head[h] = igp;
 714                 tab->i_count++;
 715                 ac_free(field);
 716         }
 717         return 0;
 718 }
 719
 720 /*
 721  * Print out all currently retained fields.
 722  */
 723 static int
 724 igshow(struct ignoretab *tab, char *which)
 725 {
 726         int h;
 727         struct ignore *igp;
 728         char **ap, **ring;
 729
 730         if (tab->i_count == 0) {
 731                 printf(catgets(catd, CATSET, 34,
 732                                 "No fields currently being %s.\n"), which);
 733                 return 0;
 734         }
 735         /*LINTED*/
 736         ring = (char **)salloc((tab->i_count + 1) * sizeof (char *));
 737         ap = ring;
 738         for (h = 0; h < HSHSIZE; h++)
 739                 for (igp = tab->i_head[h]; igp != 0; igp = igp->i_link)
 740                         *ap++ = igp->i_field;
 741         *ap = 0;
 742         qsort(ring, tab->i_count, sizeof (char *), igcomp);
 743         for (ap = ring; *ap != 0; ap++)
 744                 printf("%s\n", *ap);
 745         return 0;
 746 }
 747
 748 /*
 749  * Compare two names for sorting ignored field list.
 750  */
 751 static int
 752 igcomp(const void *l, const void *r)
 753 {
 754         return (strcmp(*(char **)l, *(char **)r));
 755 }
 756
 757 int
 758 unignore(void *v)
 759 {
 760         return unignore1((char **)v, ignore, "ignored");
 761 }
 762
 763 int
 764 unretain(void *v)
 765 {
 766         return unignore1((char **)v, ignore + 1, "retained");
 767 }
 768
 769 int
 770 unsaveignore(void *v)
 771 {
 772         return unignore1((char **)v, saveignore, "ignored");
 773 }
 774
 775 int
 776 unsaveretain(void *v)
 777 {
 778         return unignore1((char **)v, saveignore + 1, "retained");
 779 }
 780
 781 int
 782 unfwdignore(void *v)
 783 {
 784         return unignore1((char **)v, fwdignore, "ignored");
 785 }
 786
 787 int
 788 unfwdretain(void *v)
 789 {
 790         return unignore1((char **)v, fwdignore + 1, "retained");
 791 }
 792
 793 static void
 794 unignore_one(const char *name, struct ignoretab *tab)
 795 {
 796         struct ignore *ip, *iq = NULL;
 797         int h = hash(name);
 798
 799         for (ip = tab->i_head[h]; ip; ip = ip->i_link) {
 800                 if (asccasecmp(ip->i_field, name) == 0) {
 801                         free(ip->i_field);
 802                         if (iq != NULL)
 803                                 iq->i_link = ip->i_link;
 804                         else
 805                                 tab->i_head[h] = ip->i_link;
 806                         free(ip);
 807                         tab->i_count--;
 808                         break;
 809                 }
 810                 iq = ip;
 811         }
 812 }
 813
 814 static int
 815 unignore1(char **list, struct ignoretab *tab, char *which)
 816 {
 817         if (tab->i_count == 0) {
 818                 printf(catgets(catd, CATSET, 34,
 819                                 "No fields currently being %s.\n"), which);
 820                 return 0;
 821         }
 822         while (*list)
 823                 unignore_one(*list++, tab);
 824         return 0;
 825 }