cmd/mailx/local.c

/***********************************************************************
*                                                                      *
*               This software is part of the BSD package               *
*Copyright (c) 1978-2012 The Regents of the University of California an*
*                                                                      *
* Redistribution and use in source and binary forms, with or           *
* without modification, are permitted provided that the following      *
* conditions are met:                                                  *
*                                                                      *
*    1. Redistributions of source code must retain the above           *
*       copyright notice, this list of conditions and the              *
*       following disclaimer.                                          *
*                                                                      *
*    2. Redistributions in binary form must reproduce the above        *
*       copyright notice, this list of conditions and the              *
*       following disclaimer in the documentation and/or other         *
*       materials provided with the distribution.                      *
*                                                                      *
*    3. Neither the name of The Regents of the University of California*
*       names of its contributors may be used to endorse or            *
*       promote products derived from this software without            *
*       specific prior written permission.                             *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND               *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,          *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF             *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE             *
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS    *
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,             *
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED      *
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,        *
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    *
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,      *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY       *
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE              *
* POSSIBILITY OF SUCH DAMAGE.                                          *
*                                                                      *
* Redistribution and use in source and binary forms, with or without   *
* modification, are permitted provided that the following conditions   *
* are met:                                                             *
* 1. Redistributions of source code must retain the above copyright    *
*    notice, this list of conditions and the following disclaimer.     *
* 2. Redistributions in binary form must reproduce the above copyright *
*    notice, this list of conditions and the following disclaimer in   *
*    the documentation and/or other materials provided with the        *
*    distribution.                                                     *
* 3. Neither the name of the University nor the names of its           *
*    contributors may be used to endorse or promote products derived   *
*    from this software without specific prior written permission.     *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS"    *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED    *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A      *
* PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS    *
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,      *
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT     *
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF     *
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND  *
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,   *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT   *
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   *
* SUCH DAMAGE.                                                         *
*                                                                      *
*                          Kurt Shoens (UCB)                           *
*                                 gsf                                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Mail -- a mail program
 *
 * Local installation dependent routines.
 */

#include "mailx.h"

#include <pwd.h>

#if _PACKAGE_ast
#include <tm.h>
#endif

/*
 * Locate the user's mailbox file (ie, the place where new, unread
 * mail is queued).
 */
char*
mailbox(const char* user, const char* mail)
{
    register char*      s;
    register int        i;
    int         n = 0;
    struct stat     st;

    static const char*  dir[] = {
        _PATH_MAILDIR,
        "/var/spool/mail",
        "/usr/spool/mail",
        "/usr/mail"
    };

    if (!user || !*user || !stat(mail, &st) && S_ISREG(st.st_mode))
        return (char*)mail;
    if (mail) {
        if (imap_name(mail))
            return (char*)mail;
        if (s = strrchr(mail, '/')) {
            i = s - (char*)mail;
            sfprintf(state.path.temp, "%-.*s/.", i, mail);
            if (!access(struse(state.path.temp), F_OK))
                n = i;
        }
    }
    if (n == 0) {
        for (i = 0;; i++) {
            if (i >= elementsof(dir)) {
                i = 0;
                break;
            }
            sfprintf(state.path.temp, "%s/.", dir[i]);
            if (!access(struse(state.path.temp), F_OK))
                break;
        }
        mail = dir[i];
        if ((n = strlen(mail)) > 0 && mail[n - 1] == '/')
            n--;
    }
    sfprintf(state.path.temp, "%-.*s/%s", n, mail, user);
    return savestr(struse(state.path.temp));
}

/*
 * Get rid of the queued mail.
 */
void
demail(void)
{
    if (state.var.keep || rm(state.path.mail) < 0)
        close(open(state.path.mail, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY|O_cloexec, MAILMODE));
}

/*
 * Discover user login name.
 */
char*
username(void)
{
    register char*  s;
    register char*  t;
    struct passwd*  pw;

    if ((!(s = getenv("USER")) || !*s) &&
        (!(s = getenv("LOGIN")) || !*s) &&
        (pw = getpwuid(getuid())))
        s = pw->pw_name;
    if (s)
    {
        if (t = strrchr(s, '/'))
            s = t + 1;
        if (!*s)
            s = 0;
    }
    return s;
}

