xref: /illumos-gate/usr/src/cmd/mailx/fio.c (revision 5422785d)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 
23 /*
24  * Copyright 2014 Joyent, Inc.
25  */
26 
27 /*
28  * Copyright 1999 Sun Microsystems, Inc.  All rights reserved.
29  * Use is subject to license terms.
30  */
31 
32 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
33 /*	  All Rights Reserved  	*/
34 
35 #include "rcv.h"
36 #include <locale.h>
37 #include <wordexp.h>
38 
39 /*
40  * mailx -- a modified version of a University of California at Berkeley
41  *	mail program
42  *
43  * File I/O.
44  */
45 
46 static int getln(char *line, int max, FILE *f);
47 static int linecount(char *lp, long size);
48 
49 /*
50  * Set up the input pointers while copying the mail file into
51  * /tmp.
52  */
53 
54 void
setptr(register FILE * ibuf)55 setptr(register FILE *ibuf)
56 {
57 	int n, newline = 1, blankline = 1;
58 	int StartNewMsg = TRUE;
59 	int ToldUser = FALSE;
60 	long clen = -1L;
61 	int hdr = 0;
62 	int cflg = 0;			/* found Content-length in header */
63 	register char *cp;
64 	register int l;
65 	register long s;
66 	off_t offset;
67 	char linebuf[LINESIZE];
68 	int inhead, newmail, Odot;
69 	short flag;
70 
71 	if (!space) {
72 		msgCount = 0;
73 		offset = 0;
74 		space = 32;
75 		newmail = 0;
76 		message =
77 		    (struct message *)calloc(space, sizeof (struct message));
78 		if (message == NULL) {
79 			fprintf(stderr, gettext(
80 			    "calloc: insufficient memory for %d messages\n"),
81 			    space);
82 			exit(1);
83 			/* NOTREACHED */
84 		}
85 		dot = message;
86 	} else {
87 		newmail = 1;
88 		offset = fsize(otf);
89 	}
90 	s = 0L;
91 	l = 0;
92 	/*
93 	 * Set default flags.  When reading from
94 	 * a folder, assume the message has been
95 	 * previously read.
96 	 */
97 	if (edit)
98 		flag = MUSED|MREAD;
99 	else
100 		flag = MUSED|MNEW;
101 
102 	inhead = 0;
103 	while ((n = getln(linebuf, sizeof (linebuf), ibuf)) > 0) {
104 		if (!newline) {
105 			goto putout;
106 		}
107 	top:
108 		hdr = inhead && (headerp(linebuf) ||
109 		    (linebuf[0] == ' ' || linebuf[0] == '\t'));
110 		if (!hdr && cflg) {	/* nonheader, Content-length seen */
111 			if (clen > 0 && clen < n) {	/* read too much */
112 				/*
113 				 * NB: this only can happen if there is a
114 				 * small content that is NOT \n terminated
115 				 * and has no leading blank line, i.e., never.
116 				 */
117 				if (fwrite(linebuf, 1, (int)clen, otf) !=
118 					clen) {
119 					fclose(ibuf);
120 					fflush(otf);
121 				} else {
122 					l += linecount(linebuf, clen);
123 				}
124 				offset += clen;
125 				s += clen;
126 				n -= (int)clen;
127 				/* shift line to the left, copy null as well */
128 				memcpy(linebuf, linebuf+clen, n+1);
129 				cflg = 0;
130 				message[msgCount-1].m_clen = clen + 1;
131 				blankline = 1;
132 				StartNewMsg = TRUE;
133 				goto top;
134 			}
135 			/* here, clen == 0 or clen >= n */
136 			if (n == 1 && linebuf[0] == '\n') {
137 				/* leading empty line */
138 				clen++;		/* cheat */
139 				inhead = 0;
140 			}
141 			offset += clen;
142 			s += (long)clen;
143 			message[msgCount-1].m_clen = clen;
144 			for (;;) {
145 				if (fwrite(linebuf, 1, n, otf) != n) {
146 					fclose(ibuf);
147 					fflush(otf);
148 				} else {
149 					l += linecount(linebuf, n);
150 				}
151 				clen -= n;
152 				if (clen <= 0) {
153 					break;
154 				}
155 				n = clen < sizeof (linebuf) ?
156 				    (int)clen : (int)sizeof (linebuf);
157 				if ((n = fread(linebuf, 1, n, ibuf)) <= 0) {
158 					fprintf(stderr, gettext(
159 			"%s:\tYour mailfile was found to be corrupted.\n"),
160 					    progname);
161 					fprintf(stderr, gettext(
162 					    "\t(Unexpected end-of-file).\n"));
163 					fprintf(stderr, gettext(
164 					"\tMessage #%d may be truncated.\n\n"),
165 					    msgCount);
166 					offset -= clen;
167 					s -= clen;
168 					clen = 0; /* stop the loop */
169 				}
170 			}
171 			/* All done, go to top for next message */
172 			cflg = 0;
173 			blankline = 1;
174 			StartNewMsg = TRUE;
175 			continue;
176 		}
177 
178 		/* Look for a From line that starts a new message */
179 		if (blankline && linebuf[0] == 'F' && is_headline(linebuf)) {
180 			if (msgCount > 0 && !newmail) {
181 				message[msgCount-1].m_size = s;
182 				message[msgCount-1].m_lines = l;
183 				message[msgCount-1].m_flag = flag;
184 			}
185 			if (msgCount >= space) {
186 				/*
187 				 * Limit the speed at which the
188 				 * allocated space grows.
189 				 */
190 				if (space < 512)
191 					space = space*2;
192 				else
193 					space += 512;
194 				errno = 0;
195 				Odot = dot - &(message[0]);
196 				message = (struct message *)
197 				    realloc(message,
198 					space*(sizeof (struct message)));
199 				if (message == NULL) {
200 					perror("realloc failed");
201 					fprintf(stderr, gettext(
202 			"realloc: insufficient memory for %d messages\n"),
203 					    space);
204 					exit(1);
205 				}
206 				dot = &message[Odot];
207 			}
208 			message[msgCount].m_offset = offset;
209 			message[msgCount].m_text = TRUE;
210 			message[msgCount].m_clen = 0;
211 			newmail = 0;
212 			msgCount++;
213 			if (edit)
214 				flag = MUSED|MREAD;
215 			else
216 				flag = MUSED|MNEW;
217 			inhead = 1;
218 			s = 0L;
219 			l = 0;
220 			StartNewMsg = FALSE;
221 			ToldUser = FALSE;
222 			goto putout;
223 		}
224 
225 		/* if didn't get a header line, we're no longer in the header */
226 		if (!hdr)
227 			inhead = 0;
228 		if (!inhead)
229 			goto putout;
230 
231 		/*
232 		 * Look for Status: line.  Do quick check for second character,
233 		 * many headers start with "S" but few have "t" as second char.
234 		 */
235 		if ((linebuf[1] == 't' || linebuf[1] == 'T') &&
236 		    ishfield(linebuf, "status")) {
237 			cp = hcontents(linebuf);
238 			flag = MUSED|MNEW;
239 			if (strchr(cp, 'R'))
240 				flag |= MREAD;
241 			if (strchr(cp, 'O'))
242 				flag &= ~MNEW;
243 		}
244 		/*
245 		 * Look for Content-Length and Content-Type headers.  Like
246 		 * above, do a quick check for the "-", which is rare.
247 		 */
248 		if (linebuf[7] == '-') {
249 			if (ishfield(linebuf, "content-length")) {
250 				if (!cflg) {
251 					clen = atol(hcontents(linebuf));
252 					cflg = clen >= 0;
253 				}
254 			} else if (ishfield(linebuf, "content-type")) {
255 				char word[LINESIZE];
256 				char *cp2;
257 
258 				cp = hcontents(linebuf);
259 				cp2 = word;
260 				while (!isspace(*cp))
261 					*cp2++ = *cp++;
262 				*cp2 = '\0';
263 				if (icequal(word, "binary"))
264 					message[msgCount-1].m_text = FALSE;
265 			}
266 		}
267 putout:
268 		offset += n;
269 		s += (long)n;
270 		if (fwrite(linebuf, 1, n, otf) != n) {
271 			fclose(ibuf);
272 			fflush(otf);
273 		} else {
274 			l++;
275 		}
276 		if (ferror(otf)) {
277 			perror("/tmp");
278 			exit(1);
279 		}
280 		if (msgCount == 0) {
281 			fclose(ibuf);
282 			fflush(otf);
283 		}
284 		if (linebuf[n-1] == '\n') {
285 			blankline = newline && n == 1;
286 			newline = 1;
287 			if (n == 1) {
288 				/* Blank line. Skip StartNewMsg check below */
289 				continue;
290 			}
291 		} else {
292 			newline = 0;
293 		}
294 		if (StartNewMsg && !ToldUser) {
295 			fprintf(stderr, gettext(
296 			    "%s:\tYour mailfile was found to be corrupted\n"),
297 			    progname);
298 			fprintf(stderr,
299 			    gettext("\t(Content-length mismatch).\n"));
300 			fprintf(stderr, gettext(
301 			    "\tMessage #%d may be truncated,\n"), msgCount);
302 			fprintf(stderr, gettext(
303 			    "\twith another message concatenated to it.\n\n"));
304 			ToldUser = TRUE;
305 		}
306 	}
307 
308 	if (n == 0) {
309 		fflush(otf);
310 		if (fferror(otf)) {
311 			perror("/tmp");
312 			exit(1);
313 		}
314 		if (msgCount) {
315 			message[msgCount-1].m_size = s;
316 			message[msgCount-1].m_lines = l;
317 			message[msgCount-1].m_flag = flag;
318 		}
319 		fclose(ibuf);
320 	}
321 }
322 
323 /*
324  * Compute the content length of a message and set it into m_clen.
325  */
326 
327 void
setclen(register struct message * mp)328 setclen(register struct message *mp)
329 {
330 	long c;
331 	FILE *ibuf;
332 	char line[LINESIZE];
333 	int fline, nread;
334 
335 	ibuf = setinput(mp);
336 	c = mp->m_size;
337 	fline = 1;
338 	while (c > 0L) {
339 		nread = getln(line, sizeof (line), ibuf);
340 		c -= nread;
341 		/*
342 		 * First line is the From line, so no headers
343 		 * there to worry about.
344 		 */
345 		if (fline) {
346 			fline = 0;
347 			continue;
348 		}
349 		/*
350 		 * If line is blank, we've reached end of headers.
351 		 */
352 		if (line[0] == '\n')
353 			break;
354 		/*
355 		 * If this line is a continuation
356 		 * of a previous header field, keep going.
357 		 */
358 		if (isspace(line[0]))
359 			continue;
360 		/*
361 		 * If we are no longer looking at real
362 		 * header lines, we're done.
363 		 * This happens in uucp style mail where
364 		 * there are no headers at all.
365 		 */
366 		if (!headerp(line)) {
367 			c += nread;
368 			break;
369 		}
370 	}
371 	if (c == 0)
372 		c = 1;
373 	mp->m_clen = c;
374 }
375 
376 static int
getln(char * line,int max,FILE * f)377 getln(char *line, int max, FILE *f)
378 {
379 	register int c;
380 	register char *cp, *ecp;
381 
382 	cp = line;
383 	ecp = cp + max - 1;
384 	while (cp < ecp && (c = getc(f)) != EOF)
385 		if ((*cp++ = (char)c) == '\n')
386 			break;
387 	*cp = '\0';
388 	return (cp - line);
389 }
390 
391 /*
392  * Read up a line from the specified input into the line
393  * buffer.  Return the number of characters read.  Do not
394  * include the newline at the end.
395  */
396 
397 int
readline(FILE * ibuf,char * linebuf)398 readline(FILE *ibuf, char *linebuf)
399 {
400 	register char *cp;
401 	register int c;
402 	int seennulls = 0;
403 
404 	clearerr(ibuf);
405 	c = getc(ibuf);
406 	for (cp = linebuf; c != '\n' && c != EOF; c = getc(ibuf)) {
407 		if (c == 0) {
408 			if (!seennulls) {
409 				fprintf(stderr,
410 				    gettext("mailx: NUL changed to @\n"));
411 				seennulls++;
412 			}
413 			c = '@';
414 		}
415 		if (cp - linebuf < LINESIZE-2)
416 			*cp++ = (char)c;
417 	}
418 	*cp = 0;
419 	if (c == EOF && cp == linebuf)
420 		return (0);
421 	return (cp - linebuf + 1);
422 }
423 
424 /*
425  * linecount - determine the number of lines in a printable file.
426  */
427 
428 static int
linecount(char * lp,long size)429 linecount(char *lp, long size)
430 {
431 	register char *cp, *ecp;
432 	register int count;
433 
434 	count = 0;
435 	cp = lp;
436 	ecp = cp + size;
437 	while (cp < ecp)
438 		if (*cp++ == '\n')
439 			count++;
440 	return (count);
441 }
442 
443 /*
444  * Return a file buffer all ready to read up the
445  * passed message pointer.
446  */
447 
448 FILE *
setinput(register struct message * mp)449 setinput(register struct message *mp)
450 {
451 	fflush(otf);
452 	if (fseek(itf, mp->m_offset, 0) < 0) {
453 		perror("fseek");
454 		panic("temporary file seek");
455 	}
456 	return (itf);
457 }
458 
459 
460 /*
461  * Delete a file, but only if the file is a plain file.
462  */
463 
464 int
removefile(char name[])465 removefile(char name[])
466 {
467 	struct stat statb;
468 	extern int errno;
469 
470 	if (stat(name, &statb) < 0)
471 		if (errno == ENOENT)
472 			return (0);	/* it's already gone, no error */
473 		else
474 			return (-1);
475 	if ((statb.st_mode & S_IFMT) != S_IFREG) {
476 		errno = EISDIR;
477 		return (-1);
478 	}
479 	return (unlink(name));
480 }
481 
482 /*
483  * Terminate an editing session by attempting to write out the user's
484  * file from the temporary.  Save any new stuff appended to the file.
485  */
486 int
edstop(int noremove)487 edstop(
488     int noremove	/* don't allow the file to be removed, trunc instead */
489 )
490 {
491 	register int gotcha, c;
492 	register struct message *mp;
493 	FILE *obuf, *ibuf, *tbuf = 0, *readstat;
494 	struct stat statb;
495 	char tempname[STSIZ], *id;
496 	int tmpfd = -1;
497 
498 	if (readonly)
499 		return (0);
500 	holdsigs();
501 	if (Tflag != NOSTR) {
502 		if ((readstat = fopen(Tflag, "w")) == NULL)
503 			Tflag = NOSTR;
504 	}
505 	for (mp = &message[0], gotcha = 0; mp < &message[msgCount]; mp++) {
506 		if (mp->m_flag & MNEW) {
507 			mp->m_flag &= ~MNEW;
508 			mp->m_flag |= MSTATUS;
509 		}
510 		if (mp->m_flag & (MODIFY|MDELETED|MSTATUS))
511 			gotcha++;
512 		if (Tflag != NOSTR && (mp->m_flag & (MREAD|MDELETED)) != 0) {
513 			if ((id = hfield("article-id", mp, addone)) != NOSTR)
514 				fprintf(readstat, "%s\n", id);
515 		}
516 	}
517 	if (Tflag != NOSTR)
518 		fclose(readstat);
519 	if (!gotcha || Tflag != NOSTR)
520 		goto done;
521 	if ((ibuf = fopen(editfile, "r+")) == NULL) {
522 		perror(editfile);
523 		relsesigs();
524 		longjmp(srbuf, 1);
525 	}
526 	lock(ibuf, "r+", 1);
527 	if (fstat(fileno(ibuf), &statb) >= 0 && statb.st_size > mailsize) {
528 		nstrcpy(tempname, STSIZ, "/tmp/mboxXXXXXX");
529 		if ((tmpfd = mkstemp(tempname)) == -1) {
530 			perror(tempname);
531 			fclose(ibuf);
532 			relsesigs();
533 			longjmp(srbuf, 1);
534 		}
535 		if ((obuf = fdopen(tmpfd, "w")) == NULL) {
536 			perror(tempname);
537 			fclose(ibuf);
538 			removefile(tempname);
539 			relsesigs();
540 			(void) close(tmpfd);
541 			longjmp(srbuf, 1);
542 		}
543 		fseek(ibuf, mailsize, 0);
544 		while ((c = getc(ibuf)) != EOF)
545 			putc(c, obuf);
546 		fclose(obuf);
547 		if ((tbuf = fopen(tempname, "r")) == NULL) {
548 			perror(tempname);
549 			fclose(ibuf);
550 			removefile(tempname);
551 			relsesigs();
552 			longjmp(srbuf, 1);
553 		}
554 		removefile(tempname);
555 	}
556 	if ((obuf = fopen(editfile, "r+")) == NULL) {
557 		if ((obuf = fopen(editfile, "w")) == NULL) {
558 			perror(editfile);
559 			fclose(ibuf);
560 			if (tbuf)
561 				fclose(tbuf);
562 			relsesigs();
563 			longjmp(srbuf, 1);
564 		}
565 	}
566 	printf("\"%s\" ", editfile);
567 	flush();
568 	c = 0;
569 	for (mp = &message[0]; mp < &message[msgCount]; mp++) {
570 		if ((mp->m_flag & MDELETED) != 0)
571 			continue;
572 		c++;
573 		if (msend(mp, obuf, 0, fputs) < 0) {
574 			perror(editfile);
575 			fclose(ibuf);
576 			fclose(obuf);
577 			if (tbuf)
578 				fclose(tbuf);
579 			relsesigs();
580 			longjmp(srbuf, 1);
581 		}
582 	}
583 	gotcha = (c == 0 && tbuf == NULL);
584 	if (tbuf != NULL) {
585 		while ((c = getc(tbuf)) != EOF)
586 			putc(c, obuf);
587 		fclose(tbuf);
588 	}
589 	fflush(obuf);
590 	if (fferror(obuf)) {
591 		perror(editfile);
592 		fclose(ibuf);
593 		fclose(obuf);
594 		relsesigs();
595 		longjmp(srbuf, 1);
596 	}
597 	if (gotcha && !noremove && (value("keep") == NOSTR)) {
598 		removefile(editfile);
599 		printf(gettext("removed.\n"));
600 	}
601 	else
602 		printf(gettext("updated.\n"));
603 	fclose(ibuf);
604 	trunc(obuf);
605 	fclose(obuf);
606 	flush();
607 
608 done:
609 	relsesigs();
610 	return (1);
611 }
612 
613 #ifndef OLD_BSD_SIGS
614 static int sigdepth = 0;		/* depth of holdsigs() */
615 #ifdef VMUNIX
616 static int omask = 0;
617 #else
618 static	sigset_t mask, omask;
619 #endif
620 #endif
621 /*
622  * Hold signals SIGHUP - SIGQUIT.
623  */
624 void
holdsigs(void)625 holdsigs(void)
626 {
627 #ifndef OLD_BSD_SIGS
628 	if (sigdepth++ == 0) {
629 #ifdef VMUNIX
630 		omask = sigblock(sigmask(SIGHUP) |
631 		    sigmask(SIGINT)|sigmask(SIGQUIT));
632 #else
633 		sigemptyset(&mask);
634 		sigaddset(&mask, SIGHUP);
635 		sigaddset(&mask, SIGINT);
636 		sigaddset(&mask, SIGQUIT);
637 		sigprocmask(SIG_BLOCK, &mask, &omask);
638 #endif
639 	}
640 #else
641 	sighold(SIGHUP);
642 	sighold(SIGINT);
643 	sighold(SIGQUIT);
644 #endif
645 }
646 
647 /*
648  * Release signals SIGHUP - SIGQUIT
649  */
650 void
relsesigs(void)651 relsesigs(void)
652 {
653 #ifndef OLD_BSD_SIGS
654 	if (--sigdepth == 0)
655 #ifdef VMUNIX
656 		sigsetmask(omask);
657 #else
658 		sigprocmask(SIG_SETMASK, &omask, NULL);
659 #endif
660 #else
661 	sigrelse(SIGHUP);
662 	sigrelse(SIGINT);
663 	sigrelse(SIGQUIT);
664 #endif
665 }
666 
667 #if !defined(OLD_BSD_SIGS) && !defined(VMUNIX)
668 void
sigset(int sig,void (* act)(int))669 (*sigset(int sig, void (*act)(int)))(int)
670 {
671 	struct sigaction sa, osa;
672 
673 	sa.sa_handler = (void (*)())act;
674 	sigemptyset(&sa.sa_mask);
675 	sa.sa_flags = SA_RESTART;
676 	if (sigaction(sig, &sa, &osa) < 0)
677 		return ((void (*)(int))-1);
678 	return ((void (*)(int))osa.sa_handler);
679 }
680 #endif
681 
682 /*
683  * Flush the standard output.
684  */
685 
686 void
flush(void)687 flush(void)
688 {
689 	fflush(stdout);
690 	fflush(stderr);
691 }
692 
693 /*
694  * Determine the size of the file possessed by
695  * the passed buffer.
696  */
697 
698 off_t
fsize(FILE * iob)699 fsize(FILE *iob)
700 {
701 	register int f;
702 	struct stat sbuf;
703 
704 	f = fileno(iob);
705 	if (fstat(f, &sbuf) < 0)
706 		return (0);
707 	return (sbuf.st_size);
708 }
709 
710 /*
711  * Check for either a stdio recognized error, or
712  * a possibly delayed write error (in case it's
713  * an NFS file, for instance).
714  */
715 
716 int
fferror(FILE * iob)717 fferror(FILE *iob)
718 {
719 	return (ferror(iob) || fsync(fileno(iob)) < 0);
720 }
721 
722 /*
723  * Take a file name, possibly with shell meta characters
724  * in it and expand it by using wordexp().
725  * Return the file name as a dynamic string.
726  * If the name cannot be expanded (for whatever reason)
727  * return NULL.
728  */
729 
730 char *
expand(char * name)731 expand(char *name)
732 {
733 	char xname[BUFSIZ];
734 	char foldbuf[BUFSIZ];
735 	register char *cp;
736 	register int l;
737 	wordexp_t wrdexp_buf;
738 
739 	if (debug) fprintf(stderr, "expand(%s)=", name);
740 	cp = strchr(name, '\0') - 1;	/* pointer to last char of name */
741 	if (isspace(*cp)) {
742 		/* strip off trailing blanks */
743 		while (cp > name && isspace(*cp))
744 			cp--;
745 		l = *++cp;	/* save char */
746 		*cp = '\0';
747 		name = savestr(name);
748 		*cp = (char)l;	/* restore char */
749 	}
750 	if (name[0] == '+' && getfold(foldbuf) >= 0) {
751 		snprintf(xname, sizeof (xname), "%s/%s", foldbuf, name + 1);
752 		cp = safeexpand(savestr(xname));
753 		if (debug) fprintf(stderr, "%s\n", cp);
754 		return (cp);
755 	}
756 	if (!anyof(name, "~{[*?$`'\"\\")) {
757 		if (debug) fprintf(stderr, "%s\n", name);
758 		return (name);
759 	}
760 	if (wordexp(name, &wrdexp_buf, WRDE_NOCMD) != 0) {
761 		fprintf(stderr, gettext("Syntax error in \"%s\"\n"), name);
762 		fflush(stderr);
763 		return (NOSTR);
764 	}
765 	if (wrdexp_buf.we_wordc > 1) {
766 		fprintf(stderr, gettext("\"%s\": Ambiguous\n"), name);
767 		fflush(stderr);
768 		return (NOSTR);
769 	}
770 	if (debug) fprintf(stderr, "%s\n", wrdexp_buf.we_wordv[0]);
771 	return (savestr(wrdexp_buf.we_wordv[0]));
772 }
773 
774 /*
775  * Take a file name, possibly with shell meta characters
776  * in it and expand it by using "sh -c echo filename"
777  * Return the file name as a dynamic string.
778  * If the name cannot be expanded (for whatever reason)
779  * return the original file name.
780  */
781 
782 char *
safeexpand(char name[])783 safeexpand(char name[])
784 {
785 	char *t = expand(name);
786 	return (t) ? t : savestr(name);
787 }
788 
789 /*
790  * Determine the current folder directory name.
791  */
792 int
getfold(char * name)793 getfold(char *name)
794 {
795 	char *folder;
796 
797 	if ((folder = value("folder")) == NOSTR || *folder == '\0')
798 		return (-1);
799 	/*
800 	 * If name looks like a folder name, don't try
801 	 * to expand it, to prevent infinite recursion.
802 	 */
803 	if (*folder != '+' && (folder = expand(folder)) == NOSTR ||
804 	    *folder == '\0')
805 		return (-1);
806 	if (*folder == '/') {
807 		nstrcpy(name, BUFSIZ, folder);
808 	} else
809 		snprintf(name, BUFSIZ, "%s/%s", homedir, folder);
810 	return (0);
811 }
812 
813 /*
814  * A nicer version of Fdopen, which allows us to fclose
815  * without losing the open file.
816  */
817 
818 FILE *
Fdopen(int fildes,char * mode)819 Fdopen(int fildes, char *mode)
820 {
821 	register int f;
822 
823 	f = dup(fildes);
824 	if (f < 0) {
825 		perror("dup");
826 		return (NULL);
827 	}
828 	return (fdopen(f, mode));
829 }
830 
831 /*
832  * return the filename associated with "s".  This function always
833  * returns a non-null string (no error checking is done on the receiving end)
834  */
835 char *
Getf(register char * s)836 Getf(register char *s)
837 {
838 	register char *cp;
839 	static char defbuf[PATHSIZE];
840 
841 	if (((cp = value(s)) != 0) && *cp) {
842 		return (safeexpand(cp));
843 	} else if (strcmp(s, "MBOX") == 0) {
844 		snprintf(defbuf, sizeof (defbuf), "%s/%s", Getf("HOME"),
845 			"mbox");
846 		return (defbuf);
847 	} else if (strcmp(s, "DEAD") == 0) {
848 		snprintf(defbuf, sizeof (defbuf), "%s/%s", Getf("HOME"),
849 			"dead.letter");
850 		return (defbuf);
851 	} else if (strcmp(s, "MAILRC") == 0) {
852 		snprintf(defbuf, sizeof (defbuf), "%s/%s", Getf("HOME"),
853 			".mailrc");
854 		return (defbuf);
855 	} else if (strcmp(s, "HOME") == 0) {
856 		/* no recursion allowed! */
857 		return (".");
858 	}
859 	return ("DEAD");	/* "cannot happen" */
860 }
861