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 * @(#)cmd3.c 8.2 (Berkeley) 4/20/95 34 * $FreeBSD: src/usr.bin/mail/cmd3.c,v 1.4.6.4 2003/01/06 05:46:03 mikeh Exp $ 35 * $DragonFly: src/usr.bin/mail/cmd3.c,v 1.2 2003/06/17 04:29:28 dillon Exp $ 36 */ 37 38 #include "rcv.h" 39 #include "extern.h" 40 41 /* 42 * Mail -- a mail program 43 * 44 * Still more user commands. 45 */ 46 47 /* 48 * Process a shell escape by saving signals, ignoring signals, 49 * and forking a sh -c 50 */ 51 int 52 shell(str) 53 char *str; 54 { 55 sig_t sigint = signal(SIGINT, SIG_IGN); 56 char *sh; 57 char cmd[BUFSIZ]; 58 59 if (strlcpy(cmd, str, sizeof(cmd)) >= sizeof(cmd)) 60 return (1); 61 if (bangexp(cmd, sizeof(cmd)) < 0) 62 return (1); 63 if ((sh = value("SHELL")) == NULL) 64 sh = _PATH_CSHELL; 65 (void)run_command(sh, 0, -1, -1, "-c", cmd, NULL); 66 (void)signal(SIGINT, sigint); 67 printf("!\n"); 68 return (0); 69 } 70 71 /* 72 * Fork an interactive shell. 73 */ 74 /*ARGSUSED*/ 75 int 76 dosh(str) 77 char *str; 78 { 79 sig_t sigint = signal(SIGINT, SIG_IGN); 80 char *sh; 81 82 if ((sh = value("SHELL")) == NULL) 83 sh = _PATH_CSHELL; 84 (void)run_command(sh, 0, -1, -1, NULL, NULL, NULL); 85 (void)signal(SIGINT, sigint); 86 printf("\n"); 87 return (0); 88 } 89 90 /* 91 * Expand the shell escape by expanding unescaped !'s into the 92 * last issued command where possible. 93 */ 94 int 95 bangexp(str, strsize) 96 char *str; 97 size_t strsize; 98 { 99 char bangbuf[BUFSIZ]; 100 static char lastbang[BUFSIZ]; 101 char *cp, *cp2; 102 int n, changed = 0; 103 104 cp = str; 105 cp2 = bangbuf; 106 n = sizeof(bangbuf); 107 while (*cp != '\0') { 108 if (*cp == '!') { 109 if (n < strlen(lastbang)) { 110 overf: 111 printf("Command buffer overflow\n"); 112 return (-1); 113 } 114 changed++; 115 if (strlcpy(cp2, lastbang, sizeof(bangbuf) - (cp2 - bangbuf)) 116 >= sizeof(bangbuf) - (cp2 - bangbuf)) 117 goto overf; 118 cp2 += strlen(lastbang); 119 n -= strlen(lastbang); 120 cp++; 121 continue; 122 } 123 if (*cp == '\\' && cp[1] == '!') { 124 if (--n <= 1) 125 goto overf; 126 *cp2++ = '!'; 127 cp += 2; 128 changed++; 129 } 130 if (--n <= 1) 131 goto overf; 132 *cp2++ = *cp++; 133 } 134 *cp2 = 0; 135 if (changed) { 136 printf("!%s\n", bangbuf); 137 (void)fflush(stdout); 138 } 139 if (strlcpy(str, bangbuf, strsize) >= strsize) 140 goto overf; 141 if (strlcpy(lastbang, bangbuf, sizeof(lastbang)) >= sizeof(lastbang)) 142 goto overf; 143 return (0); 144 } 145 146 /* 147 * Print out a nice help message from some file or another. 148 */ 149 150 int 151 help() 152 { 153 int c; 154 FILE *f; 155 156 if ((f = Fopen(_PATH_HELP, "r")) == NULL) { 157 warn("%s", _PATH_HELP); 158 return (1); 159 } 160 while ((c = getc(f)) != EOF) 161 putchar(c); 162 (void)Fclose(f); 163 return (0); 164 } 165 166 /* 167 * Change user's working directory. 168 */ 169 int 170 schdir(arglist) 171 char **arglist; 172 { 173 char *cp; 174 175 if (*arglist == NULL) { 176 if (homedir == NULL) 177 return (1); 178 cp = homedir; 179 } else 180 if ((cp = expand(*arglist)) == NULL) 181 return (1); 182 if (chdir(cp) < 0) { 183 warn("%s", cp); 184 return (1); 185 } 186 return (0); 187 } 188 189 int 190 respond(msgvec) 191 int *msgvec; 192 { 193 if (value("Replyall") == NULL && value("flipr") == NULL) 194 return (dorespond(msgvec)); 195 else 196 return (doRespond(msgvec)); 197 } 198 199 /* 200 * Reply to a list of messages. Extract each name from the 201 * message header and send them off to mail1() 202 */ 203 int 204 dorespond(msgvec) 205 int *msgvec; 206 { 207 struct message *mp; 208 char *cp, *rcv, *replyto; 209 char **ap; 210 struct name *np; 211 struct header head; 212 213 if (msgvec[1] != 0) { 214 printf("Sorry, can't reply to multiple messages at once\n"); 215 return (1); 216 } 217 mp = &message[msgvec[0] - 1]; 218 touch(mp); 219 dot = mp; 220 if ((rcv = skin(hfield("from", mp))) == NULL) 221 rcv = skin(nameof(mp, 1)); 222 if ((replyto = skin(hfield("reply-to", mp))) != NULL) 223 np = extract(replyto, GTO); 224 else if ((cp = skin(hfield("to", mp))) != NULL) 225 np = extract(cp, GTO); 226 else 227 np = NULL; 228 np = elide(np); 229 /* 230 * Delete my name from the reply list, 231 * and with it, all my alternate names. 232 */ 233 np = delname(np, myname); 234 if (altnames) 235 for (ap = altnames; *ap != NULL; ap++) 236 np = delname(np, *ap); 237 if (np != NULL && replyto == NULL) 238 np = cat(np, extract(rcv, GTO)); 239 else if (np == NULL) { 240 if (replyto != NULL) 241 printf("Empty reply-to field -- replying to author\n"); 242 np = extract(rcv, GTO); 243 } 244 head.h_to = np; 245 if ((head.h_subject = hfield("subject", mp)) == NULL) 246 head.h_subject = hfield("subj", mp); 247 head.h_subject = reedit(head.h_subject); 248 if (replyto == NULL && (cp = skin(hfield("cc", mp))) != NULL) { 249 np = elide(extract(cp, GCC)); 250 np = delname(np, myname); 251 if (altnames != 0) 252 for (ap = altnames; *ap != NULL; ap++) 253 np = delname(np, *ap); 254 head.h_cc = np; 255 } else 256 head.h_cc = NULL; 257 head.h_bcc = NULL; 258 head.h_smopts = NULL; 259 head.h_replyto = value("REPLYTO"); 260 head.h_inreplyto = skin(hfield("message-id", mp)); 261 mail1(&head, 1); 262 return (0); 263 } 264 265 /* 266 * Modify the subject we are replying to to begin with Re: if 267 * it does not already. 268 */ 269 char * 270 reedit(subj) 271 char *subj; 272 { 273 char *newsubj; 274 275 if (subj == NULL) 276 return (NULL); 277 if ((subj[0] == 'r' || subj[0] == 'R') && 278 (subj[1] == 'e' || subj[1] == 'E') && 279 subj[2] == ':') 280 return (subj); 281 newsubj = salloc(strlen(subj) + 5); 282 sprintf(newsubj, "Re: %s", subj); 283 return (newsubj); 284 } 285 286 /* 287 * Preserve the named messages, so that they will be sent 288 * back to the system mailbox. 289 */ 290 int 291 preserve(msgvec) 292 int *msgvec; 293 { 294 int *ip, mesg; 295 struct message *mp; 296 297 if (edit) { 298 printf("Cannot \"preserve\" in edit mode\n"); 299 return (1); 300 } 301 for (ip = msgvec; *ip != 0; ip++) { 302 mesg = *ip; 303 mp = &message[mesg-1]; 304 mp->m_flag |= MPRESERVE; 305 mp->m_flag &= ~MBOX; 306 dot = mp; 307 } 308 return (0); 309 } 310 311 /* 312 * Mark all given messages as unread. 313 */ 314 int 315 unread(msgvec) 316 int msgvec[]; 317 { 318 int *ip; 319 320 for (ip = msgvec; *ip != 0; ip++) { 321 dot = &message[*ip-1]; 322 dot->m_flag &= ~(MREAD|MTOUCH); 323 dot->m_flag |= MSTATUS; 324 } 325 return (0); 326 } 327 328 /* 329 * Print the size of each message. 330 */ 331 int 332 messize(msgvec) 333 int *msgvec; 334 { 335 struct message *mp; 336 int *ip, mesg; 337 338 for (ip = msgvec; *ip != 0; ip++) { 339 mesg = *ip; 340 mp = &message[mesg-1]; 341 printf("%d: %ld/%ld\n", mesg, mp->m_lines, mp->m_size); 342 } 343 return (0); 344 } 345 346 /* 347 * Quit quickly. If we are sourcing, just pop the input level 348 * by returning an error. 349 */ 350 int 351 rexit(e) 352 int e; 353 { 354 if (sourcing) 355 return (1); 356 exit(0); 357 /*NOTREACHED*/ 358 } 359 360 /* 361 * Set or display a variable value. Syntax is similar to that 362 * of csh. 363 */ 364 int 365 set(arglist) 366 char **arglist; 367 { 368 struct var *vp; 369 char *cp, *cp2; 370 char varbuf[BUFSIZ], **ap, **p; 371 int errs, h, s; 372 373 if (*arglist == NULL) { 374 for (h = 0, s = 1; h < HSHSIZE; h++) 375 for (vp = variables[h]; vp != NULL; vp = vp->v_link) 376 s++; 377 ap = (char **)salloc(s * sizeof(*ap)); 378 for (h = 0, p = ap; h < HSHSIZE; h++) 379 for (vp = variables[h]; vp != NULL; vp = vp->v_link) 380 *p++ = vp->v_name; 381 *p = NULL; 382 sort(ap); 383 for (p = ap; *p != NULL; p++) 384 printf("%s\t%s\n", *p, value(*p)); 385 return (0); 386 } 387 errs = 0; 388 for (ap = arglist; *ap != NULL; ap++) { 389 cp = *ap; 390 cp2 = varbuf; 391 while (cp2 < varbuf + sizeof(varbuf) - 1 && *cp != '=' && *cp != '\0') 392 *cp2++ = *cp++; 393 *cp2 = '\0'; 394 if (*cp == '\0') 395 cp = ""; 396 else 397 cp++; 398 if (equal(varbuf, "")) { 399 printf("Non-null variable name required\n"); 400 errs++; 401 continue; 402 } 403 assign(varbuf, cp); 404 } 405 return (errs); 406 } 407 408 /* 409 * Unset a bunch of variable values. 410 */ 411 int 412 unset(arglist) 413 char **arglist; 414 { 415 struct var *vp, *vp2; 416 int errs, h; 417 char **ap; 418 419 errs = 0; 420 for (ap = arglist; *ap != NULL; ap++) { 421 if ((vp2 = lookup(*ap)) == NULL) { 422 if (getenv(*ap)) 423 unsetenv(*ap); 424 else if (!sourcing) { 425 printf("\"%s\": undefined variable\n", *ap); 426 errs++; 427 } 428 continue; 429 } 430 h = hash(*ap); 431 if (vp2 == variables[h]) { 432 variables[h] = variables[h]->v_link; 433 vfree(vp2->v_name); 434 vfree(vp2->v_value); 435 (void)free(vp2); 436 continue; 437 } 438 for (vp = variables[h]; vp->v_link != vp2; vp = vp->v_link) 439 ; 440 vp->v_link = vp2->v_link; 441 vfree(vp2->v_name); 442 vfree(vp2->v_value); 443 (void)free(vp2); 444 } 445 return (errs); 446 } 447 448 /* 449 * Put add users to a group. 450 */ 451 int 452 group(argv) 453 char **argv; 454 { 455 struct grouphead *gh; 456 struct group *gp; 457 char **ap, *gname, **p; 458 int h, s; 459 460 if (*argv == NULL) { 461 for (h = 0, s = 1; h < HSHSIZE; h++) 462 for (gh = groups[h]; gh != NULL; gh = gh->g_link) 463 s++; 464 ap = (char **)salloc(s * sizeof(*ap)); 465 for (h = 0, p = ap; h < HSHSIZE; h++) 466 for (gh = groups[h]; gh != NULL; gh = gh->g_link) 467 *p++ = gh->g_name; 468 *p = NULL; 469 sort(ap); 470 for (p = ap; *p != NULL; p++) 471 printgroup(*p); 472 return (0); 473 } 474 if (argv[1] == NULL) { 475 printgroup(*argv); 476 return (0); 477 } 478 gname = *argv; 479 h = hash(gname); 480 if ((gh = findgroup(gname)) == NULL) { 481 gh = calloc(sizeof(*gh), 1); 482 gh->g_name = vcopy(gname); 483 gh->g_list = NULL; 484 gh->g_link = groups[h]; 485 groups[h] = gh; 486 } 487 488 /* 489 * Insert names from the command list into the group. 490 * Who cares if there are duplicates? They get tossed 491 * later anyway. 492 */ 493 494 for (ap = argv+1; *ap != NULL; ap++) { 495 gp = calloc(sizeof(*gp), 1); 496 gp->ge_name = vcopy(*ap); 497 gp->ge_link = gh->g_list; 498 gh->g_list = gp; 499 } 500 return (0); 501 } 502 503 /* 504 * Sort the passed string vecotor into ascending dictionary 505 * order. 506 */ 507 void 508 sort(list) 509 char **list; 510 { 511 char **ap; 512 513 for (ap = list; *ap != NULL; ap++) 514 ; 515 if (ap-list < 2) 516 return; 517 qsort(list, ap-list, sizeof(*list), diction); 518 } 519 520 /* 521 * Do a dictionary order comparison of the arguments from 522 * qsort. 523 */ 524 int 525 diction(a, b) 526 const void *a, *b; 527 { 528 return (strcmp(*(const char **)a, *(const char **)b)); 529 } 530 531 /* 532 * The do nothing command for comments. 533 */ 534 535 /*ARGSUSED*/ 536 int 537 null(e) 538 int e; 539 { 540 return (0); 541 } 542 543 /* 544 * Change to another file. With no argument, print information about 545 * the current file. 546 */ 547 int 548 file(argv) 549 char **argv; 550 { 551 552 if (argv[0] == NULL) { 553 newfileinfo(0); 554 return (0); 555 } 556 if (setfile(*argv) < 0) 557 return (1); 558 announce(); 559 return (0); 560 } 561 562 /* 563 * Expand file names like echo 564 */ 565 int 566 echo(argv) 567 char **argv; 568 { 569 char **ap, *cp; 570 571 for (ap = argv; *ap != NULL; ap++) { 572 cp = *ap; 573 if ((cp = expand(cp)) != NULL) { 574 if (ap != argv) 575 printf(" "); 576 printf("%s", cp); 577 } 578 } 579 printf("\n"); 580 return (0); 581 } 582 583 int 584 Respond(msgvec) 585 int *msgvec; 586 { 587 if (value("Replyall") == NULL && value("flipr") == NULL) 588 return (doRespond(msgvec)); 589 else 590 return (dorespond(msgvec)); 591 } 592 593 /* 594 * Reply to a series of messages by simply mailing to the senders 595 * and not messing around with the To: and Cc: lists as in normal 596 * reply. 597 */ 598 int 599 doRespond(msgvec) 600 int msgvec[]; 601 { 602 struct header head; 603 struct message *mp; 604 int *ap; 605 char *cp, *mid; 606 607 head.h_to = NULL; 608 for (ap = msgvec; *ap != 0; ap++) { 609 mp = &message[*ap - 1]; 610 touch(mp); 611 dot = mp; 612 if ((cp = skin(hfield("from", mp))) == NULL) 613 cp = skin(nameof(mp, 2)); 614 head.h_to = cat(head.h_to, extract(cp, GTO)); 615 mid = skin(hfield("message-id", mp)); 616 } 617 if (head.h_to == NULL) 618 return (0); 619 mp = &message[msgvec[0] - 1]; 620 if ((head.h_subject = hfield("subject", mp)) == NULL) 621 head.h_subject = hfield("subj", mp); 622 head.h_subject = reedit(head.h_subject); 623 head.h_cc = NULL; 624 head.h_bcc = NULL; 625 head.h_smopts = NULL; 626 head.h_replyto = value("REPLYTO"); 627 head.h_inreplyto = mid; 628 mail1(&head, 1); 629 return (0); 630 } 631 632 /* 633 * Conditional commands. These allow one to parameterize one's 634 * .mailrc and do some things if sending, others if receiving. 635 */ 636 int 637 ifcmd(argv) 638 char **argv; 639 { 640 char *cp; 641 642 if (cond != CANY) { 643 printf("Illegal nested \"if\"\n"); 644 return (1); 645 } 646 cond = CANY; 647 cp = argv[0]; 648 switch (*cp) { 649 case 'r': case 'R': 650 cond = CRCV; 651 break; 652 653 case 's': case 'S': 654 cond = CSEND; 655 break; 656 657 default: 658 printf("Unrecognized if-keyword: \"%s\"\n", cp); 659 return (1); 660 } 661 return (0); 662 } 663 664 /* 665 * Implement 'else'. This is pretty simple -- we just 666 * flip over the conditional flag. 667 */ 668 int 669 elsecmd() 670 { 671 672 switch (cond) { 673 case CANY: 674 printf("\"Else\" without matching \"if\"\n"); 675 return (1); 676 677 case CSEND: 678 cond = CRCV; 679 break; 680 681 case CRCV: 682 cond = CSEND; 683 break; 684 685 default: 686 printf("Mail's idea of conditions is screwed up\n"); 687 cond = CANY; 688 break; 689 } 690 return (0); 691 } 692 693 /* 694 * End of if statement. Just set cond back to anything. 695 */ 696 int 697 endifcmd() 698 { 699 700 if (cond == CANY) { 701 printf("\"Endif\" without matching \"if\"\n"); 702 return (1); 703 } 704 cond = CANY; 705 return (0); 706 } 707 708 /* 709 * Set the list of alternate names. 710 */ 711 int 712 alternates(namelist) 713 char **namelist; 714 { 715 int c; 716 char **ap, **ap2, *cp; 717 718 c = argcount(namelist) + 1; 719 if (c == 1) { 720 if (altnames == 0) 721 return (0); 722 for (ap = altnames; *ap != NULL; ap++) 723 printf("%s ", *ap); 724 printf("\n"); 725 return (0); 726 } 727 if (altnames != 0) 728 (void)free(altnames); 729 altnames = calloc((unsigned)c, sizeof(char *)); 730 for (ap = namelist, ap2 = altnames; *ap != NULL; ap++, ap2++) { 731 cp = calloc((unsigned)strlen(*ap) + 1, sizeof(char)); 732 strcpy(cp, *ap); 733 *ap2 = cp; 734 } 735 *ap2 = 0; 736 return (0); 737 } 738