/*
 * Convert name to a user id and return it.
 * Mapping cached in state.userid.
 * Return -1 on error.
 */
int
userid(char* name)
{
    register struct name*   up;
    register struct passwd* pw;

    up = dictsearch(&state.userid, name, INSERT);
    if (!up->value)
        up->flags = (pw = getpwnam(name)) ? pw->pw_uid : -1;
    return up->flags;
}

/*
 * Make sure the lock doesn't hang -- NFS anyone?
 */
static void
alarmed(int sig)
{
    signal(sig, SIG_IGN);
    state.hung = 1;
}

/*
 * Lock (set!=0) or unlock (set==0) open file fp.
 */
int
filelock(const char* name, FILE* fp, int set)
{
#if defined(F_SETLKW) && defined(F_WRLCK) && defined(F_UNLCK) || defined(LOCK_EX) && defined(LOCK_UN)
    int r;
    sig_t   savealrm;

    if (state.var.lock)
    {
        state.hung = 0;
        savealrm = signal(SIGALRM, alarmed);
        if (!(r = strtol(state.var.lock, NiL, 10)))
            r = 5;
        alarm(r);
#if defined(F_SETLKW) && defined(F_WRLCK) && defined(F_UNLCK)
        {
            struct flock    lck;

            lck.l_type = set ? F_WRLCK : F_UNLCK;
            lck.l_whence = SEEK_SET;
            lck.l_start = 0;
            lck.l_len = 0;
            r = fcntl(fileno(fp), F_SETLKW, &lck);
        }
#else
        r = flock(fileno(fp), set ? LOCK_EX : LOCK_UN);
#endif
        alarm(0);
        signal(SIGALRM, savealrm);
        if (state.hung)
            note(0, "%s: file lock hung -- continuing without lock", name);
        else if (r)
            note(SYSTEM, "%s: continuing without lock", name);
    }
#endif
    return 0;
}

#if _PACKAGE_ast

/*
 * Compute what the screen size for printing headers should be.
 */

void
setscreensize(void)
{
    astwinsize(1, &state.realscreenheight, &state.screenwidth);
    if (!state.realscreenheight)
        state.realscreenheight = 24;
    state.screenheight = state.realscreenheight;
    if (!state.screenwidth)
        state.screenwidth = 80;
}

/*
 * check if date is valid with no trailing junk
 */

int
isdate(char* s)
{
    char*   t;

    (void)tmdate(s, &t, NiL);
    return *t == 0 && strmatch(s, "*[a-zA-Z]*[0-9]:[0-9]*");
}

#else /*_PACKAGE_ast*/

#include <termios.h>

#define CHUNK   32

char*
fmtesc(const char* as)
{
    register unsigned char* s = (unsigned char*)as;
    register char*      b;
    register int        c;

    static char*        buf;
    static int      bufsiz;

    c = 4 * (strlen((char*)s) + 1);
    if (bufsiz < c)
    {
        bufsiz = ((c + CHUNK - 1) / CHUNK) * CHUNK;
        if (!(buf = newof(buf, char, bufsiz, 0)))
            return 0;
    }
    b = buf;
    while (c = *s++)
    {
        if (iscntrl(c) || !isprint(c))
        {
            *b++ = '\\';
            switch (c)
            {
            case '\007':
                c = 'a';
                break;
            case '\b':
                c = 'b';
                break;
            case '\f':
                c = 'f';
                break;
            case '\n':
                c = 'n';
                break;
            case '\r':
                c = 'r';
                break;
            case '\t':
                c = 't';
                break;
            case '\v':
                c = 'v';
                break;
            case '\033':
                c = 'E';
                break;
            default:
                *b++ = '0' + ((c >> 6) & 07);
                *b++ = '0' + ((c >> 3) & 07);
                c = '0' + (c & 07);
                break;
            }
        }
        *b++ = c;
    }
    *b = 0;
    return buf;
}

