usr/src/cmd/mailx/send.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 1985, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2016 by Delphix. All rights reserved.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  * University Copyright- Copyright (c) 1982, 1986, 1988
  32  * The Regents of the University of California
  33  * All Rights Reserved
  34  *
  35  * University Acknowledgment- Portions of this document are derived from
  36  * software developed by the University of California, Berkeley, and its
  37  * contributors.
  38  */
  39
  40 #include "rcv.h"
  41 #include <locale.h>
  42
  43 /*
  44  * mailx -- a modified version of a University of California at Berkeley
  45  *      mail program
  46  *
  47  * Mail to others.
  48  */
  49
  50 static void             fmt(register char *str, register FILE *fo);
  51 static FILE             *infix(struct header *hp, FILE *fi);
  52 static void             statusput(register struct message *mp, register FILE *obuf, int doign, int (*fp)(const char *, FILE *));
  53 static int              savemail(char name[], struct header *hp, FILE *fi);
  54 static int              sendmail(char *str);
  55 static int              Sendmail(char *str);
  56
  57 static off_t textpos;
  58
  59 /*
  60  * Send message described by the passed pointer to the
  61  * passed output buffer.  Return -1 on error, but normally
  62  * the number of lines written.  Adjust the status: field
  63  * if need be.  If doign is set, suppress ignored header fields.
  64  * Call (*fp)(line, obuf) to print the line.
  65  */
  66 long
  67 msend(
  68         struct message *mailp,
  69         FILE *obuf,
  70         int flag,
  71         int (*fp)(const char *, FILE *))
  72 {
  73         register struct message *mp;
  74         long clen, n, c;
  75         FILE *ibuf;
  76         char line[LINESIZE], field[BUFSIZ];
  77         int ishead, infld, fline, dostat, doclen, nread, unused;
  78         char *cp, *cp2;
  79         int doign = flag & M_IGNORE;
  80         int oldign = 0; /* previous line was ignored */
  81         long lc;
  82
  83         mp = mailp;
  84         if (mp->m_clen == 0)
  85                 setclen(mp);
  86         ibuf = setinput(mp);
  87         c = mp->m_size;
  88         ishead = 1;
  89         dostat = 1;
  90         doclen = 1;
  91         infld = 0;
  92         fline = 1;
  93         lc = 0;
  94         clearerr(obuf);
  95         while (c > 0L) {
  96                 nread = getaline(line, LINESIZE, ibuf, &unused);
  97                 c -= nread;
  98                 lc++;
  99                 if (ishead) {
 100                         /*
 101                          * First line is the From line, so no headers
 102                          * there to worry about
 103                          */
 104                         if (fline) {
 105                                 fline = 0;
 106                                 goto writeit;
 107                         }
 108                         /*
 109                          * If line is blank, we've reached end of
 110                          * headers, so force out status: field
 111                          * and note that we are no longer in header
 112                          * fields.  Also force out Content-Length: field.
 113                          */
 114                         if (line[0] == '\n') {
 115                                 if (dostat) {
 116                                         statusput(mailp, obuf, doign, fp);
 117                                         dostat = 0;
 118                                 }
 119                                 if (doclen &&
 120                                     !isign("content-length", flag&M_SAVING)) {
 121                                         snprintf(field, sizeof (field),
 122                                                 "Content-Length: %ld\n",
 123                                                 mp->m_clen - 1);
 124                                         (*fp)(field, obuf);
 125                                         if (ferror(obuf))
 126                                                 return(-1);
 127                                         doclen = 0;
 128                                 }
 129                                 ishead = 0;
 130                                 goto writeit;
 131                         }
 132                         /*
 133                          * If this line is a continuation
 134                          * of a previous header field, just echo it.
 135                          */
 136                         if (isspace(line[0]) && infld)
 137                                 if (oldign)
 138                                         continue;
 139                                 else
 140                                         goto writeit;
 141                         infld = 0;
 142                         /*
 143                          * If we are no longer looking at real
 144                          * header lines, force out status:
 145                          * This happens in uucp style mail where
 146                          * there are no headers at all.
 147                          */
 148                         if (!headerp(line)) {
 149                                 if (dostat) {
 150                                         statusput(mailp, obuf, doign, fp);
 151                                         dostat = 0;
 152                                 }
 153                                 (*fp)("\n", obuf);
 154                                 ishead = 0;
 155                                 goto writeit;
 156                         }
 157                         infld++;
 158                         /*
 159                          * Pick up the header field.
 160                          * If it is an ignored field and
 161                          * we care about such things, skip it.
 162                          */
 163                         cp = line;
 164                         cp2 = field;
 165                         while (*cp && *cp != ':' && !isspace(*cp))
 166                                 *cp2++ = *cp++;
 167                         *cp2 = 0;
 168                         oldign = doign && isign(field, flag&M_SAVING);
 169                         if (oldign)
 170                                 continue;
 171                         /*
 172                          * If the field is "status," go compute and print the
 173                          * real Status: field
 174                          */
 175                         if (icequal(field, "status")) {
 176                                 if (dostat) {
 177                                         statusput(mailp, obuf, doign, fp);
 178                                         dostat = 0;
 179                                 }
 180                                 continue;
 181                         }
 182                         if (icequal(field, "content-length")) {
 183                                 if (doclen) {
 184                                         snprintf(line, sizeof (line),
 185                                                 "Content-Length: %ld\n",
 186                                                 mp->m_clen - 1);
 187                                         (*fp)(line, obuf);
 188                                         if (ferror(obuf))
 189                                                 return(-1);
 190                                         doclen = 0;
 191                                 }
 192                                 continue;
 193                         }
 194                 }
 195 writeit:
 196                 if (!ishead && !mp->m_text && mp->m_clen != 0) {
 197                         if (line[0] == '\n')
 198                                 putc('\n', obuf);
 199                         clen = mp->m_clen-1;
 200                         for (;;) {
 201                                 n = clen < sizeof line ? clen : sizeof line;
 202                                 if ((n = fread(line, 1, (int)n, ibuf)) <= 0) {
 203                                         fprintf(stderr, gettext(
 204                                             "\t(Unexpected end-of-file).\n"));
 205                                         clen = 0;
 206                                 } else {
 207                                         if (fwrite(line, 1, (int)n, obuf) != n) {
 208                                                 fprintf(stderr, gettext(
 209                                         "\tError writing to the new file.\n"));
 210                                                 fflush(obuf);
 211                                                 if (fferror(obuf))
 212                                                         return (-1);
 213                                         }
 214                                 }
 215                                 clen -= n;
 216                                 if (clen <= 0) {
 217                                         break;
 218                                 }
 219                         }
 220                         c = 0L;
 221                 } else {
 222                         (*fp)(line, obuf);
 223                         if (ferror(obuf))
 224                                 return(-1);
 225                 }
 226         }
 227         fflush(obuf);
 228         if (ferror(obuf))
 229                 return(-1);
 230         if (ishead && (mailp->m_flag & MSTATUS))
 231                 printf(gettext("failed to fix up status field\n"));
 232         return(lc);
 233 }
 234
 235 /*
 236  * Test if the passed line is a header line, RFC 822 style.
 237  */
 238 int
 239 headerp(register char *line)
 240 {
 241         register char *cp = line;
 242
 243         while (*cp && *cp != ' ' && *cp != '\t' && *cp != ':')
 244                 cp++;
 245         return(*cp == ':');
 246 }
 247
 248 /*
 249  * Output a reasonable looking status field.
 250  * But if "status" is ignored and doign, forget it.
 251  */
 252 static void
 253 statusput(
 254         register struct message *mp,
 255         register FILE *obuf,
 256         int doign,
 257         int (*fp)(const char *, FILE *))
 258 {
 259         char statout[12];
 260
 261         if (doign && isign("status", 0))
 262                 return;
 263         if ((mp->m_flag & (MNEW|MREAD)) == MNEW)
 264                 return;
 265         strcpy(statout, "Status: ");
 266         if (mp->m_flag & MREAD)
 267                 strcat(statout, "R");
 268         if ((mp->m_flag & MNEW) == 0)
 269                 strcat(statout, "O");
 270         strcat(statout, "\n");
 271         (*fp)(statout, obuf);
 272 }
 273
 274 /*
 275  * Interface between the argument list and the mail1 routine
 276  * which does all the dirty work.
 277  */
 278
 279 int
 280 mail(char **people)
 281 {
 282         register char *cp2, *cp3;
 283         register int s;
 284         char *buf, **ap;
 285         struct header head;
 286
 287         for (s = 0, ap = people; *ap; ap++)
 288                 s += strlen(*ap) + 2;
 289         buf = (char *)salloc((unsigned)(s+1));
 290         cp2 = buf;
 291         for (ap = people; *ap; ap++) {
 292                 for (cp3 = *ap; *cp3; ) {
 293                         if (*cp3 == ' ' || *cp3 == '\t') {
 294                                 *cp3++ = ',';
 295                                 while (*cp3 == ' ' || *cp3 == '\t')
 296                                         cp3++;
 297                         } else
 298                                 cp3++;
 299                 }
 300                 cp2 = copy(*ap, cp2);
 301                 *cp2++ = ',';
 302                 *cp2++ = ' ';
 303         }
 304         *cp2 = '\0';
 305         head.h_to = buf;
 306         head.h_subject = head.h_cc = head.h_bcc = head.h_defopt = NOSTR;
 307         head.h_others = NOSTRPTR;
 308         head.h_seq = 0;
 309         mail1(&head, Fflag, NOSTR);
 310         return(0);
 311 }
 312
 313 int
 314 sendm(char *str)
 315 {
 316         if (value("flipm") != NOSTR)
 317                 return(Sendmail(str));
 318         else return(sendmail(str));
 319 }
 320
 321 int
 322 Sendm(char *str)
 323 {
 324         if (value("flipm") != NOSTR)
 325                 return(sendmail(str));
 326         else return(Sendmail(str));
 327 }
 328
 329 /*
 330  * Interface to the mail1 routine for the -t flag
 331  * (read headers from text).
 332  */
 333 int
 334 tmail(void)
 335 {
 336         struct header head;
 337
 338         head.h_to = NOSTR;
 339         head.h_subject = head.h_cc = head.h_bcc = head.h_defopt = NOSTR;
 340         head.h_others = NOSTRPTR;
 341         head.h_seq = 0;
 342         mail1(&head, Fflag, NOSTR);
 343         return(0);
 344 }
 345
 346 /*
 347  * Send mail to a bunch of user names.  The interface is through
 348  * the mail routine below.
 349  */
 350 static int
 351 sendmail(char *str)
 352 {
 353         struct header head;
 354
 355         if (blankline(str))
 356                 head.h_to = NOSTR;
 357         else
 358                 head.h_to = addto(NOSTR, str);
 359         head.h_subject = head.h_cc = head.h_bcc = head.h_defopt = NOSTR;
 360         head.h_others = NOSTRPTR;
 361         head.h_seq = 0;
 362         mail1(&head, 0, NOSTR);
 363         return(0);
 364 }
 365
 366 /*
 367  * Send mail to a bunch of user names.  The interface is through
 368  * the mail routine below.
 369  * save a copy of the letter
 370  */
 371 static int
 372 Sendmail(char *str)
 373 {
 374         struct header head;
 375
 376         if (blankline(str))
 377                 head.h_to = NOSTR;
 378         else
 379                 head.h_to = addto(NOSTR, str);
 380         head.h_subject = head.h_cc = head.h_bcc = head.h_defopt = NOSTR;
 381         head.h_others = NOSTRPTR;
 382         head.h_seq = 0;
 383         mail1(&head, 1, NOSTR);
 384         return(0);
 385 }
 386
 387 /*
 388  * Walk the list of fds, closing all but one.
 389  */
 390 static int
 391 closefd_walk(void *special_fd, int fd)
 392 {
 393         if (fd > STDERR_FILENO && fd != *(int *)special_fd)
 394                 (void) close(fd);
 395         return (0);
 396 }
 397
 398 /*
 399  * Mail a message on standard input to the people indicated
 400  * in the passed header.  (Internal interface).
 401  */
 402 void
 403 mail1(struct header *hp, int use_to, char *orig_to)
 404 {
 405         pid_t p, pid;
 406         int i, s, gotcha;
 407         char **namelist, *deliver;
 408         struct name *to, *np;
 409         FILE *mtf, *fp;
 410         int remote = rflag != NOSTR || rmail;
 411         char **t;
 412         char *deadletter;
 413         char recfile[PATHSIZE];
 414
 415         /*
 416          * Collect user's mail from standard input.
 417          * Get the result as mtf.
 418          */
 419
 420         pid = (pid_t)-1;
 421         if ((mtf = collect(hp)) == NULL)
 422                 return;
 423         hp->h_seq = 1;
 424         if (hp->h_subject == NOSTR)
 425                 hp->h_subject = sflag;
 426         if (fsize(mtf) == 0 && hp->h_subject == NOSTR) {
 427                 printf(gettext("No message !?!\n"));
 428                 goto out;
 429         }
 430         if (intty) {
 431                 printf(gettext("EOT\n"));
 432                 flush();
 433         }
 434
 435         /*
 436          * If we need to use the To: line to determine the record
 437          * file, save a copy of it before it's sorted below.
 438          */
 439
 440         if (use_to && orig_to == NOSTR && hp->h_to != NOSTR)
 441                 orig_to = strcpy((char *)salloc(strlen(hp->h_to)+1), hp->h_to);
 442         else if (orig_to == NOSTR)
 443                 orig_to = "";
 444
 445         /*
 446          * Now, take the user names from the combined
 447          * to and cc lists and do all the alias
 448          * processing.
 449          */
 450
 451         senderr = 0;
 452         to = cat(extract(hp->h_bcc, GBCC),
 453              cat(extract(hp->h_to, GTO),
 454              extract(hp->h_cc, GCC)));
 455         to = translate(outpre(elide(usermap(to))));
 456         if (!senderr)
 457                 mapf(to, myname);
 458         mechk(to);
 459         for (gotcha = 0, np = to; np != NIL; np = np->n_flink)
 460                 if ((np->n_type & GDEL) == 0)
 461                         gotcha++;
 462         hp->h_to = detract(to, GTO);
 463         hp->h_cc = detract(to, GCC);
 464         hp->h_bcc = detract(to, GBCC);
 465         if ((mtf = infix(hp, mtf)) == NULL) {
 466                 fprintf(stderr, gettext(". . . message lost, sorry.\n"));
 467                 return;
 468         }
 469         rewind(mtf);
 470         if (askme && isatty(0)) {
 471                 char ans[64];
 472                 puthead(hp, stdout, GTO|GCC|GBCC, 0);
 473                 printf(gettext("Send? "));
 474                 printf("[yes] ");
 475                 if (fgets(ans, sizeof(ans), stdin) && ans[0] &&
 476                                 (tolower(ans[0]) != 'y' && ans[0] != '\n'))
 477                         goto dead;
 478         }
 479         if (senderr)
 480                 goto dead;
 481         /*
 482          * Look through the recipient list for names with /'s
 483          * in them which we write to as files directly.
 484          */
 485         i = outof(to, mtf);
 486         rewind(mtf);
 487         if (!gotcha && !i) {
 488                 printf(gettext("No recipients specified\n"));
 489                 goto dead;
 490         }
 491         if (senderr)
 492                 goto dead;
 493
 494         getrecf(orig_to, recfile, use_to, sizeof (recfile));
 495         if (recfile != NOSTR && *recfile)
 496                 savemail(safeexpand(recfile), hp, mtf);
 497         if (!gotcha)
 498                 goto out;
 499         namelist = unpack(to);
 500         if (debug) {
 501                 fprintf(stderr, "Recipients of message:\n");
 502                 for (t = namelist; *t != NOSTR; t++)
 503                         fprintf(stderr, " \"%s\"", *t);
 504                 fprintf(stderr, "\n");
 505                 return;
 506         }
 507
 508         /*
 509          * Wait, to absorb a potential zombie, then
 510          * fork, set up the temporary mail file as standard
 511          * input for "mail" and exec with the user list we generated
 512          * far above. Return the process id to caller in case it
 513          * wants to await the completion of mail.
 514          */
 515
 516 #ifdef VMUNIX
 517         while (wait3(NULL, WNOHANG, NULL) > 0)
 518                 ;
 519 #else
 520 #ifdef preSVr4
 521         wait((int *)0);
 522 #else
 523         while (waitpid((pid_t)-1, (int *)0, WNOHANG) > 0)
 524                 ;
 525 #endif
 526 #endif
 527         rewind(mtf);
 528         pid = fork();
 529         if (pid == (pid_t)-1) {
 530                 perror("fork");
 531 dead:
 532                 deadletter = Getf("DEAD");
 533                 if (fp = fopen(deadletter,
 534                     value("appenddeadletter") == NOSTR ? "w" : "a")) {
 535                         chmod(deadletter, DEADPERM);
 536                         puthead(hp, fp, GMASK|GCLEN, fsize(mtf) - textpos);
 537                         fseek(mtf, textpos, 0);
 538                         lcwrite(deadletter, mtf, fp,
 539                             value("appenddeadletter") != NOSTR);
 540                         fclose(fp);
 541                 } else
 542                         perror(deadletter);
 543                 goto out;
 544         }
 545         if (pid == 0) {
 546                 sigchild();
 547 #ifdef SIGTSTP
 548                 if (remote == 0) {
 549                         sigset(SIGTSTP, SIG_IGN);
 550                         sigset(SIGTTIN, SIG_IGN);
 551                         sigset(SIGTTOU, SIG_IGN);
 552                 }
 553 #endif
 554                 sigset(SIGHUP, SIG_IGN);
 555                 sigset(SIGINT, SIG_IGN);
 556                 sigset(SIGQUIT, SIG_IGN);
 557                 s = fileno(mtf);
 558                 (void) fdwalk(closefd_walk, &s);
 559                 close(0);
 560                 dup(s);
 561                 close(s);
 562 #ifdef CC
 563                 submit(getpid());
 564 #endif /* CC */
 565                 if ((deliver = value("sendmail")) == NOSTR)
 566 #ifdef SENDMAIL
 567                         deliver = SENDMAIL;
 568 #else
 569                         deliver = MAIL;
 570 #endif
 571                 execvp(safeexpand(deliver), namelist);
 572                 perror(deliver);
 573                 exit(1);
 574         }
 575
 576         if (value("sendwait")!=NOSTR)
 577                 remote++;
 578 out:
 579         if (remote) {
 580                 while ((p = wait(&s)) != pid && p != (pid_t)-1)
 581                         ;
 582                 if (s != 0)
 583                         senderr++;
 584                 pid = 0;
 585         }
 586         fclose(mtf);
 587         return;
 588 }
 589
 590 /*
 591  * Prepend a header in front of the collected stuff
 592  * and return the new file.
 593  */
 594
 595 static FILE *
 596 infix(struct header *hp, FILE *fi)
 597 {
 598         register FILE *nfo, *nfi;
 599         register int c;
 600         char *postmark, *returnaddr;
 601         int fd = -1;
 602
 603         rewind(fi);
 604         if ((fd = open(tempMail, O_RDWR|O_CREAT|O_EXCL, 0600)) < 0 ||
 605         (nfo = fdopen(fd, "w")) == NULL) {
 606                 perror(tempMail);
 607                 return(fi);
 608         }
 609         if ((nfi = fopen(tempMail, "r")) == NULL) {
 610                 perror(tempMail);
 611                 fclose(nfo);
 612                 return(fi);
 613         }
 614         removefile(tempMail);
 615         postmark = value("postmark");
 616         returnaddr = value("returnaddr");
 617         if ((postmark != NOSTR) || (returnaddr != NOSTR)) {
 618                 if (returnaddr && *returnaddr)
 619                         fprintf(nfo, "From: %s", returnaddr);
 620                 else
 621                         fprintf(nfo, "From: %s@%s", myname, host);
 622                 if (postmark && *postmark)
 623                         fprintf(nfo, " (%s)", postmark);
 624                 putc('\n', nfo);
 625         }
 626         puthead(hp, nfo, (GMASK & ~GBCC) | GCLEN, fsize(fi));
 627         textpos = ftell(nfo);
 628         while ((c = getc(fi)) != EOF)
 629                 putc(c, nfo);
 630         if (ferror(fi)) {
 631                 perror("read");
 632                 return(fi);
 633         }
 634         fflush(nfo);
 635         if (fferror(nfo)) {
 636                 perror(tempMail);
 637                 fclose(nfo);
 638                 fclose(nfi);
 639                 return(fi);
 640         }
 641         fclose(nfo);
 642         fclose(fi);
 643         rewind(nfi);
 644         return(nfi);
 645 }
 646
 647 /*
 648  * Dump the message header on the
 649  * passed file buffer.
 650  */
 651
 652 int
 653 puthead(struct header *hp, FILE *fo, int w, long clen)
 654 {
 655         register int gotcha;
 656
 657         gotcha = 0;
 658         if (hp->h_to != NOSTR && (w & GTO))
 659                 fprintf(fo, "To: "), fmt(hp->h_to, fo), gotcha++;
 660         if ((w & GSUBJECT) && (int)value("bsdcompat"))
 661                 if (hp->h_subject != NOSTR && *hp->h_subject)
 662                         fprintf(fo, "Subject: %s\n", hp->h_subject), gotcha++;
 663                 else
 664                         if (sflag && *sflag)
 665                                 fprintf(fo, "Subject: %s\n", sflag), gotcha++;
 666         if (hp->h_cc != NOSTR && (w & GCC))
 667                 fprintf(fo, "Cc: "), fmt(hp->h_cc, fo), gotcha++;
 668         if (hp->h_bcc != NOSTR && (w & GBCC))
 669                 fprintf(fo, "Bcc: "), fmt(hp->h_bcc, fo), gotcha++;
 670         if (hp->h_defopt != NOSTR && (w & GDEFOPT))
 671                 if (receipt_flg)
 672                         fprintf(fo, "Return-Receipt-To: %s\n",
 673                                 hp->h_defopt), gotcha++;
 674                 else
 675                 fprintf(fo, "Default-Options: %s\n", hp->h_defopt), gotcha++;
 676         if ((w & GSUBJECT) && !(int)value("bsdcompat"))
 677                 if (hp->h_subject != NOSTR && *hp->h_subject)
 678                         fprintf(fo, "Subject: %s\n", hp->h_subject), gotcha++;
 679                 else
 680                         if (sflag && *sflag)
 681                                 fprintf(fo, "Subject: %s\n", sflag), gotcha++;
 682         if (hp->h_others != NOSTRPTR && (w & GOTHER)) {
 683                 char **p;
 684                 for (p = hp->h_others; *p; p++)
 685                         fprintf(fo, "%s\n", *p);
 686                 gotcha++;
 687         }
 688 #ifndef preSVr4
 689         if (w & GCLEN)
 690                 fprintf(fo, "Content-Length: %ld\n", clen), gotcha++;
 691 #endif
 692         if (gotcha && (w & GNL))
 693                 putc('\n', fo);
 694         return(0);
 695 }
 696
 697 /*
 698  * Format the given text to not exceed 78 characters.
 699  */
 700 static void
 701 fmt(register char *str, register FILE *fo)
 702 {
 703         register int col = 4;
 704         char name[256];
 705         int len;
 706
 707         str = strcpy((char *)salloc(strlen(str)+1), str);
 708         while (str = yankword(str, name, sizeof (name), 1)) {
 709                 len = strlen(name);
 710                 if (col > 4) {
 711                         if (col + len > 76) {
 712                                 fputs(",\n    ", fo);
 713                                 col = 4;
 714                         } else {
 715                                 fputs(", ", fo);
 716                                 col += 2;
 717                         }
 718                 }
 719                 fputs(name, fo);
 720                 col += len;
 721         }
 722         putc('\n', fo);
 723 }
 724
 725 /*
 726  * Save the outgoing mail on the passed file.
 727  */
 728 static int
 729 savemail(char name[], struct header *hp, FILE *fi)
 730 {
 731         register FILE *fo;
 732         time_t now;
 733         char *n;
 734 #ifdef preSVr4
 735         char line[BUFSIZ];
 736 #else
 737         int c;
 738 #endif
 739
 740         if (debug)
 741                 fprintf(stderr, gettext("save in '%s'\n"), name);
 742         if ((fo = fopen(name, "a")) == NULL) {
 743                 perror(name);
 744                 return(-1);
 745         }
 746         time(&now);
 747         n = rflag;
 748         if (n == NOSTR)
 749                 n = myname;
 750         fprintf(fo, "From %s %s", n, ctime(&now));
 751         puthead(hp, fo, GMASK|GCLEN, fsize(fi) - textpos);
 752         fseek(fi, textpos, 0);
 753 #ifdef preSVr4
 754         while (fgets(line, sizeof line, fi)) {
 755                 if (!strncmp(line, "From ", 5))
 756                         putc('>', fo);
 757                 fputs(line, fo);
 758         }
 759 #else
 760         while ((c = getc(fi)) != EOF)
 761                 putc(c, fo);
 762 #endif
 763         putc('\n', fo);
 764         fflush(fo);
 765         if (fferror(fo))
 766                 perror(name);
 767         fclose(fo);
 768         return(0);
 769 }