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