#define IDENT   01
#define USAGE   02

/*
 * format what(1) and/or ident(1) string a
 */

char*
fmtident(const char* a)
{
    register char*  s = (char*)a;
    register char*  t;
    char*       buf;
    int     i;

    i = 0;
    for (;;)
    {
        while (isspace(*s))
            s++;
        if (s[0] == '[')
        {
            while (*++s && *s != '\n');
            i |= USAGE;
        }
        else if (s[0] == '@' && s[1] == '(' && s[2] == '#' && s[3] == ')')
            s += 4;
        else if (s[0] == '$' && s[1] == 'I' && s[2] == 'd' && s[3] == ':' && isspace(s[4]))
        {
            s += 5;
            i |= IDENT;
        }
        else
            break;
    }
    if (i)
    {
        i &= IDENT;
        for (t = s; isprint(*t) && *t != '\n'; t++)
            if (i && t[0] == ' ' && t[1] == '$')
                break;
        while (t > s && isspace(t[-1]))
            t--;
        i = t - s;
        if (!(buf = newof(buf, char, i, i)))
            return s;
        memcpy(buf, s, i);
        s = buf;
        s[i] = 0;
    }
    return s;
}

/*
 * return the current shell path
 */

char*
pathshell(void)
{
    char*   shell;

    if (!(shell = state.var.shell) || !*shell)
        shell = _PATH_SHELL;
    return shell;
}

/*
 * Compute what the screen size for printing headers should be.
 * We use the following algorithm for the height:
 *  If baud rate < 1200, use  9
 *  If baud rate = 1200, use 14
 *  If baud rate > 1200, use 24 or ws_row
 * Width is either 80 or ws_col;
 */

void
setscreensize(void)
{
    struct termios  tbuf;
    struct winsize  ws;
    int     speed;

    if (ioctl(1, TIOCGWINSZ, (char*)&ws) < 0)
        ws.ws_col = ws.ws_row = 0;
    if (tcgetattr(1, &tbuf) < 0)
        speed = B9600;
    else
        speed = cfgetospeed(&tbuf);
    if (speed < B1200)
        state.screenheight = 9;
    else if (speed == B1200)
        state.screenheight = 14;
    else if (ws.ws_row)
        state.screenheight = ws.ws_row;
    else
        state.screenheight = 24;
    if (!(state.realscreenheight = ws.ws_row))
        state.realscreenheight = 24;
    if (!(state.screenwidth = ws.ws_col))
        state.screenwidth = 80;
}

/*
 * signal critical region support
 */

static const struct
{
    int sig;
    int op;
}
signals[] =     /* held inside critical region  */
{
    SIGINT,     SIG_REG_EXEC,
#ifdef SIGQUIT
    SIGQUIT,    SIG_REG_EXEC,
#endif
#ifdef SIGHUP
    SIGHUP,     SIG_REG_EXEC,
#endif
#ifdef SIGPIPE
    SIGPIPE,    SIG_REG_EXEC,
#endif
#ifdef SIGCLD
    SIGCLD,     SIG_REG_PROC,
#endif
#ifdef SIGCHLD
    SIGCHLD,    SIG_REG_PROC,
#endif
#ifdef SIGTSTP
    SIGTSTP,    SIG_REG_TERM,
#endif
#ifdef SIGTTIN
    SIGTTIN,    SIG_REG_TERM,
#endif
#ifdef SIGTTOU
    SIGTTOU,    SIG_REG_TERM,
#endif
};

/*
 * critical signal region handler
 *
 * op>0     new region according to SIG_REG_*, return region level
 * op==0    pop region, return region level
 * op<0     return non-zero if any signals held in current region
 *
 * signals[] held until region popped
 */

