Home | History | Annotate | Line # | Download | only in mail
send.c revision 1.7
      1  1.7     lukem /*	$NetBSD: send.c,v 1.7 1997/10/19 05:03:52 lukem Exp $	*/
      2  1.6  christos 
      3  1.1       cgd /*
      4  1.4   deraadt  * Copyright (c) 1980, 1993
      5  1.4   deraadt  *	The Regents of the University of California.  All rights reserved.
      6  1.1       cgd  *
      7  1.1       cgd  * Redistribution and use in source and binary forms, with or without
      8  1.1       cgd  * modification, are permitted provided that the following conditions
      9  1.1       cgd  * are met:
     10  1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     11  1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     12  1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     13  1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     14  1.1       cgd  *    documentation and/or other materials provided with the distribution.
     15  1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     16  1.1       cgd  *    must display the following acknowledgement:
     17  1.1       cgd  *	This product includes software developed by the University of
     18  1.1       cgd  *	California, Berkeley and its contributors.
     19  1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     20  1.1       cgd  *    may be used to endorse or promote products derived from this software
     21  1.1       cgd  *    without specific prior written permission.
     22  1.1       cgd  *
     23  1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  1.1       cgd  * SUCH DAMAGE.
     34  1.1       cgd  */
     35  1.1       cgd 
     36  1.7     lukem #include <sys/cdefs.h>
     37  1.1       cgd #ifndef lint
     38  1.6  christos #if 0
     39  1.6  christos static char sccsid[] = "@(#)send.c	8.1 (Berkeley) 6/6/93";
     40  1.6  christos #else
     41  1.7     lukem __RCSID("$NetBSD: send.c,v 1.7 1997/10/19 05:03:52 lukem Exp $");
     42  1.6  christos #endif
     43  1.1       cgd #endif /* not lint */
     44  1.1       cgd 
     45  1.1       cgd #include "rcv.h"
     46  1.4   deraadt #include "extern.h"
     47  1.1       cgd 
     48  1.1       cgd /*
     49  1.1       cgd  * Mail -- a mail program
     50  1.1       cgd  *
     51  1.1       cgd  * Mail to others.
     52  1.1       cgd  */
     53  1.1       cgd 
     54  1.1       cgd /*
     55  1.1       cgd  * Send message described by the passed pointer to the
     56  1.1       cgd  * passed output buffer.  Return -1 on error.
     57  1.1       cgd  * Adjust the status: field if need be.
     58  1.1       cgd  * If doign is given, suppress ignored header fields.
     59  1.1       cgd  * prefix is a string to prepend to each output line.
     60  1.1       cgd  */
     61  1.4   deraadt int
     62  1.1       cgd send(mp, obuf, doign, prefix)
     63  1.7     lukem 	struct message *mp;
     64  1.1       cgd 	FILE *obuf;
     65  1.1       cgd 	struct ignoretab *doign;
     66  1.1       cgd 	char *prefix;
     67  1.1       cgd {
     68  1.1       cgd 	long count;
     69  1.7     lukem 	FILE *ibuf;
     70  1.1       cgd 	char line[LINESIZE];
     71  1.6  christos 	int ishead, infld, ignoring = 0, dostat, firstline;
     72  1.7     lukem 	char *cp, *cp2;
     73  1.7     lukem 	int c = 0;
     74  1.1       cgd 	int length;
     75  1.6  christos 	int prefixlen = 0;
     76  1.1       cgd 
     77  1.1       cgd 	/*
     78  1.1       cgd 	 * Compute the prefix string, without trailing whitespace
     79  1.1       cgd 	 */
     80  1.1       cgd 	if (prefix != NOSTR) {
     81  1.1       cgd 		cp2 = 0;
     82  1.1       cgd 		for (cp = prefix; *cp; cp++)
     83  1.1       cgd 			if (*cp != ' ' && *cp != '\t')
     84  1.1       cgd 				cp2 = cp;
     85  1.1       cgd 		prefixlen = cp2 == 0 ? 0 : cp2 - prefix + 1;
     86  1.1       cgd 	}
     87  1.1       cgd 	ibuf = setinput(mp);
     88  1.1       cgd 	count = mp->m_size;
     89  1.1       cgd 	ishead = 1;
     90  1.1       cgd 	dostat = doign == 0 || !isign("status", doign);
     91  1.1       cgd 	infld = 0;
     92  1.1       cgd 	firstline = 1;
     93  1.1       cgd 	/*
     94  1.1       cgd 	 * Process headers first
     95  1.1       cgd 	 */
     96  1.1       cgd 	while (count > 0 && ishead) {
     97  1.1       cgd 		if (fgets(line, LINESIZE, ibuf) == NULL)
     98  1.1       cgd 			break;
     99  1.1       cgd 		count -= length = strlen(line);
    100  1.1       cgd 		if (firstline) {
    101  1.1       cgd 			/*
    102  1.1       cgd 			 * First line is the From line, so no headers
    103  1.1       cgd 			 * there to worry about
    104  1.1       cgd 			 */
    105  1.1       cgd 			firstline = 0;
    106  1.1       cgd 			ignoring = doign == ignoreall;
    107  1.1       cgd 		} else if (line[0] == '\n') {
    108  1.1       cgd 			/*
    109  1.1       cgd 			 * If line is blank, we've reached end of
    110  1.1       cgd 			 * headers, so force out status: field
    111  1.1       cgd 			 * and note that we are no longer in header
    112  1.1       cgd 			 * fields
    113  1.1       cgd 			 */
    114  1.1       cgd 			if (dostat) {
    115  1.1       cgd 				statusput(mp, obuf, prefix);
    116  1.1       cgd 				dostat = 0;
    117  1.1       cgd 			}
    118  1.1       cgd 			ishead = 0;
    119  1.1       cgd 			ignoring = doign == ignoreall;
    120  1.1       cgd 		} else if (infld && (line[0] == ' ' || line[0] == '\t')) {
    121  1.1       cgd 			/*
    122  1.1       cgd 			 * If this line is a continuation (via space or tab)
    123  1.1       cgd 			 * of a previous header field, just echo it
    124  1.1       cgd 			 * (unless the field should be ignored).
    125  1.1       cgd 			 * In other words, nothing to do.
    126  1.1       cgd 			 */
    127  1.1       cgd 		} else {
    128  1.1       cgd 			/*
    129  1.1       cgd 			 * Pick up the header field if we have one.
    130  1.1       cgd 			 */
    131  1.1       cgd 			for (cp = line; (c = *cp++) && c != ':' && !isspace(c);)
    132  1.1       cgd 				;
    133  1.1       cgd 			cp2 = --cp;
    134  1.1       cgd 			while (isspace(*cp++))
    135  1.1       cgd 				;
    136  1.1       cgd 			if (cp[-1] != ':') {
    137  1.1       cgd 				/*
    138  1.1       cgd 				 * Not a header line, force out status:
    139  1.1       cgd 				 * This happens in uucp style mail where
    140  1.1       cgd 				 * there are no headers at all.
    141  1.1       cgd 				 */
    142  1.1       cgd 				if (dostat) {
    143  1.1       cgd 					statusput(mp, obuf, prefix);
    144  1.1       cgd 					dostat = 0;
    145  1.1       cgd 				}
    146  1.1       cgd 				if (doign != ignoreall)
    147  1.1       cgd 					/* add blank line */
    148  1.1       cgd 					(void) putc('\n', obuf);
    149  1.1       cgd 				ishead = 0;
    150  1.1       cgd 				ignoring = 0;
    151  1.1       cgd 			} else {
    152  1.1       cgd 				/*
    153  1.1       cgd 				 * If it is an ignored field and
    154  1.1       cgd 				 * we care about such things, skip it.
    155  1.1       cgd 				 */
    156  1.1       cgd 				*cp2 = 0;	/* temporarily null terminate */
    157  1.1       cgd 				if (doign && isign(line, doign))
    158  1.1       cgd 					ignoring = 1;
    159  1.1       cgd 				else if ((line[0] == 's' || line[0] == 'S') &&
    160  1.1       cgd 					 strcasecmp(line, "status") == 0) {
    161  1.1       cgd 					/*
    162  1.1       cgd 					 * If the field is "status," go compute
    163  1.1       cgd 					 * and print the real Status: field
    164  1.1       cgd 					 */
    165  1.1       cgd 					if (dostat) {
    166  1.1       cgd 						statusput(mp, obuf, prefix);
    167  1.1       cgd 						dostat = 0;
    168  1.1       cgd 					}
    169  1.1       cgd 					ignoring = 1;
    170  1.1       cgd 				} else {
    171  1.1       cgd 					ignoring = 0;
    172  1.1       cgd 					*cp2 = c;	/* restore */
    173  1.1       cgd 				}
    174  1.1       cgd 				infld = 1;
    175  1.1       cgd 			}
    176  1.1       cgd 		}
    177  1.1       cgd 		if (!ignoring) {
    178  1.1       cgd 			/*
    179  1.1       cgd 			 * Strip trailing whitespace from prefix
    180  1.1       cgd 			 * if line is blank.
    181  1.1       cgd 			 */
    182  1.1       cgd 			if (prefix != NOSTR)
    183  1.1       cgd 				if (length > 1)
    184  1.1       cgd 					fputs(prefix, obuf);
    185  1.1       cgd 				else
    186  1.1       cgd 					(void) fwrite(prefix, sizeof *prefix,
    187  1.1       cgd 							prefixlen, obuf);
    188  1.1       cgd 			(void) fwrite(line, sizeof *line, length, obuf);
    189  1.1       cgd 			if (ferror(obuf))
    190  1.1       cgd 				return -1;
    191  1.1       cgd 		}
    192  1.1       cgd 	}
    193  1.1       cgd 	/*
    194  1.1       cgd 	 * Copy out message body
    195  1.1       cgd 	 */
    196  1.1       cgd 	if (doign == ignoreall)
    197  1.1       cgd 		count--;		/* skip final blank line */
    198  1.1       cgd 	if (prefix != NOSTR)
    199  1.1       cgd 		while (count > 0) {
    200  1.1       cgd 			if (fgets(line, LINESIZE, ibuf) == NULL) {
    201  1.1       cgd 				c = 0;
    202  1.1       cgd 				break;
    203  1.1       cgd 			}
    204  1.1       cgd 			count -= c = strlen(line);
    205  1.1       cgd 			/*
    206  1.1       cgd 			 * Strip trailing whitespace from prefix
    207  1.1       cgd 			 * if line is blank.
    208  1.1       cgd 			 */
    209  1.1       cgd 			if (c > 1)
    210  1.1       cgd 				fputs(prefix, obuf);
    211  1.1       cgd 			else
    212  1.1       cgd 				(void) fwrite(prefix, sizeof *prefix,
    213  1.1       cgd 						prefixlen, obuf);
    214  1.1       cgd 			(void) fwrite(line, sizeof *line, c, obuf);
    215  1.1       cgd 			if (ferror(obuf))
    216  1.1       cgd 				return -1;
    217  1.1       cgd 		}
    218  1.1       cgd 	else
    219  1.1       cgd 		while (count > 0) {
    220  1.1       cgd 			c = count < LINESIZE ? count : LINESIZE;
    221  1.1       cgd 			if ((c = fread(line, sizeof *line, c, ibuf)) <= 0)
    222  1.1       cgd 				break;
    223  1.1       cgd 			count -= c;
    224  1.1       cgd 			if (fwrite(line, sizeof *line, c, obuf) != c)
    225  1.1       cgd 				return -1;
    226  1.1       cgd 		}
    227  1.1       cgd 	if (doign == ignoreall && c > 0 && line[c - 1] != '\n')
    228  1.1       cgd 		/* no final blank line */
    229  1.1       cgd 		if ((c = getc(ibuf)) != EOF && putc(c, obuf) == EOF)
    230  1.1       cgd 			return -1;
    231  1.1       cgd 	return 0;
    232  1.1       cgd }
    233  1.1       cgd 
    234  1.1       cgd /*
    235  1.1       cgd  * Output a reasonable looking status field.
    236  1.1       cgd  */
    237  1.4   deraadt void
    238  1.1       cgd statusput(mp, obuf, prefix)
    239  1.7     lukem 	struct message *mp;
    240  1.1       cgd 	FILE *obuf;
    241  1.1       cgd 	char *prefix;
    242  1.1       cgd {
    243  1.1       cgd 	char statout[3];
    244  1.7     lukem 	char *cp = statout;
    245  1.1       cgd 
    246  1.1       cgd 	if (mp->m_flag & MREAD)
    247  1.1       cgd 		*cp++ = 'R';
    248  1.1       cgd 	if ((mp->m_flag & MNEW) == 0)
    249  1.1       cgd 		*cp++ = 'O';
    250  1.1       cgd 	*cp = 0;
    251  1.1       cgd 	if (statout[0])
    252  1.1       cgd 		fprintf(obuf, "%sStatus: %s\n",
    253  1.1       cgd 			prefix == NOSTR ? "" : prefix, statout);
    254  1.1       cgd }
    255  1.1       cgd 
    256  1.1       cgd /*
    257  1.1       cgd  * Interface between the argument list and the mail1 routine
    258  1.1       cgd  * which does all the dirty work.
    259  1.1       cgd  */
    260  1.4   deraadt int
    261  1.1       cgd mail(to, cc, bcc, smopts, subject)
    262  1.1       cgd 	struct name *to, *cc, *bcc, *smopts;
    263  1.1       cgd 	char *subject;
    264  1.1       cgd {
    265  1.1       cgd 	struct header head;
    266  1.1       cgd 
    267  1.1       cgd 	head.h_to = to;
    268  1.1       cgd 	head.h_subject = subject;
    269  1.1       cgd 	head.h_cc = cc;
    270  1.1       cgd 	head.h_bcc = bcc;
    271  1.1       cgd 	head.h_smopts = smopts;
    272  1.1       cgd 	mail1(&head, 0);
    273  1.1       cgd 	return(0);
    274  1.1       cgd }
    275  1.1       cgd 
    276  1.1       cgd 
    277  1.1       cgd /*
    278  1.1       cgd  * Send mail to a bunch of user names.  The interface is through
    279  1.1       cgd  * the mail routine below.
    280  1.1       cgd  */
    281  1.4   deraadt int
    282  1.6  christos sendmail(v)
    283  1.6  christos 	void *v;
    284  1.1       cgd {
    285  1.6  christos 	char *str = v;
    286  1.1       cgd 	struct header head;
    287  1.1       cgd 
    288  1.1       cgd 	head.h_to = extract(str, GTO);
    289  1.1       cgd 	head.h_subject = NOSTR;
    290  1.1       cgd 	head.h_cc = NIL;
    291  1.1       cgd 	head.h_bcc = NIL;
    292  1.1       cgd 	head.h_smopts = NIL;
    293  1.1       cgd 	mail1(&head, 0);
    294  1.1       cgd 	return(0);
    295  1.1       cgd }
    296  1.1       cgd 
    297  1.1       cgd /*
    298  1.1       cgd  * Mail a message on standard input to the people indicated
    299  1.1       cgd  * in the passed header.  (Internal interface).
    300  1.1       cgd  */
    301  1.4   deraadt void
    302  1.1       cgd mail1(hp, printheaders)
    303  1.1       cgd 	struct header *hp;
    304  1.4   deraadt 	int printheaders;
    305  1.1       cgd {
    306  1.1       cgd 	char *cp;
    307  1.1       cgd 	int pid;
    308  1.1       cgd 	char **namelist;
    309  1.1       cgd 	struct name *to;
    310  1.1       cgd 	FILE *mtf;
    311  1.1       cgd 
    312  1.1       cgd 	/*
    313  1.1       cgd 	 * Collect user's mail from standard input.
    314  1.1       cgd 	 * Get the result as mtf.
    315  1.1       cgd 	 */
    316  1.1       cgd 	if ((mtf = collect(hp, printheaders)) == NULL)
    317  1.1       cgd 		return;
    318  1.1       cgd 	if (value("interactive") != NOSTR)
    319  1.3       jtc 		if (value("askcc") != NOSTR || value("askbcc") != NOSTR) {
    320  1.3       jtc 			if (value("askcc") != NOSTR)
    321  1.3       jtc 				grabh(hp, GCC);
    322  1.3       jtc 			if (value("askbcc") != NOSTR)
    323  1.3       jtc 				grabh(hp, GBCC);
    324  1.3       jtc 		} else {
    325  1.1       cgd 			printf("EOT\n");
    326  1.1       cgd 			(void) fflush(stdout);
    327  1.1       cgd 		}
    328  1.1       cgd 	if (fsize(mtf) == 0)
    329  1.1       cgd 		if (hp->h_subject == NOSTR)
    330  1.1       cgd 			printf("No message, no subject; hope that's ok\n");
    331  1.1       cgd 		else
    332  1.1       cgd 			printf("Null message body; hope that's ok\n");
    333  1.1       cgd 	/*
    334  1.1       cgd 	 * Now, take the user names from the combined
    335  1.1       cgd 	 * to and cc lists and do all the alias
    336  1.1       cgd 	 * processing.
    337  1.1       cgd 	 */
    338  1.1       cgd 	senderr = 0;
    339  1.1       cgd 	to = usermap(cat(hp->h_bcc, cat(hp->h_to, hp->h_cc)));
    340  1.1       cgd 	if (to == NIL) {
    341  1.1       cgd 		printf("No recipients specified\n");
    342  1.1       cgd 		senderr++;
    343  1.1       cgd 	}
    344  1.1       cgd 	/*
    345  1.1       cgd 	 * Look through the recipient list for names with /'s
    346  1.1       cgd 	 * in them which we write to as files directly.
    347  1.1       cgd 	 */
    348  1.1       cgd 	to = outof(to, mtf, hp);
    349  1.1       cgd 	if (senderr)
    350  1.1       cgd 		savedeadletter(mtf);
    351  1.1       cgd 	to = elide(to);
    352  1.1       cgd 	if (count(to) == 0)
    353  1.1       cgd 		goto out;
    354  1.1       cgd 	fixhead(hp, to);
    355  1.1       cgd 	if ((mtf = infix(hp, mtf)) == NULL) {
    356  1.1       cgd 		fprintf(stderr, ". . . message lost, sorry.\n");
    357  1.1       cgd 		return;
    358  1.1       cgd 	}
    359  1.1       cgd 	namelist = unpack(cat(hp->h_smopts, to));
    360  1.1       cgd 	if (debug) {
    361  1.1       cgd 		char **t;
    362  1.1       cgd 
    363  1.1       cgd 		printf("Sendmail arguments:");
    364  1.1       cgd 		for (t = namelist; *t != NOSTR; t++)
    365  1.1       cgd 			printf(" \"%s\"", *t);
    366  1.1       cgd 		printf("\n");
    367  1.1       cgd 		goto out;
    368  1.1       cgd 	}
    369  1.1       cgd 	if ((cp = value("record")) != NOSTR)
    370  1.1       cgd 		(void) savemail(expand(cp), mtf);
    371  1.1       cgd 	/*
    372  1.1       cgd 	 * Fork, set up the temporary mail file as standard
    373  1.1       cgd 	 * input for "mail", and exec with the user list we generated
    374  1.1       cgd 	 * far above.
    375  1.1       cgd 	 */
    376  1.1       cgd 	pid = fork();
    377  1.1       cgd 	if (pid == -1) {
    378  1.1       cgd 		perror("fork");
    379  1.1       cgd 		savedeadletter(mtf);
    380  1.1       cgd 		goto out;
    381  1.1       cgd 	}
    382  1.1       cgd 	if (pid == 0) {
    383  1.6  christos 		sigset_t nset;
    384  1.6  christos 		sigemptyset(&nset);
    385  1.6  christos 		sigaddset(&nset, SIGHUP);
    386  1.6  christos 		sigaddset(&nset, SIGINT);
    387  1.6  christos 		sigaddset(&nset, SIGQUIT);
    388  1.6  christos 		sigaddset(&nset, SIGTSTP);
    389  1.6  christos 		sigaddset(&nset, SIGTTIN);
    390  1.6  christos 		sigaddset(&nset, SIGTTOU);
    391  1.6  christos 		prepare_child(&nset, fileno(mtf), -1);
    392  1.1       cgd 		if ((cp = value("sendmail")) != NOSTR)
    393  1.1       cgd 			cp = expand(cp);
    394  1.1       cgd 		else
    395  1.1       cgd 			cp = _PATH_SENDMAIL;
    396  1.1       cgd 		execv(cp, namelist);
    397  1.1       cgd 		perror(cp);
    398  1.1       cgd 		_exit(1);
    399  1.1       cgd 	}
    400  1.1       cgd 	if (value("verbose") != NOSTR)
    401  1.1       cgd 		(void) wait_child(pid);
    402  1.1       cgd 	else
    403  1.1       cgd 		free_child(pid);
    404  1.1       cgd out:
    405  1.1       cgd 	(void) Fclose(mtf);
    406  1.1       cgd }
    407  1.1       cgd 
    408  1.1       cgd /*
    409  1.1       cgd  * Fix the header by glopping all of the expanded names from
    410  1.1       cgd  * the distribution list into the appropriate fields.
    411  1.1       cgd  */
    412  1.4   deraadt void
    413  1.1       cgd fixhead(hp, tolist)
    414  1.1       cgd 	struct header *hp;
    415  1.1       cgd 	struct name *tolist;
    416  1.1       cgd {
    417  1.7     lukem 	struct name *np;
    418  1.1       cgd 
    419  1.1       cgd 	hp->h_to = NIL;
    420  1.1       cgd 	hp->h_cc = NIL;
    421  1.1       cgd 	hp->h_bcc = NIL;
    422  1.1       cgd 	for (np = tolist; np != NIL; np = np->n_flink)
    423  1.1       cgd 		if ((np->n_type & GMASK) == GTO)
    424  1.1       cgd 			hp->h_to =
    425  1.1       cgd 				cat(hp->h_to, nalloc(np->n_name, np->n_type));
    426  1.1       cgd 		else if ((np->n_type & GMASK) == GCC)
    427  1.1       cgd 			hp->h_cc =
    428  1.1       cgd 				cat(hp->h_cc, nalloc(np->n_name, np->n_type));
    429  1.1       cgd 		else if ((np->n_type & GMASK) == GBCC)
    430  1.1       cgd 			hp->h_bcc =
    431  1.1       cgd 				cat(hp->h_bcc, nalloc(np->n_name, np->n_type));
    432  1.1       cgd }
    433  1.1       cgd 
    434  1.1       cgd /*
    435  1.1       cgd  * Prepend a header in front of the collected stuff
    436  1.1       cgd  * and return the new file.
    437  1.1       cgd  */
    438  1.1       cgd FILE *
    439  1.1       cgd infix(hp, fi)
    440  1.1       cgd 	struct header *hp;
    441  1.1       cgd 	FILE *fi;
    442  1.1       cgd {
    443  1.5       jtc 	extern char *tempMail;
    444  1.7     lukem 	FILE *nfo, *nfi;
    445  1.7     lukem 	int c;
    446  1.1       cgd 
    447  1.1       cgd 	if ((nfo = Fopen(tempMail, "w")) == NULL) {
    448  1.1       cgd 		perror(tempMail);
    449  1.1       cgd 		return(fi);
    450  1.1       cgd 	}
    451  1.1       cgd 	if ((nfi = Fopen(tempMail, "r")) == NULL) {
    452  1.1       cgd 		perror(tempMail);
    453  1.1       cgd 		(void) Fclose(nfo);
    454  1.1       cgd 		return(fi);
    455  1.1       cgd 	}
    456  1.1       cgd 	(void) rm(tempMail);
    457  1.1       cgd 	(void) puthead(hp, nfo, GTO|GSUBJECT|GCC|GBCC|GNL|GCOMMA);
    458  1.1       cgd 	c = getc(fi);
    459  1.1       cgd 	while (c != EOF) {
    460  1.1       cgd 		(void) putc(c, nfo);
    461  1.1       cgd 		c = getc(fi);
    462  1.1       cgd 	}
    463  1.1       cgd 	if (ferror(fi)) {
    464  1.1       cgd 		perror("read");
    465  1.1       cgd 		rewind(fi);
    466  1.1       cgd 		return(fi);
    467  1.1       cgd 	}
    468  1.1       cgd 	(void) fflush(nfo);
    469  1.1       cgd 	if (ferror(nfo)) {
    470  1.1       cgd 		perror(tempMail);
    471  1.1       cgd 		(void) Fclose(nfo);
    472  1.1       cgd 		(void) Fclose(nfi);
    473  1.1       cgd 		rewind(fi);
    474  1.1       cgd 		return(fi);
    475  1.1       cgd 	}
    476  1.1       cgd 	(void) Fclose(nfo);
    477  1.1       cgd 	(void) Fclose(fi);
    478  1.1       cgd 	rewind(nfi);
    479  1.1       cgd 	return(nfi);
    480  1.1       cgd }
    481  1.1       cgd 
    482  1.1       cgd /*
    483  1.1       cgd  * Dump the to, subject, cc header on the
    484  1.1       cgd  * passed file buffer.
    485  1.1       cgd  */
    486  1.4   deraadt int
    487  1.1       cgd puthead(hp, fo, w)
    488  1.1       cgd 	struct header *hp;
    489  1.1       cgd 	FILE *fo;
    490  1.4   deraadt 	int w;
    491  1.1       cgd {
    492  1.7     lukem 	int gotcha;
    493  1.1       cgd 
    494  1.1       cgd 	gotcha = 0;
    495  1.1       cgd 	if (hp->h_to != NIL && w & GTO)
    496  1.1       cgd 		fmt("To:", hp->h_to, fo, w&GCOMMA), gotcha++;
    497  1.1       cgd 	if (hp->h_subject != NOSTR && w & GSUBJECT)
    498  1.1       cgd 		fprintf(fo, "Subject: %s\n", hp->h_subject), gotcha++;
    499  1.1       cgd 	if (hp->h_cc != NIL && w & GCC)
    500  1.1       cgd 		fmt("Cc:", hp->h_cc, fo, w&GCOMMA), gotcha++;
    501  1.1       cgd 	if (hp->h_bcc != NIL && w & GBCC)
    502  1.1       cgd 		fmt("Bcc:", hp->h_bcc, fo, w&GCOMMA), gotcha++;
    503  1.1       cgd 	if (gotcha && w & GNL)
    504  1.1       cgd 		(void) putc('\n', fo);
    505  1.1       cgd 	return(0);
    506  1.1       cgd }
    507  1.1       cgd 
    508  1.1       cgd /*
    509  1.1       cgd  * Format the given header line to not exceed 72 characters.
    510  1.1       cgd  */
    511  1.4   deraadt void
    512  1.1       cgd fmt(str, np, fo, comma)
    513  1.1       cgd 	char *str;
    514  1.7     lukem 	struct name *np;
    515  1.1       cgd 	FILE *fo;
    516  1.1       cgd 	int comma;
    517  1.1       cgd {
    518  1.7     lukem 	int col, len;
    519  1.1       cgd 
    520  1.1       cgd 	comma = comma ? 1 : 0;
    521  1.1       cgd 	col = strlen(str);
    522  1.1       cgd 	if (col)
    523  1.1       cgd 		fputs(str, fo);
    524  1.1       cgd 	for (; np != NIL; np = np->n_flink) {
    525  1.1       cgd 		if (np->n_flink == NIL)
    526  1.1       cgd 			comma = 0;
    527  1.1       cgd 		len = strlen(np->n_name);
    528  1.1       cgd 		col++;		/* for the space */
    529  1.1       cgd 		if (col + len + comma > 72 && col > 4) {
    530  1.1       cgd 			fputs("\n    ", fo);
    531  1.1       cgd 			col = 4;
    532  1.1       cgd 		} else
    533  1.1       cgd 			putc(' ', fo);
    534  1.1       cgd 		fputs(np->n_name, fo);
    535  1.1       cgd 		if (comma)
    536  1.1       cgd 			putc(',', fo);
    537  1.1       cgd 		col += len + comma;
    538  1.1       cgd 	}
    539  1.1       cgd 	putc('\n', fo);
    540  1.1       cgd }
    541  1.1       cgd 
    542  1.1       cgd /*
    543  1.1       cgd  * Save the outgoing mail on the passed file.
    544  1.1       cgd  */
    545  1.1       cgd 
    546  1.1       cgd /*ARGSUSED*/
    547  1.4   deraadt int
    548  1.1       cgd savemail(name, fi)
    549  1.1       cgd 	char name[];
    550  1.7     lukem 	FILE *fi;
    551  1.1       cgd {
    552  1.7     lukem 	FILE *fo;
    553  1.1       cgd 	char buf[BUFSIZ];
    554  1.7     lukem 	int i;
    555  1.6  christos 	time_t now;
    556  1.1       cgd 
    557  1.1       cgd 	if ((fo = Fopen(name, "a")) == NULL) {
    558  1.1       cgd 		perror(name);
    559  1.1       cgd 		return (-1);
    560  1.1       cgd 	}
    561  1.1       cgd 	(void) time(&now);
    562  1.1       cgd 	fprintf(fo, "From %s %s", myname, ctime(&now));
    563  1.1       cgd 	while ((i = fread(buf, 1, sizeof buf, fi)) > 0)
    564  1.1       cgd 		(void) fwrite(buf, 1, i, fo);
    565  1.1       cgd 	(void) putc('\n', fo);
    566  1.1       cgd 	(void) fflush(fo);
    567  1.1       cgd 	if (ferror(fo))
    568  1.1       cgd 		perror(name);
    569  1.1       cgd 	(void) Fclose(fo);
    570  1.1       cgd 	rewind(fi);
    571  1.1       cgd 	return (0);
    572  1.1       cgd }
    573