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