int
sigcritical(int op)
{
    register int        i;
    sigset_t        nmask;

    static int      region;
    static int      level;
    static sigset_t     mask;

    if (op > 0)
    {
        if (!level++)
        {
            region = op;
            if (op & SIG_REG_SET)
                level--;
            sigemptyset(&nmask);
            for (i = 0; i < elementsof(signals); i++)
                if (op & signals[i].op)
                    sigaddset(&nmask, signals[i].sig);
            sigprocmask(SIG_BLOCK, &nmask, &mask);
        }
        return level;
    }
    else if (op < 0)
    {
        sigpending(&nmask);
        for (i = 0; i < elementsof(signals); i++)
            if (region & signals[i].op)
            {
                if (sigismember(&nmask, signals[i].sig))
                    return 1;
            }
        return 0;
    }
    else
    {
        /*
         * a vfork() may have intervened so we
         * allow apparent nesting mismatches
         */

        if (--level < 0)
        {
            level = 0;
            sigprocmask(SIG_SETMASK, &mask, NiL);
        }
        return level;
    }
}

/*
 * remove sig from the set of blocked signals
 * sig==0 unblocks them all
 */

int
sigunblock(int sig)
{
    int     op;
    sigset_t    mask;

    sigemptyset(&mask);
    if (sig)
    {
        sigaddset(&mask, sig);
        op = SIG_UNBLOCK;
    }
    else op = SIG_SETMASK;
    return sigprocmask(op, &mask, NiL);
}

/*
 * fork+execvp
 */

int
spawnvp(const char* cmd, char* const* argv)
{
    int pid;

    sigcritical(1);
    if ((pid = fork()) < 0)
    {
        note(SYSTEM, "fork");
        return -1;
    }
    sigcritical(0);
    if (pid == 0)
    {
        execvp(cmd, argv);
        note(SYSTEM, "%s", cmd);
        _exit(1);
    }
    return pid;
}

/*
 * return the next character in the string s
 * \ character constants are converted
 * p is updated to point to the next character in s
 */

int
chresc(register const char* s, char** p)
{
    register const char*    q;
    register int        c;

    switch (c = *s++)
    {
    case 0:
        s--;
        break;
    case '\\':
        switch (c = *s++)
        {
        case '0': case '1': case '2': case '3':
        case '4': case '5': case '6': case '7':
            c -= '0';
            q = s + 2;
            while (s < q) switch (*s)
            {
            case '0': case '1': case '2': case '3':
            case '4': case '5': case '6': case '7':
                c = (c << 3) + *s++ - '0';
                break;
            default:
                q = s;
                break;
            }
            break;
        case 'a':
            c = '\007';
            break;
        case 'b':
            c = '\b';
            break;
        case 'f':
            c = '\f';
            break;
        case 'n':
            c = '\n';
            break;
        case 'r':
            c = '\r';
            break;
        case 's':
            c = ' ';
            break;
        case 't':
            c = '\t';
            break;
        case 'v':
            c = '\013';
            break;
        case 'x':
            c = 0;
            q = s;
            while (q) switch (*s)
            {
            case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                c = (c << 4) + *s++ - 'a' + 10;
                break;
            case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                c = (c << 4) + *s++ - 'A' + 10;
                break;
            case '0': case '1': case '2': case '3': case '4':
            case '5': case '6': case '7': case '8': case '9':
                c = (c << 4) + *s++ - '0';
                break;
            default:
                q = 0;
                break;
            }
            break;
        case 'E':
            c = '\033';
            break;
        case 0:
            s--;
            break;
        }
        break;
    }
    if (p) *p = (char*)s;
    return c;
}

/*
 * copy t into s, return a pointer to the end of s ('\0')
 */

char*
strcopy(register char* s, register const char* t)
{
    if (!t)
        return s;
    while (*s++ = *t++);
    return s - 1;
}

/*
 * convert \x character constants in s in place
 * the length of the converted s is returned (may have imbedded \0's)
 */

int
stresc(register char* s)
{
    register char*  t;
    register int    c;
    char*       b;
    char*       p;

    b = t = s;
    for (;;)
    {
        switch (c = *s++)
        {
        case '\\':
            c = chresc(s - 1, &p);
            s = p;
            break;
        case 0:
            *t = 0;
            return t - b;
        }
        *t++ = c;
    }
}

