1*d9a51c35Sjmc /* $OpenBSD: fio.c,v 1.39 2022/12/26 19:16:01 jmc Exp $ */
2db59c1a6Smillert /* $NetBSD: fio.c,v 1.8 1997/07/07 22:57:55 phil Exp $ */
37eb34045Sderaadt
4df930be7Sderaadt /*
5df930be7Sderaadt * Copyright (c) 1980, 1993
6df930be7Sderaadt * The Regents of the University of California. All rights reserved.
7df930be7Sderaadt *
8df930be7Sderaadt * Redistribution and use in source and binary forms, with or without
9df930be7Sderaadt * modification, are permitted provided that the following conditions
10df930be7Sderaadt * are met:
11df930be7Sderaadt * 1. Redistributions of source code must retain the above copyright
12df930be7Sderaadt * notice, this list of conditions and the following disclaimer.
13df930be7Sderaadt * 2. Redistributions in binary form must reproduce the above copyright
14df930be7Sderaadt * notice, this list of conditions and the following disclaimer in the
15df930be7Sderaadt * documentation and/or other materials provided with the distribution.
16f75387cbSmillert * 3. Neither the name of the University nor the names of its contributors
17df930be7Sderaadt * may be used to endorse or promote products derived from this software
18df930be7Sderaadt * without specific prior written permission.
19df930be7Sderaadt *
20df930be7Sderaadt * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21df930be7Sderaadt * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22df930be7Sderaadt * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23df930be7Sderaadt * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24df930be7Sderaadt * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25df930be7Sderaadt * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26df930be7Sderaadt * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27df930be7Sderaadt * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28df930be7Sderaadt * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29df930be7Sderaadt * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30df930be7Sderaadt * SUCH DAMAGE.
31df930be7Sderaadt */
32df930be7Sderaadt
33df930be7Sderaadt #include "rcv.h"
34df930be7Sderaadt
35df930be7Sderaadt #include <unistd.h>
36df930be7Sderaadt #include <paths.h>
37df930be7Sderaadt #include <errno.h>
3832cc11aaSmillert #include <glob.h>
39df930be7Sderaadt #include "extern.h"
40df930be7Sderaadt
41df930be7Sderaadt /*
42df930be7Sderaadt * Mail -- a mail program
43df930be7Sderaadt *
44df930be7Sderaadt * File I/O.
45df930be7Sderaadt */
46df930be7Sderaadt
477f56ba93Smillert static volatile sig_atomic_t fiosignal;
487f56ba93Smillert
49df930be7Sderaadt /*
50ca8b07b0Smillert * Wrapper for read() to catch EINTR.
51ca8b07b0Smillert */
52d33b10b9Sderaadt static ssize_t
myread(int fd,char * buf,int len)534a9caef2Smillert myread(int fd, char *buf, int len)
54ca8b07b0Smillert {
55ca8b07b0Smillert ssize_t nread;
56ca8b07b0Smillert
57ca8b07b0Smillert while ((nread = read(fd, buf, len)) == -1 && errno == EINTR)
58ca8b07b0Smillert ;
59ca8b07b0Smillert return(nread);
60ca8b07b0Smillert }
61ca8b07b0Smillert
62ca8b07b0Smillert /*
63df930be7Sderaadt * Set up the input pointers while copying the mail file into /tmp.
64df930be7Sderaadt */
65df930be7Sderaadt void
setptr(FILE * ibuf,off_t offset)664a9caef2Smillert setptr(FILE *ibuf, off_t offset)
67df930be7Sderaadt {
6836999bedSmillert int c, count;
6936999bedSmillert char *cp, *cp2;
70df930be7Sderaadt struct message this;
71df930be7Sderaadt FILE *mestmp;
7236999bedSmillert int maybe, inhead, omsgCount;
73c32a3250Sderaadt char linebuf[LINESIZE], pathbuf[PATHSIZE];
74df930be7Sderaadt
75df930be7Sderaadt /* Get temporary file. */
76db59c1a6Smillert (void)snprintf(pathbuf, sizeof(pathbuf), "%s/mail.XXXXXXXXXX", tmpdir);
77db59c1a6Smillert if ((c = mkstemp(pathbuf)) == -1 || (mestmp = Fdopen(c, "r+")) == NULL)
78db59c1a6Smillert err(1, "can't open %s", pathbuf);
790ecc72fcSmillert (void)rm(pathbuf);
80df930be7Sderaadt
81db59c1a6Smillert if (offset == 0) {
82df930be7Sderaadt msgCount = 0;
83db59c1a6Smillert } else {
84db59c1a6Smillert /* Seek into the file to get to the new messages */
85a52c79cdStobias (void)fseeko(ibuf, offset, SEEK_SET);
86db59c1a6Smillert /*
87db59c1a6Smillert * We need to make "offset" a pointer to the end of
88db59c1a6Smillert * the temp file that has the copy of the mail file.
89db59c1a6Smillert * If any messages have been edited, this will be
90db59c1a6Smillert * different from the offset into the mail file.
91db59c1a6Smillert */
922a187660Sderaadt (void)fseeko(otf, (off_t)0, SEEK_END);
93db59c1a6Smillert offset = ftell(otf);
94db59c1a6Smillert }
95db59c1a6Smillert omsgCount = msgCount;
96df930be7Sderaadt maybe = 1;
97df930be7Sderaadt inhead = 0;
98df930be7Sderaadt this.m_flag = MUSED|MNEW;
99df930be7Sderaadt this.m_size = 0;
100df930be7Sderaadt this.m_lines = 0;
101df930be7Sderaadt this.m_block = 0;
102df930be7Sderaadt this.m_offset = 0;
103df930be7Sderaadt for (;;) {
104db59c1a6Smillert if (fgets(linebuf, sizeof(linebuf), ibuf) == NULL) {
105db59c1a6Smillert if (append(&this, mestmp))
106db59c1a6Smillert err(1, "temporary file");
107db59c1a6Smillert makemessage(mestmp, omsgCount);
108df930be7Sderaadt return;
109df930be7Sderaadt }
110df930be7Sderaadt count = strlen(linebuf);
1117f7d0dfbSmillert /*
1127f7d0dfbSmillert * Transforms lines ending in <CR><LF> to just <LF>.
1137f7d0dfbSmillert * This allows mail to be able to read Eudora mailboxes
1147f7d0dfbSmillert * that reside on a DOS partition.
1157f7d0dfbSmillert */
1167f7d0dfbSmillert if (count >= 2 && linebuf[count-1] == '\n' &&
117ad26b615Sray linebuf[count - 2] == '\r') {
118ad26b615Sray linebuf[count - 2] = '\n';
119ad26b615Sray linebuf[count - 1] = '\0';
120ad26b615Sray count--;
121ad26b615Sray }
1227f7d0dfbSmillert
123db59c1a6Smillert (void)fwrite(linebuf, sizeof(*linebuf), count, otf);
124db59c1a6Smillert if (ferror(otf))
12564d7140cSmartynas err(1, "%s", pathbuf);
12604bc0233Schl if (count && linebuf[count - 1] == '\n')
127db59c1a6Smillert linebuf[count - 1] = '\0';
128df930be7Sderaadt if (maybe && linebuf[0] == 'F' && ishead(linebuf)) {
129df930be7Sderaadt msgCount++;
130db59c1a6Smillert if (append(&this, mestmp))
131db59c1a6Smillert err(1, "temporary file");
132df930be7Sderaadt this.m_flag = MUSED|MNEW;
133df930be7Sderaadt this.m_size = 0;
134df930be7Sderaadt this.m_lines = 0;
135df930be7Sderaadt this.m_block = blockof(offset);
136df930be7Sderaadt this.m_offset = offsetof(offset);
137df930be7Sderaadt inhead = 1;
138df930be7Sderaadt } else if (linebuf[0] == 0) {
139df930be7Sderaadt inhead = 0;
140df930be7Sderaadt } else if (inhead) {
141df930be7Sderaadt for (cp = linebuf, cp2 = "status";; cp++) {
142085f113bSokan if ((c = (unsigned char)*cp2++) == 0) {
143be435c80Smmcc while (isspace((unsigned char)*cp++))
144df930be7Sderaadt ;
145df930be7Sderaadt if (cp[-1] != ':')
146df930be7Sderaadt break;
147085f113bSokan while ((c = (unsigned char)*cp++) != '\0')
148df930be7Sderaadt if (c == 'R')
149df930be7Sderaadt this.m_flag |= MREAD;
150df930be7Sderaadt else if (c == 'O')
151df930be7Sderaadt this.m_flag &= ~MNEW;
152df930be7Sderaadt inhead = 0;
153df930be7Sderaadt break;
154df930be7Sderaadt }
155df930be7Sderaadt if (*cp != c && *cp != toupper(c))
156df930be7Sderaadt break;
157df930be7Sderaadt }
158df930be7Sderaadt }
159df930be7Sderaadt offset += count;
160df930be7Sderaadt this.m_size += count;
161df930be7Sderaadt this.m_lines++;
162df930be7Sderaadt maybe = linebuf[0] == 0;
163df930be7Sderaadt }
164df930be7Sderaadt }
165df930be7Sderaadt
166df930be7Sderaadt /*
167df930be7Sderaadt * Drop the passed line onto the passed output buffer.
168df930be7Sderaadt * If a write error occurs, return -1, else the count of
169db59c1a6Smillert * characters written, including the newline if requested.
170df930be7Sderaadt */
171df930be7Sderaadt int
putline(FILE * obuf,char * linebuf,int outlf)1724a9caef2Smillert putline(FILE *obuf, char *linebuf, int outlf)
173df930be7Sderaadt {
17436999bedSmillert int c;
175df930be7Sderaadt
176df930be7Sderaadt c = strlen(linebuf);
177db59c1a6Smillert (void)fwrite(linebuf, sizeof(*linebuf), c, obuf);
178db59c1a6Smillert if (outlf) {
179df930be7Sderaadt (void)putc('\n', obuf);
180db59c1a6Smillert c++;
181db59c1a6Smillert }
182df930be7Sderaadt if (ferror(obuf))
183df930be7Sderaadt return(-1);
184db59c1a6Smillert return(c);
185df930be7Sderaadt }
186df930be7Sderaadt
187df930be7Sderaadt /*
188df930be7Sderaadt * Read up a line from the specified input into the line
189df930be7Sderaadt * buffer. Return the number of characters read. Do not
1907f7d0dfbSmillert * include the newline (or carriage return) at the end.
191df930be7Sderaadt */
192df930be7Sderaadt int
readline(FILE * ibuf,char * linebuf,int linesize,int * signo)1934a9caef2Smillert readline(FILE *ibuf, char *linebuf, int linesize, int *signo)
194df930be7Sderaadt {
1957f56ba93Smillert struct sigaction act;
1967f56ba93Smillert struct sigaction savetstp;
1977f56ba93Smillert struct sigaction savettou;
1987f56ba93Smillert struct sigaction savettin;
1997f56ba93Smillert struct sigaction saveint;
2007f56ba93Smillert struct sigaction savehup;
2017f56ba93Smillert sigset_t oset;
20236999bedSmillert int n;
203df930be7Sderaadt
2047f56ba93Smillert /*
2057f56ba93Smillert * Setup signal handlers if the caller asked us to catch signals.
2067f56ba93Smillert * Note that we do not restart system calls since we need the
20765389327Skrw * read to be interruptible.
2087f56ba93Smillert */
2097f56ba93Smillert if (signo) {
2107f56ba93Smillert fiosignal = 0;
2117f56ba93Smillert sigemptyset(&act.sa_mask);
2127f56ba93Smillert act.sa_flags = 0;
2137f56ba93Smillert act.sa_handler = fioint;
2147f56ba93Smillert if (sigaction(SIGINT, NULL, &saveint) == 0 &&
2157f56ba93Smillert saveint.sa_handler != SIG_IGN) {
2167f56ba93Smillert (void)sigaction(SIGINT, &act, &saveint);
2177f56ba93Smillert (void)sigprocmask(SIG_UNBLOCK, &intset, &oset);
2187f56ba93Smillert }
2197f56ba93Smillert if (sigaction(SIGHUP, NULL, &savehup) == 0 &&
2207f56ba93Smillert savehup.sa_handler != SIG_IGN)
2217f56ba93Smillert (void)sigaction(SIGHUP, &act, &savehup);
2227f56ba93Smillert (void)sigaction(SIGTSTP, &act, &savetstp);
2237f56ba93Smillert (void)sigaction(SIGTTOU, &act, &savettou);
2247f56ba93Smillert (void)sigaction(SIGTTIN, &act, &savettin);
2257f56ba93Smillert }
226db59c1a6Smillert
2277f56ba93Smillert clearerr(ibuf);
2287f56ba93Smillert if (fgets(linebuf, linesize, ibuf) == NULL) {
2297f56ba93Smillert if (ferror(ibuf))
2307f56ba93Smillert clearerr(ibuf);
2317f56ba93Smillert n = -1;
2327f56ba93Smillert } else {
233df930be7Sderaadt n = strlen(linebuf);
234df930be7Sderaadt if (n > 0 && linebuf[n - 1] == '\n')
235df930be7Sderaadt linebuf[--n] = '\0';
2367f7d0dfbSmillert if (n > 0 && linebuf[n - 1] == '\r')
2377f7d0dfbSmillert linebuf[--n] = '\0';
2387f56ba93Smillert }
2397f56ba93Smillert
2407f56ba93Smillert if (signo) {
2417f56ba93Smillert (void)sigprocmask(SIG_SETMASK, &oset, NULL);
2427f56ba93Smillert (void)sigaction(SIGINT, &saveint, NULL);
2437f56ba93Smillert (void)sigaction(SIGHUP, &savehup, NULL);
2447f56ba93Smillert (void)sigaction(SIGTSTP, &savetstp, NULL);
2457f56ba93Smillert (void)sigaction(SIGTTOU, &savettou, NULL);
2467f56ba93Smillert (void)sigaction(SIGTTIN, &savettin, NULL);
2477f56ba93Smillert *signo = fiosignal;
2487f56ba93Smillert }
2497f56ba93Smillert
250db59c1a6Smillert return(n);
251df930be7Sderaadt }
252df930be7Sderaadt
253df930be7Sderaadt /*
254df930be7Sderaadt * Return a file buffer all ready to read up the
255df930be7Sderaadt * passed message pointer.
256df930be7Sderaadt */
257df930be7Sderaadt FILE *
setinput(struct message * mp)2584a9caef2Smillert setinput(struct message *mp)
259df930be7Sderaadt {
260df930be7Sderaadt
261df930be7Sderaadt fflush(otf);
262a52c79cdStobias if (fseek(itf, (long)positionof(mp->m_block, mp->m_offset), SEEK_SET)
2633aaa63ebSderaadt == -1)
26436999bedSmillert err(1, "fseek");
265df930be7Sderaadt return(itf);
266df930be7Sderaadt }
267df930be7Sderaadt
268df930be7Sderaadt /*
269df930be7Sderaadt * Take the data out of the passed ghost file and toss it into
270df930be7Sderaadt * a dynamically allocated message structure.
271df930be7Sderaadt */
272df930be7Sderaadt void
makemessage(FILE * f,int omsgCount)2734a9caef2Smillert makemessage(FILE *f, int omsgCount)
274df930be7Sderaadt {
2753462a97cSmillert size_t size;
2763462a97cSmillert struct message *nmessage;
277df930be7Sderaadt
2783462a97cSmillert size = (msgCount + 1) * sizeof(struct message);
279cd9ca5b7Smmcc nmessage = realloc(message, size);
2803462a97cSmillert if (nmessage == 0)
281cd9ca5b7Smmcc err(1, "realloc");
2823462a97cSmillert if (omsgCount == 0 || message == NULL)
2833462a97cSmillert dot = nmessage;
2843462a97cSmillert else
2853462a97cSmillert dot = nmessage + (dot - message);
2863462a97cSmillert message = nmessage;
287db59c1a6Smillert size -= (omsgCount + 1) * sizeof(struct message);
288df930be7Sderaadt fflush(f);
28985c482d6Sderaadt (void)lseek(fileno(f), (off_t)sizeof(*message), SEEK_SET);
290ca8b07b0Smillert if (myread(fileno(f), (void *) &message[omsgCount], size) != size)
29136999bedSmillert errx(1, "Message temporary file corrupted");
292df930be7Sderaadt message[msgCount].m_size = 0;
293df930be7Sderaadt message[msgCount].m_lines = 0;
294db59c1a6Smillert (void)Fclose(f);
295df930be7Sderaadt }
296df930be7Sderaadt
297df930be7Sderaadt /*
298df930be7Sderaadt * Append the passed message descriptor onto the temp file.
299df930be7Sderaadt * If the write fails, return 1, else 0
300df930be7Sderaadt */
301df930be7Sderaadt int
append(struct message * mp,FILE * f)3024a9caef2Smillert append(struct message *mp, FILE *f)
303df930be7Sderaadt {
3044a9caef2Smillert
305db59c1a6Smillert return(fwrite((char *) mp, sizeof(*mp), 1, f) != 1);
306df930be7Sderaadt }
307df930be7Sderaadt
308df930be7Sderaadt /*
3090b426e12Smillert * Delete or truncate a file, but only if the file is a plain file.
310df930be7Sderaadt */
311df930be7Sderaadt int
rm(char * name)3124a9caef2Smillert rm(char *name)
313df930be7Sderaadt {
314df930be7Sderaadt struct stat sb;
315df930be7Sderaadt
3163aaa63ebSderaadt if (stat(name, &sb) == -1)
317df930be7Sderaadt return(-1);
318df930be7Sderaadt if (!S_ISREG(sb.st_mode)) {
319df930be7Sderaadt errno = EISDIR;
320df930be7Sderaadt return(-1);
321df930be7Sderaadt }
3220b426e12Smillert if (unlink(name) == -1) {
3230b426e12Smillert if (errno == EPERM)
3242a187660Sderaadt return(truncate(name, (off_t)0));
3250b426e12Smillert else
3260b426e12Smillert return(-1);
3270b426e12Smillert }
3280b426e12Smillert return(0);
329df930be7Sderaadt }
330df930be7Sderaadt
331df930be7Sderaadt static int sigdepth; /* depth of holdsigs() */
3327eb34045Sderaadt static sigset_t nset, oset;
333df930be7Sderaadt /*
334df930be7Sderaadt * Hold signals SIGHUP, SIGINT, and SIGQUIT.
335df930be7Sderaadt */
336df930be7Sderaadt void
holdsigs(void)3374a9caef2Smillert holdsigs(void)
338df930be7Sderaadt {
339df930be7Sderaadt
3407eb34045Sderaadt if (sigdepth++ == 0) {
3417eb34045Sderaadt sigemptyset(&nset);
3427eb34045Sderaadt sigaddset(&nset, SIGHUP);
3437eb34045Sderaadt sigaddset(&nset, SIGINT);
3447eb34045Sderaadt sigaddset(&nset, SIGQUIT);
3457eb34045Sderaadt sigprocmask(SIG_BLOCK, &nset, &oset);
3467eb34045Sderaadt }
347df930be7Sderaadt }
348df930be7Sderaadt
349df930be7Sderaadt /*
350df930be7Sderaadt * Release signals SIGHUP, SIGINT, and SIGQUIT.
351df930be7Sderaadt */
352df930be7Sderaadt void
relsesigs(void)3534a9caef2Smillert relsesigs(void)
354df930be7Sderaadt {
355df930be7Sderaadt
356df930be7Sderaadt if (--sigdepth == 0)
3577eb34045Sderaadt sigprocmask(SIG_SETMASK, &oset, NULL);
358df930be7Sderaadt }
359df930be7Sderaadt
360df930be7Sderaadt /*
3617f56ba93Smillert * Unblock and ignore a signal
3627f56ba93Smillert */
3637f56ba93Smillert int
ignoresig(int sig,struct sigaction * oact,sigset_t * oset)3644a9caef2Smillert ignoresig(int sig, struct sigaction *oact, sigset_t *oset)
3657f56ba93Smillert {
3667f56ba93Smillert struct sigaction act;
3677f56ba93Smillert sigset_t nset;
3687f56ba93Smillert int error;
3697f56ba93Smillert
3707f56ba93Smillert sigemptyset(&act.sa_mask);
3717f56ba93Smillert act.sa_flags = SA_RESTART;
3727f56ba93Smillert act.sa_handler = SIG_IGN;
3737f56ba93Smillert error = sigaction(sig, &act, oact);
3747f56ba93Smillert
3757f56ba93Smillert if (error == 0) {
3767f56ba93Smillert sigemptyset(&nset);
3777f56ba93Smillert sigaddset(&nset, sig);
3787f56ba93Smillert (void)sigprocmask(SIG_UNBLOCK, &nset, oset);
3797f56ba93Smillert } else if (oset != NULL)
3807f56ba93Smillert (void)sigprocmask(SIG_BLOCK, NULL, oset);
3817f56ba93Smillert
3827f56ba93Smillert return(error);
3837f56ba93Smillert }
3847f56ba93Smillert
3857f56ba93Smillert /*
386df930be7Sderaadt * Determine the size of the file possessed by
387df930be7Sderaadt * the passed buffer.
388df930be7Sderaadt */
389df930be7Sderaadt off_t
fsize(FILE * iob)3904a9caef2Smillert fsize(FILE *iob)
391df930be7Sderaadt {
392df930be7Sderaadt struct stat sbuf;
393df930be7Sderaadt
3943aaa63ebSderaadt if (fstat(fileno(iob), &sbuf) == -1)
395db59c1a6Smillert return(0);
396db59c1a6Smillert return(sbuf.st_size);
397df930be7Sderaadt }
398df930be7Sderaadt
399df930be7Sderaadt /*
400df930be7Sderaadt * Evaluate the string given as a new mailbox name.
401df930be7Sderaadt * Supported meta characters:
402df930be7Sderaadt * % for my system mail box
403df930be7Sderaadt * %user for user's system mail box
404df930be7Sderaadt * # for previous file
405df930be7Sderaadt * & invoker's mbox file
406df930be7Sderaadt * +file file in folder directory
407df930be7Sderaadt * any shell meta character
408df930be7Sderaadt * Return the file name as a dynamic string.
409df930be7Sderaadt */
410df930be7Sderaadt char *
expand(char * name)4114a9caef2Smillert expand(char *name)
412df930be7Sderaadt {
41332cc11aaSmillert const int flags = GLOB_BRACE|GLOB_TILDE|GLOB_NOSORT;
414df930be7Sderaadt char xname[PATHSIZE];
415df930be7Sderaadt char cmdbuf[PATHSIZE]; /* also used for file names */
41632cc11aaSmillert char *match = NULL;
41732cc11aaSmillert glob_t names;
418df930be7Sderaadt
419df930be7Sderaadt /*
420df930be7Sderaadt * The order of evaluation is "%" and "#" expand into constants.
421df930be7Sderaadt * "&" can expand into "+". "+" can expand into shell meta characters.
422df930be7Sderaadt * Shell meta characters expand into constants.
423df930be7Sderaadt * This way, we make no recursive expansion.
424df930be7Sderaadt */
425df930be7Sderaadt switch (*name) {
426df930be7Sderaadt case '%':
427db59c1a6Smillert findmail(name[1] ? name + 1 : myname, xname, sizeof(xname));
428db59c1a6Smillert return(savestr(xname));
429df930be7Sderaadt case '#':
430df930be7Sderaadt if (name[1] != 0)
431df930be7Sderaadt break;
432df930be7Sderaadt if (prevfile[0] == 0) {
433db59c1a6Smillert puts("No previous file");
434c318c72bSmillert return(NULL);
435df930be7Sderaadt }
436db59c1a6Smillert return(savestr(prevfile));
437df930be7Sderaadt case '&':
438c318c72bSmillert if (name[1] == 0 && (name = value("MBOX")) == NULL)
439df930be7Sderaadt name = "~/mbox";
440df930be7Sderaadt /* fall through */
441df930be7Sderaadt }
442db59c1a6Smillert if (name[0] == '+' && getfold(cmdbuf, sizeof(cmdbuf)) >= 0) {
4430ecc72fcSmillert (void)snprintf(xname, sizeof(xname), "%s/%s", cmdbuf, name + 1);
444df930be7Sderaadt name = savestr(xname);
445df930be7Sderaadt }
446df930be7Sderaadt /* catch the most common shell meta character */
4475c85bdadSmillert if (name[0] == '~' && homedir && (name[1] == '/' || name[1] == '\0')) {
4480ecc72fcSmillert (void)snprintf(xname, sizeof(xname), "%s%s", homedir, name + 1);
449df930be7Sderaadt name = savestr(xname);
450df930be7Sderaadt }
45132cc11aaSmillert if (strpbrk(name, "~{[*?\\") == NULL)
45232cc11aaSmillert return(savestr(name));
45332cc11aaSmillert
454*d9a51c35Sjmc /* XXX - does not expand environment variables. */
45532cc11aaSmillert switch (glob(name, flags, NULL, &names)) {
45632cc11aaSmillert case 0:
45732cc11aaSmillert if (names.gl_pathc == 1)
45832cc11aaSmillert match = savestr(names.gl_pathv[0]);
45932cc11aaSmillert else
460df930be7Sderaadt fprintf(stderr, "\"%s\": Ambiguous.\n", name);
46132cc11aaSmillert break;
46232cc11aaSmillert case GLOB_NOSPACE:
46332cc11aaSmillert fprintf(stderr, "\"%s\": Out of memory.\n", name);
46432cc11aaSmillert break;
46532cc11aaSmillert case GLOB_NOMATCH:
46632cc11aaSmillert fprintf(stderr, "\"%s\": No match.\n", name);
46732cc11aaSmillert break;
46832cc11aaSmillert default:
46932cc11aaSmillert fprintf(stderr, "\"%s\": Expansion failed.\n", name);
47032cc11aaSmillert break;
471df930be7Sderaadt }
47232cc11aaSmillert globfree(&names);
47332cc11aaSmillert return(match);
474df930be7Sderaadt }
475df930be7Sderaadt
476df930be7Sderaadt /*
477df930be7Sderaadt * Determine the current folder directory name.
478df930be7Sderaadt */
479df930be7Sderaadt int
getfold(char * name,int namelen)4804a9caef2Smillert getfold(char *name, int namelen)
481df930be7Sderaadt {
482df930be7Sderaadt char *folder;
483df930be7Sderaadt
484c318c72bSmillert if ((folder = value("folder")) == NULL)
485df930be7Sderaadt return(-1);
4864a9caef2Smillert if (*folder == '/')
4874a9caef2Smillert strlcpy(name, folder, namelen);
4884a9caef2Smillert else
4895c85bdadSmillert (void)snprintf(name, namelen, "%s/%s", homedir ? homedir : ".",
4905c85bdadSmillert folder);
491df930be7Sderaadt return(0);
492df930be7Sderaadt }
493df930be7Sderaadt
494df930be7Sderaadt /*
495df930be7Sderaadt * Return the name of the dead.letter file.
496df930be7Sderaadt */
497df930be7Sderaadt char *
getdeadletter(void)4984a9caef2Smillert getdeadletter(void)
499df930be7Sderaadt {
50036999bedSmillert char *cp;
501df930be7Sderaadt
502c318c72bSmillert if ((cp = value("DEAD")) == NULL || (cp = expand(cp)) == NULL)
503df930be7Sderaadt cp = expand("~/dead.letter");
504df930be7Sderaadt else if (*cp != '/') {
505df930be7Sderaadt char buf[PATHSIZE];
506df930be7Sderaadt
507db59c1a6Smillert (void)snprintf(buf, sizeof(buf), "~/%s", cp);
508df930be7Sderaadt cp = expand(buf);
509df930be7Sderaadt }
510db59c1a6Smillert return(cp);
511df930be7Sderaadt }
5127f56ba93Smillert
5137f56ba93Smillert /*
5147f56ba93Smillert * Signal handler used by readline() to catch SIGINT, SIGHUP, SIGTSTP,
5157f56ba93Smillert * SIGTTOU, SIGTTIN.
5167f56ba93Smillert */
5177f56ba93Smillert void
fioint(int s)5184a9caef2Smillert fioint(int s)
5197f56ba93Smillert {
5207f56ba93Smillert
5217f56ba93Smillert fiosignal = s;
5227f56ba93Smillert }
523