usr.bin/mail/names.c

   1 /*
   2  * Copyright (c) 1980, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#)names.c  8.1 (Berkeley) 6/6/93
  30  * $FreeBSD: src/usr.bin/mail/names.c,v 1.4.6.3 2003/01/06 05:46:03 mikeh Exp $
  31  * $DragonFly: src/usr.bin/mail/names.c,v 1.5 2004/09/08 03:01:11 joerg Exp $
  32  */
  33
  34 /*
  35  * Mail -- a mail program
  36  *
  37  * Handle name lists.
  38  */
  39
  40 #include "rcv.h"
  41 #include <fcntl.h>
  42 #include "extern.h"
  43
  44 /*
  45  * Allocate a single element of a name list,
  46  * initialize its name field to the passed
  47  * name and return it.
  48  */
  49 struct name *
  50 nalloc(char *str, int ntype)
  51 {
  52         struct name *np;
  53
  54         np = (struct name *)salloc(sizeof(*np));
  55         np->n_flink = NULL;
  56         np->n_blink = NULL;
  57         np->n_type = ntype;
  58         np->n_name = savestr(str);
  59         return (np);
  60 }
  61
  62 /*
  63  * Find the tail of a list and return it.
  64  */
  65 struct name *
  66 tailof(struct name *name)
  67 {
  68         struct name *np;
  69
  70         np = name;
  71         if (np == NULL)
  72                 return (NULL);
  73         while (np->n_flink != NULL)
  74                 np = np->n_flink;
  75         return (np);
  76 }
  77
  78 /*
  79  * Extract a list of names from a line,
  80  * and make a list of names from it.
  81  * Return the list or NULL if none found.
  82  */
  83 struct name *
  84 extract(char *line, int ntype)
  85 {
  86         char *cp, *nbuf;
  87         struct name *top, *np, *t;
  88
  89         if (line == NULL || *line == '\0')
  90                 return (NULL);
  91         if ((nbuf = malloc(strlen(line) + 1)) == NULL)
  92                 err(1, "Out of memory");
  93         top = NULL;
  94         np = NULL;
  95         cp = line;
  96         while ((cp = yankword(cp, nbuf)) != NULL) {
  97                 t = nalloc(nbuf, ntype);
  98                 if (top == NULL)
  99                         top = t;
 100                 else
 101                         np->n_flink = t;
 102                 t->n_blink = np;
 103                 np = t;
 104         }
 105         free(nbuf);
 106         return (top);
 107 }
 108
 109 /*
 110  * Turn a list of names into a string of the same names.
 111  */
 112 char *
 113 detract(struct name *np, int ntype)
 114 {
 115         int s, comma;
 116         char *cp, *top;
 117         struct name *p;
 118
 119         comma = ntype & GCOMMA;
 120         if (np == NULL)
 121                 return (NULL);
 122         ntype &= ~GCOMMA;
 123         s = 0;
 124         if (debug && comma)
 125                 fprintf(stderr, "detract asked to insert commas\n");
 126         for (p = np; p != NULL; p = p->n_flink) {
 127                 if (ntype && (p->n_type & GMASK) != ntype)
 128                         continue;
 129                 s += strlen(p->n_name) + 1;
 130                 if (comma)
 131                         s++;
 132         }
 133         if (s == 0)
 134                 return (NULL);
 135         s += 2;
 136         top = salloc(s);
 137         cp = top;
 138         for (p = np; p != NULL; p = p->n_flink) {
 139                 if (ntype && (p->n_type & GMASK) != ntype)
 140                         continue;
 141                 cp += strlcpy(cp, p->n_name, strlen(p->n_name) + 1);
 142                 if (comma && p->n_flink != NULL)
 143                         *cp++ = ',';
 144                 *cp++ = ' ';
 145         }
 146         *--cp = '\0';
 147         if (comma && *--cp == ',')
 148                 *cp = '\0';
 149         return (top);
 150 }
 151
 152 /*
 153  * Grab a single word (liberal word)
 154  * Throw away things between ()'s, and take anything between <>.
 155  */
 156 char *
 157 yankword(char *ap, char *wbuf)
 158 {
 159         char *cp, *cp2;
 160
 161         cp = ap;
 162         for (;;) {
 163                 if (*cp == '\0')
 164                         return (NULL);
 165                 if (*cp == '(') {
 166                         int nesting = 0;
 167
 168                         while (*cp != '\0') {
 169                                 switch (*cp++) {
 170                                 case '(':
 171                                         nesting++;
 172                                         break;
 173                                 case ')':
 174                                         --nesting;
 175                                         break;
 176                                 }
 177                                 if (nesting <= 0)
 178                                         break;
 179                         }
 180                 } else if (*cp == ' ' || *cp == '\t' || *cp == ',')
 181                         cp++;
 182                 else
 183                         break;
 184         }
 185         if (*cp ==  '<')
 186                 for (cp2 = wbuf; *cp && (*cp2++ = *cp++) != '>';)
 187                         ;
 188         else
 189                 for (cp2 = wbuf; *cp != '\0' && strchr(" \t,(", *cp) == NULL;
 190                     *cp2++ = *cp++)
 191                         ;
 192         *cp2 = '\0';
 193         return (cp);
 194 }
 195
 196 /*
 197  * Grab a single login name (liberal word).
 198  * Throw away things between ()'s, take anything between <>,
 199  * and look for words before metacharacters %, @, !.
 200  */
 201 char *
 202 yanklogin(char *ap, char *wbuf)
 203 {
 204         char *cp, *cp2, *cp_temp;
 205         int n;
 206
 207         cp = ap;
 208         for (;;) {
 209                 if (*cp == '\0')
 210                         return (NULL);
 211                 if (*cp == '(') {
 212                         int nesting = 0;
 213
 214                         while (*cp != '\0') {
 215                                 switch (*cp++) {
 216                                 case '(':
 217                                         nesting++;
 218                                         break;
 219                                 case ')':
 220                                         nesting--;
 221                                         break;
 222                                 }
 223                                 if (nesting <= 0)
 224                                         break;
 225                         }
 226                 } else if (*cp == ' ' || *cp == '\t' || *cp == ',') {
 227                         cp++;
 228                 } else {
 229                         break;
 230                 }
 231         }
 232
 233         /*
 234          * Now, let's go forward till we meet the needed character,
 235          * and step one word back.
 236          */
 237
 238         /* First, remember current point. */
 239         cp_temp = cp;
 240         n = 0;
 241
 242         /*
 243          * Note that we look ahead in a cycle. This is safe, since
 244          * non-end of string is checked first.
 245          */
 246         while (*cp != '\0' && strchr("@%!", *(cp + 1)) == NULL)
 247                 cp ++;
 248
 249         /*
 250          * Now, start stepping back to the first non-word character,
 251          * while counting the number of symbols in a word.
 252          */
 253         while (cp != cp_temp && strchr(" \t,<>", *(cp - 1)) == NULL) {
 254                 n++;
 255                 cp--;
 256         }
 257
 258         /* Finally, grab the word forward. */
 259         cp2 = wbuf;
 260         while (n >= 0) {
 261                 *cp++ = *cp++;
 262                 n--;
 263         }
 264
 265         *cp2 = '\0';
 266         return (cp);
 267 }
 268
 269 /*
 270  * For each recipient in the passed name list with a /
 271  * in the name, append the message to the end of the named file
 272  * and remove him from the recipient list.
 273  *
 274  * Recipients whose name begins with | are piped through the given
 275  * program and removed.
 276  */
 277 struct name *
 278 outof(struct name *names, FILE *fo, struct header *hp)
 279 {
 280         int c, ispipe;
 281         struct name *np, *top;
 282         time_t now;
 283         char *date, *fname;
 284         FILE *fout, *fin;
 285
 286         top = names;
 287         np = names;
 288         time(&now);
 289         date = ctime(&now);
 290         while (np != NULL) {
 291                 if (!isfileaddr(np->n_name) && np->n_name[0] != '|') {
 292                         np = np->n_flink;
 293                         continue;
 294                 }
 295                 ispipe = np->n_name[0] == '|';
 296                 if (ispipe)
 297                         fname = np->n_name+1;
 298                 else
 299                         fname = expand(np->n_name);
 300
 301                 /*
 302                  * See if we have copied the complete message out yet.
 303                  * If not, do so.
 304                  */
 305
 306                 if (image < 0) {
 307                         int fd;
 308                         char tempname[PATHSIZE];
 309
 310                         snprintf(tempname, sizeof(tempname),
 311                                  "%s/mail.ReXXXXXXXXXX", tmpdir);
 312                         if ((fd = mkstemp(tempname)) == -1 ||
 313                             (fout = Fdopen(fd, "a")) == NULL) {
 314                                 warn("%s", tempname);
 315                                 senderr++;
 316                                 goto cant;
 317                         }
 318                         image = open(tempname, O_RDWR);
 319                         rm(tempname);
 320                         if (image < 0) {
 321                                 warn("%s", tempname);
 322                                 senderr++;
 323                                 Fclose(fout);
 324                                 goto cant;
 325                         }
 326                         fcntl(image, F_SETFD, 1);
 327                         fprintf(fout, "From %s %s", myname, date);
 328                         puthead(hp, fout,
 329                             GTO|GSUBJECT|GCC|GREPLYTO|GINREPLYTO|GNL);
 330                         while ((c = getc(fo)) != EOF)
 331                                 putc(c, fout);
 332                         rewind(fo);
 333                         fprintf(fout, "\n");
 334                         fflush(fout);
 335                         if (ferror(fout)) {
 336                                 warn("%s", tempname);
 337                                 senderr++;
 338                                 Fclose(fout);
 339                                 goto cant;
 340                         }
 341                         Fclose(fout);
 342                 }
 343
 344                 /*
 345                  * Now either copy "image" to the desired file
 346                  * or give it as the standard input to the desired
 347                  * program as appropriate.
 348                  */
 349
 350                 if (ispipe) {
 351                         int pid;
 352                         char *sh;
 353                         sigset_t nset;
 354
 355                         /*
 356                          * XXX
 357                          * We can't really reuse the same image file,
 358                          * because multiple piped recipients will
 359                          * share the same lseek location and trample
 360                          * on one another.
 361                          */
 362                         if ((sh = value("SHELL")) == NULL)
 363                                 sh = _PATH_CSHELL;
 364                         sigemptyset(&nset);
 365                         sigaddset(&nset, SIGHUP);
 366                         sigaddset(&nset, SIGINT);
 367                         sigaddset(&nset, SIGQUIT);
 368                         pid = start_command(sh, &nset, image, -1, "-c", fname,
 369                             NULL);
 370                         if (pid < 0) {
 371                                 senderr++;
 372                                 goto cant;
 373                         }
 374                         free_child(pid);
 375                 } else {
 376                         int f;
 377                         if ((fout = Fopen(fname, "a")) == NULL) {
 378                                 warn("%s", fname);
 379                                 senderr++;
 380                                 goto cant;
 381                         }
 382                         if ((f = dup(image)) < 0) {
 383                                 warn("dup");
 384                                 fin = NULL;
 385                         } else
 386                                 fin = Fdopen(f, "r");
 387                         if (fin == NULL) {
 388                                 fprintf(stderr, "Can't reopen image\n");
 389                                 Fclose(fout);
 390                                 senderr++;
 391                                 goto cant;
 392                         }
 393                         rewind(fin);
 394                         while ((c = getc(fin)) != EOF)
 395                                 putc(c, fout);
 396                         if (ferror(fout)) {
 397                                 warnx("%s", fname);
 398                                 senderr++;
 399                                 Fclose(fout);
 400                                 Fclose(fin);
 401                                 goto cant;
 402                         }
 403                         Fclose(fout);
 404                         Fclose(fin);
 405                 }
 406 cant:
 407                 /*
 408                  * In days of old we removed the entry from the
 409                  * the list; now for sake of header expansion
 410                  * we leave it in and mark it as deleted.
 411                  */
 412                 np->n_type |= GDEL;
 413                 np = np->n_flink;
 414         }
 415         if (image >= 0) {
 416                 close(image);
 417                 image = -1;
 418         }
 419         return (top);
 420 }
 421
 422 /*
 423  * Determine if the passed address is a local "send to file" address.
 424  * If any of the network metacharacters precedes any slashes, it can't
 425  * be a filename.  We cheat with .'s to allow path names like ./...
 426  */
 427 int
 428 isfileaddr(char *name)
 429 {
 430         char *cp;
 431
 432         if (*name == '+')
 433                 return (1);
 434         for (cp = name; *cp != '\0'; cp++) {
 435                 if (*cp == '!' || *cp == '%' || *cp == '@')
 436                         return (0);
 437                 if (*cp == '/')
 438                         return (1);
 439         }
 440         return (0);
 441 }
 442
 443 /*
 444  * Map all of the aliased users in the invoker's mailrc
 445  * file and insert them into the list.
 446  * Changed after all these months of service to recursively
 447  * expand names (2/14/80).
 448  */
 449
 450 struct name *
 451 usermap(struct name *names)
 452 {
 453         struct name *new, *np, *cp;
 454         struct grouphead *gh;
 455         int metoo;
 456
 457         new = NULL;
 458         np = names;
 459         metoo = (value("metoo") != NULL);
 460         while (np != NULL) {
 461                 if (np->n_name[0] == '\\') {
 462                         cp = np->n_flink;
 463                         new = put(new, np);
 464                         np = cp;
 465                         continue;
 466                 }
 467                 gh = findgroup(np->n_name);
 468                 cp = np->n_flink;
 469                 if (gh != NULL)
 470                         new = gexpand(new, gh, metoo, np->n_type);
 471                 else
 472                         new = put(new, np);
 473                 np = cp;
 474         }
 475         return (new);
 476 }
 477
 478 /*
 479  * Recursively expand a group name.  We limit the expansion to some
 480  * fixed level to keep things from going haywire.
 481  * Direct recursion is not expanded for convenience.
 482  */
 483
 484 struct name *
 485 gexpand(struct name *nlist, struct grouphead *gh, int metoo, int ntype)
 486 {
 487         struct group *gp;
 488         struct grouphead *ngh;
 489         struct name *np;
 490         static int depth;
 491         char *cp;
 492
 493         if (depth > MAXEXP) {
 494                 printf("Expanding alias to depth larger than %d\n", MAXEXP);
 495                 return (nlist);
 496         }
 497         depth++;
 498         for (gp = gh->g_list; gp != NULL; gp = gp->ge_link) {
 499                 cp = gp->ge_name;
 500                 if (*cp == '\\')
 501                         goto quote;
 502                 if (strcmp(cp, gh->g_name) == 0)
 503                         goto quote;
 504                 if ((ngh = findgroup(cp)) != NULL) {
 505                         nlist = gexpand(nlist, ngh, metoo, ntype);
 506                         continue;
 507                 }
 508 quote:
 509                 np = nalloc(cp, ntype);
 510                 /*
 511                  * At this point should allow to expand
 512                  * to self if only person in group
 513                  */
 514                 if (gp == gh->g_list && gp->ge_link == NULL)
 515                         goto skip;
 516                 if (!metoo && strcmp(cp, myname) == 0)
 517                         np->n_type |= GDEL;
 518 skip:
 519                 nlist = put(nlist, np);
 520         }
 521         depth--;
 522         return (nlist);
 523 }
 524
 525 /*
 526  * Concatenate the two passed name lists, return the result.
 527  */
 528 struct name *
 529 cat(struct name *n1, struct name *n2)
 530 {
 531         struct name *tail;
 532
 533         if (n1 == NULL)
 534                 return (n2);
 535         if (n2 == NULL)
 536                 return (n1);
 537         tail = tailof(n1);
 538         tail->n_flink = n2;
 539         n2->n_blink = tail;
 540         return (n1);
 541 }
 542
 543 /*
 544  * Unpack the name list onto a vector of strings.
 545  * Return an error if the name list won't fit.
 546  */
 547 char **
 548 unpack(struct name *np)
 549 {
 550         char **ap, **top;
 551         struct name *n;
 552         int t, extra, metoo, verbose;
 553
 554         n = np;
 555         if ((t = count(n)) == 0)
 556                 errx(1, "No names to unpack");
 557         /*
 558          * Compute the number of extra arguments we will need.
 559          * We need at least two extra -- one for "mail" and one for
 560          * the terminating 0 pointer.  Additional spots may be needed
 561          * to pass along -f to the host mailer.
 562          */
 563         extra = 2;
 564         extra++;
 565         metoo = value("metoo") != NULL;
 566         if (metoo)
 567                 extra++;
 568         verbose = value("verbose") != NULL;
 569         if (verbose)
 570                 extra++;
 571         top = (char **)salloc((t + extra) * sizeof(*top));
 572         ap = top;
 573         *ap++ = "send-mail";
 574         *ap++ = "-i";
 575         if (metoo)
 576                 *ap++ = "-m";
 577         if (verbose)
 578                 *ap++ = "-v";
 579         for (; n != NULL; n = n->n_flink)
 580                 if ((n->n_type & GDEL) == 0)
 581                         *ap++ = n->n_name;
 582         *ap = NULL;
 583         return (top);
 584 }
 585
 586 /*
 587  * Remove all of the duplicates from the passed name list by
 588  * insertion sorting them, then checking for dups.
 589  * Return the head of the new list.
 590  */
 591 struct name *
 592 elide(struct name *names)
 593 {
 594         struct name *np, *t, *new;
 595         struct name *x;
 596
 597         if (names == NULL)
 598                 return (NULL);
 599         new = names;
 600         np = names;
 601         np = np->n_flink;
 602         if (np != NULL)
 603                 np->n_blink = NULL;
 604         new->n_flink = NULL;
 605         while (np != NULL) {
 606                 t = new;
 607                 while (strcasecmp(t->n_name, np->n_name) < 0) {
 608                         if (t->n_flink == NULL)
 609                                 break;
 610                         t = t->n_flink;
 611                 }
 612
 613                 /*
 614                  * If we ran out of t's, put the new entry after
 615                  * the current value of t.
 616                  */
 617
 618                 if (strcasecmp(t->n_name, np->n_name) < 0) {
 619                         t->n_flink = np;
 620                         np->n_blink = t;
 621                         t = np;
 622                         np = np->n_flink;
 623                         t->n_flink = NULL;
 624                         continue;
 625                 }
 626
 627                 /*
 628                  * Otherwise, put the new entry in front of the
 629                  * current t.  If at the front of the list,
 630                  * the new guy becomes the new head of the list.
 631                  */
 632
 633                 if (t == new) {
 634                         t = np;
 635                         np = np->n_flink;
 636                         t->n_flink = new;
 637                         new->n_blink = t;
 638                         t->n_blink = NULL;
 639                         new = t;
 640                         continue;
 641                 }
 642
 643                 /*
 644                  * The normal case -- we are inserting into the
 645                  * middle of the list.
 646                  */
 647
 648                 x = np;
 649                 np = np->n_flink;
 650                 x->n_flink = t;
 651                 x->n_blink = t->n_blink;
 652                 t->n_blink->n_flink = x;
 653                 t->n_blink = x;
 654         }
 655
 656         /*
 657          * Now the list headed up by new is sorted.
 658          * Go through it and remove duplicates.
 659          */
 660
 661         np = new;
 662         while (np != NULL) {
 663                 t = np;
 664                 while (t->n_flink != NULL &&
 665                     strcasecmp(np->n_name, t->n_flink->n_name) == 0)
 666                         t = t->n_flink;
 667                 if (t == np || t == NULL) {
 668                         np = np->n_flink;
 669                         continue;
 670                 }
 671
 672                 /*
 673                  * Now t points to the last entry with the same name
 674                  * as np.  Make np point beyond t.
 675                  */
 676
 677                 np->n_flink = t->n_flink;
 678                 if (t->n_flink != NULL)
 679                         t->n_flink->n_blink = np;
 680                 np = np->n_flink;
 681         }
 682         return (new);
 683 }
 684
 685 /*
 686  * Put another node onto a list of names and return
 687  * the list.
 688  */
 689 struct name *
 690 put(struct name *list, struct name *node)
 691 {
 692         node->n_flink = list;
 693         node->n_blink = NULL;
 694         if (list != NULL)
 695                 list->n_blink = node;
 696         return (node);
 697 }
 698
 699 /*
 700  * Determine the number of undeleted elements in
 701  * a name list and return it.
 702  */
 703 int
 704 count(struct name *np)
 705 {
 706         int c;
 707
 708         for (c = 0; np != NULL; np = np->n_flink)
 709                 if ((np->n_type & GDEL) == 0)
 710                         c++;
 711         return (c);
 712 }
 713
 714 /*
 715  * Delete the given name from a namelist.
 716  */
 717 struct name *
 718 delname(struct name *np, char *name)
 719 {
 720         struct name *p;
 721
 722         for (p = np; p != NULL; p = p->n_flink)
 723                 if (strcasecmp(p->n_name, name) == 0) {
 724                         if (p->n_blink == NULL) {
 725                                 if (p->n_flink != NULL)
 726                                         p->n_flink->n_blink = NULL;
 727                                 np = p->n_flink;
 728                                 continue;
 729                         }
 730                         if (p->n_flink == NULL) {
 731                                 if (p->n_blink != NULL)
 732                                         p->n_blink->n_flink = NULL;
 733                                 continue;
 734                         }
 735                         p->n_blink->n_flink = p->n_flink;
 736                         p->n_flink->n_blink = p->n_blink;
 737                 }
 738         return (np);
 739 }
 740
 741 /*
 742  * Pretty print a name list
 743  * Uncomment it if you need it.
 744  */
 745
 746 /*
 747 void
 748 prettyprint(struct name *name)
 749 {
 750         struct name *np;
 751
 752         np = name;
 753         while (np != NULL) {
 754                 fprintf(stderr, "%s(%d) ", np->n_name, np->n_type);
 755                 np = np->n_flink;
 756         }
 757         fprintf(stderr, "\n");
 758 }
 759 */