/*
 * return a pointer to the isalpha() identifier matching
 * name in the sorted tab of num elements of
 * size siz where the first member of each
 * element is a char*
 *
 * [xxx] brackets optional identifier characters
 *
 * 0 returned if name not found
 * otherwise if next!=0 then it points to the next
 * unmatched char in name
 */

void*
strpsearch(const void* tab, size_t num, size_t siz, const char* name, char** next)
{
    register char*      lo = (char*)tab;
    register char*      hi = lo + (num - 1) * siz;
    register char*      mid;
    register unsigned char* s;
    register unsigned char* t;
    register int        c;
    register int        v;
    int         sequential = 0;

    c = *((unsigned char*)name);
    while (lo <= hi) {
        mid = lo + (sequential ? 0 : (((hi - lo) / siz) / 2) * siz);
        if (!(v = c - *(s = *((unsigned char**)mid))) || *s == '[' && !(v = c - *++s) && (v = 1)) {
            t = (unsigned char*)name;
            for (;;) {
                if (!v && *s == '[') {
                    v = 1;
                    s++;
                }
                else if (v && *s == ']') {
                    v = 0;
                    s++;
                }
                else if (!isalpha(*t)) {
                    if (v || !*s) {
                        if (next)
                            *next = (char*)t;
                        return (void*)mid;
                    }
                    if (!sequential) {
                        while ((mid -= siz) >= lo && (c == *(s = *((unsigned char**)mid)) || *s == '[' && c == *(s + 1)));
                        sequential = 1;
                    }
                    v = 1;
                    break;
                }
                else if (*t != *s) {
                    v = *t - *s;
                    break;
                }
                else {
                    t++;
                    s++;
                }
            }
        }
        else if (sequential)
            break;
        if (v > 0)
            lo = mid + siz;
        else
            hi = mid - siz;
    }
    return 0;
}

typedef int (*Compare_f)(const char*, const char*);
typedef int (*Compare_context_f)(const char*, const char*, void*);

/*
 * return a pointer to the element matching
 * name in the (*comparf*)() sorted tab of num elements of
 * size siz where the first member of each
 * element is a char*
 *
 * 0 returned if name not found
 */

void*
strsearch(const void* tab, size_t num, size_t siz, Compare_f comparf, const char* name, void* context)
{
    register char*      lo = (char*)tab;
    register char*      hi = lo + (num - 1) * siz;
    register char*      mid;
    register int        v;

    while (lo <= hi)
    {
        mid = lo + (((hi - lo) / siz) / 2) * siz;
        if (!(v = context ? (*(Compare_context_f)comparf)(name, *((char**)mid), context) : (*(Compare_f)comparf)(name, *((char**)mid))))
            return (void*)mid;
        else if (v > 0)
            lo = mid + siz;
        else hi = mid - siz;
    }
    return 0;
}

/*
 * touch file access and modify times of file
 * if force>0 then file will be created if it doesn't exist
 * if force<0 then times are taken verbatim
 * times have one second granularity
 *
 *  (time_t)(-1)    retain old time
 *  0       use current time
 */

int
touch(const char* file, time_t atime, time_t mtime, int force)
{
    struct stat st;
    struct timeval  tv[2];
    time_t      now;

    now = time(NiL);
    if (stat(file, &st))
    {
        if (!force || close(open(file, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY|O_cloexec, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)))
            return -1;
        st.st_mtime = st.st_atime = now;
    }
    if (force >= 0)
    {
        if (atime == (time_t)0)
            atime = now;
        else if (atime == (time_t)(-1))
            atime = st.st_atime;
        if (mtime == (time_t)0)
            mtime = now;
        else if (mtime == (time_t)(-1))
            mtime = st.st_mtime;
    }
    tv[0].tv_sec = atime;
    tv[1].tv_sec = mtime;
    tv[0].tv_usec = tv[1].tv_usec = 0;
    return utimes(file, tv);
}

/*
 * check if date is valid with no trailing junk
 */

int
isdate(const char* s)
{
    return 1;
}

#endif /*_PACKAGE_ast*/