/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


/*
 * Copyright 1985-2002 Sun Microsystems, Inc. All rights reserved.
 * Use is subject to license terms.
 */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

#include "rcv.h"
#include <locale.h>

/*
 * mailx -- a modified version of a University of California at Berkeley
 *      mail program
 *
 * Auxiliary functions.
 */

static char     *phrase(char *name, int token, int comma);
static char     *ripoff(register char *buf);

/*
 * Return a pointer to a dynamic copy of the argument.
 */

char *
savestr(char *str)
{
        register char *cp, *cp2, *top;

        for (cp = str; *cp; cp++)
                ;
        top = (char *)salloc((unsigned)(cp-str + 1));
        if (top == NOSTR)
                return(NOSTR);
        for (cp = str, cp2 = top; *cp; cp++)
                *cp2++ = *cp;
        *cp2 = 0;
        return(top);
}

/*
 * Announce a fatal error and die.
 */

void
panic(char *str)
{
        fprintf(stderr, gettext("mailx: Panic - %s\n"), str);
        exit(1);
        /* NOTREACHED */
}

/*
 * Touch the named message by setting its MTOUCH flag.
 * Touched messages have the effect of not being sent
 * back to the system mailbox on exit.
 */

void
touch(int mesg)
{
        register struct message *mp;

        if (mesg < 1 || mesg > msgCount)
                return;
        mp = &message[mesg-1];
        mp->m_flag |= MTOUCH;
        if ((mp->m_flag & MREAD) == 0)
                mp->m_flag |= MREAD|MSTATUS;
}

/*
 * Test to see if the passed file name is a directory.
 * Return true if it is.
 */

int
isdir(char name[])
{
        struct stat sbuf;

        if (stat(name, &sbuf) < 0)
                return(0);
        return((sbuf.st_mode & S_IFMT) == S_IFDIR);
}

/*
 * Count the number of arguments in the given string raw list.
 */

int
argcount(char **argv)
{
        register char **ap;

        for (ap = argv; *ap != NOSTR; ap++)
                ;
        return(ap-argv);
}

/*
 * Return the desired header line from the passed message
 * pointer (or NOSTR if the desired header field is not available).
 * Read all the header lines and concatenate multiple instances of
 * the requested header.
 */

char *
hfield(char field[], struct message *mp, char *(*add)(char *, char *))
{
        register FILE *ibuf;
        char linebuf[LINESIZE];
        register long lc;
        char *r = NOSTR;

        ibuf = setinput(mp);
        if ((lc = mp->m_lines) <= 0)
                return(NOSTR);
        if (readline(ibuf, linebuf) < 0)
                return(NOSTR);
        lc--;
        while ((lc = gethfield(ibuf, linebuf, lc)) >= 0)
                if (ishfield(linebuf, field))
                        r = (*add)(r, hcontents(linebuf));
        return r;
}

/*
 * Return the next header field found in the given message.
 * Return > 0 if something found, <= 0 elsewise.
 * Must deal with \ continuations & other such fraud.
 */

int
gethfield(
        register FILE *f,
        char linebuf[],
        register long rem)
{
        char line2[LINESIZE];
        register char *cp, *cp2;
        register int c;

        for (;;) {
                if (rem <= 0)
                        return(-1);
                if (readline(f, linebuf) < 0)
                        return(-1);
                rem--;
                if (strlen(linebuf) == 0)
                        return(-1);
                if (isspace(linebuf[0]))
                        continue;
                if (!headerp(linebuf))
                        return(-1);

                /*
                 * I guess we got a headline.
                 * Handle wraparounding
                 */

                for (;;) {
                        if (rem <= 0)
                                break;
                        c = getc(f);
                        ungetc(c, f);
                        if (!isspace(c) || c == '\n')
                                break;
                        if (readline(f, line2) < 0)
                                break;
                        rem--;
                        cp2 = line2;
                        for (cp2 = line2; *cp2 != 0 && isspace(*cp2); cp2++)
                                ;
                        if (strlen(linebuf) + strlen(cp2) >=
                            (unsigned)LINESIZE-2)
                                break;
                        cp = &linebuf[strlen(linebuf)];
                        while (cp > linebuf &&
                            (isspace(cp[-1]) || cp[-1] == '\\'))
                                cp--;
                        *cp++ = ' ';
                        for (cp2 = line2; *cp2 != 0 && isspace(*cp2); cp2++)
                                ;
                        nstrcpy(cp, LINESIZE - (cp - linebuf), cp2);
                }
                if ((c = strlen(linebuf)) > 0) {
                        cp = &linebuf[c-1];
                        while (cp > linebuf && isspace(*cp))
                                cp--;
                        *++cp = 0;
                }
                return(rem);
        }
        /* NOTREACHED */
}

/*
 * Check whether the passed line is a header line of
 * the desired breed.
 */

int
ishfield(char linebuf[], char field[])
{
        register char *cp;

        if ((cp = strchr(linebuf, ':')) == NOSTR)
                return(0);
        if (cp == linebuf)
                return(0);
        *cp = 0;
        if (icequal(linebuf, field)) {
                *cp = ':';
                return(1);
        }
        *cp = ':';
        return(0);
}

/*
 * Extract the non label information from the given header field
 * and return it.
 */

char *
hcontents(char hfield[])
{
        register char *cp;

        if ((cp = strchr(hfield, ':')) == NOSTR)
                return(NOSTR);
        cp++;
        while (*cp && isspace(*cp))
                cp++;
        return(cp);
}

/*
 * Compare two strings, ignoring case.
 */

int
icequal(register char *s1, register char *s2)
{

        while (toupper(*s1++) == toupper(*s2))
                if (*s2++ == 0)
                        return(1);
        return(0);
}

/*
 * Copy a string, lowercasing it as we go. Here dstsize is the size of
 * the destination buffer dst.
 */
void
istrcpy(char *dst, int dstsize, char *src)
{
        register char *cp, *cp2;

        cp2 = dst;
        cp = src;

        while (--dstsize > 0 && *cp != '\0')
                *cp2++ = tolower(*cp++);
        *cp2 = '\0';
}

/*
 * The following code deals with input stacking to do source
 * commands.  All but the current file pointer are saved on
 * the stack.
 */

static  int     ssp = -1;               /* Top of file stack */
static struct sstack {
        FILE    *s_file;                /* File we were in. */
        int     s_cond;                 /* Saved state of conditionals */
        int     s_loading;              /* Loading .mailrc, etc. */
} *sstack;

/*
 * Pushdown current input file and switch to a new one.
 * Set the global flag "sourcing" so that others will realize
 * that they are no longer reading from a tty (in all probability).
 */

int
source(char name[])
{
        register FILE *fi;
        register char *cp;

        if ((cp = expand(name)) == NOSTR)
                return(1);
        if ((fi = fopen(cp, "r")) == NULL) {
                printf(gettext("Unable to open %s\n"), cp);
                return(1);
        }

        if (!maxfiles) {
                if ((maxfiles = (int)ulimit(4, 0)) < 0)
#ifndef _NFILE
# define _NFILE 20
#endif
                        maxfiles = _NFILE;
                sstack = (struct sstack *)calloc(maxfiles, sizeof(struct sstack));
                if (sstack == NULL) {
                        printf(gettext(
                            "Couldn't allocate memory for sourcing stack\n"));
                        fclose(fi);
                        return(1);
                }
        }

        sstack[++ssp].s_file = input;
        sstack[ssp].s_cond = cond;
        sstack[ssp].s_loading = loading;
        loading = 0;
        cond = CANY;
        input = fi;
        sourcing++;
        return(0);
}

/*
 * Pop the current input back to the previous level.
 * Update the "sourcing" flag as appropriate.
 */

int
unstack(void)
{
        if (ssp < 0) {
                printf(gettext("\"Source\" stack over-pop.\n"));
                sourcing = 0;
                return(1);
        }
        fclose(input);
        if (cond != CANY)
                printf(gettext("Unmatched \"if\"\n"));
        cond = sstack[ssp].s_cond;
        loading = sstack[ssp].s_loading;
        input = sstack[ssp--].s_file;
        if (ssp < 0)
                sourcing = loading;
        return(0);
}

/*
 * Touch the indicated file.
 * This is nifty for the shell.
 * If we have the utime() system call, this is better served
 * by using that, since it will work for empty files.
 * On non-utime systems, we must sleep a second, then read.
 */

void
alter(char name[])
{
        int rc = utime(name, utimep);
        extern int errno;

        if (rc != 0) {
                fprintf(stderr, gettext("Cannot utime %s in aux:alter\n"),
name);
                fprintf(stderr, gettext("Errno: %d\n"), errno);
        }
}

/*
 * Examine the passed line buffer and
 * return true if it is all blanks and tabs.
 */

int
blankline(const char linebuf[])
{
        register const char *cp;

        for (cp = linebuf; *cp; cp++)
                if (!any(*cp, " \t"))
                        return(0);
        return(1);
}

/*
 * Skin an arpa net address according to the RFC 822 interpretation
 * of "host-phrase."
 */
static char *
phrase(char *name, int token, int comma)
{
        register char c;
        register char *cp, *cp2;
        char *bufend, *nbufp;
        int gotlt, lastsp, didq;
        char nbuf[LINESIZE];
        int nesting;

        if (name == NOSTR)
                return(NOSTR);
        if (strlen(name) >= (unsigned)LINESIZE)
                nbufp = (char *)salloc(strlen(name));
        else
                nbufp = nbuf;
        gotlt = 0;
        lastsp = 0;
        bufend = nbufp;
        for (cp = name, cp2 = bufend; (c = *cp++) != 0;) {
                switch (c) {
                case '(':
                        /*
                                Start of a comment, ignore it.
                        */
                        nesting = 1;
                        while ((c = *cp) != 0) {
                                cp++;
                                switch(c) {
                                case '\\':
                                        if (*cp == 0) goto outcm;
                                        cp++;
                                        break;
                                case '(':
                                        nesting++;
                                        break;
                                case ')':
                                        --nesting;
                                        break;
                                }
                                if (nesting <= 0) break;
                        }
                outcm:
                        lastsp = 0;
                        break;
                case '"':
                        /*
                                Start a quoted string.
                                Copy it in its entirety.
                        */
                        didq = 0;
                        while ((c = *cp) != 0) {
                                cp++;
                                switch (c) {
                                case '\\':
                                        if ((c = *cp) == 0) goto outqs;
                                        cp++;
                                        break;
                                case '"':
                                        goto outqs;
                                }
                                if (gotlt == 0 || gotlt == '<') {
                                        if (lastsp) {
                                                lastsp = 0;
                                                *cp2++ = ' ';
                                        }
                                        if (!didq) {
                                                *cp2++ = '"';
                                                didq++;
                                        }
                                        *cp2++ = c;
                                }
                        }
                outqs:
                        if (didq)
                                *cp2++ = '"';
                        lastsp = 0;
                        break;

                case ' ':
                case '\t':
                case '\n':
                        if (token && (!comma || c == '\n')) {
                        done:
                                cp[-1] = 0;
                                return cp;
                        }
                        lastsp = 1;
                        break;

                case ',':
                        *cp2++ = c;
                        if (gotlt != '<') {
                                if (token)
                                        goto done;
                                bufend = cp2;
                                gotlt = 0;
                        }
                        break;

                case '<':
                        cp2 = bufend;
                        gotlt = c;
                        lastsp = 0;
                        break;

                case '>':
                        if (gotlt == '<') {
                                gotlt = c;
                                break;
                        }

                        /* FALLTHROUGH . . . */

                default:
                        if (gotlt == 0 || gotlt == '<') {
                                if (lastsp) {
                                        lastsp = 0;
                                        *cp2++ = ' ';
                                }
                                *cp2++ = c;
                        }
                        break;
                }
        }
        *cp2 = 0;
        return (token ? --cp : equal(name, nbufp) ? name :
            nbufp == nbuf ? savestr(nbuf) : nbufp);
}

char *
skin(char *name)
{
        return phrase(name, 0, 0);
}

/*
 * Here sz is the buffer size of word.
 */
char *
yankword(char *name, char *word, int sz, int comma)
{
        char *cp;

        if (name == 0)
                return 0;
        while (isspace(*name))
                name++;
        if (*name == 0)
                return 0;
        cp = phrase(name, 1, comma);
        nstrcpy(word, sz, name);
        return cp;
}

int
docomma(char *s)
{
        return s && strpbrk(s, "(<,");
}

/*
 * Fetch the sender's name from the passed message.
 */

char *
nameof(register struct message *mp)
{
        char namebuf[LINESIZE];
        char linebuf[LINESIZE];
        register char *cp, *cp2;
        register FILE *ibuf;
        int first = 1, wint = 0;
        char    *tmp;

        if (value("from") && (cp = hfield("from", mp, addto)) != NOSTR)
                return ripoff(cp);
        ibuf = setinput(mp);
        copy("", namebuf);
        if (readline(ibuf, linebuf) <= 0)
                return(savestr(namebuf));
newname:
        for (cp = linebuf; *cp != ' '; cp++)
                ;
        while (any(*cp, " \t"))
                cp++;
        for (cp2 = &namebuf[strlen(namebuf)]; *cp && !any(*cp, " \t") &&
            cp2-namebuf < LINESIZE-1; *cp2++ = *cp++)
                ;
        *cp2 = '\0';
        for (;;) {
                if (readline(ibuf, linebuf) <= 0)
                        break;
                if (substr(linebuf,"forwarded by ") != -1)
                        continue;
                if (linebuf[0] == 'F')
                        cp = linebuf;
                else if (linebuf[0] == '>')
                        cp = linebuf + 1;
                else
                        break;
                if (strncmp(cp, "From ", 5) != 0)
                        break;
                if ((wint = substr(cp, "remote from ")) != -1) {
                        cp += wint + 12;
                        if (first) {
                                copy(cp, namebuf);
                                first = 0;
                        } else {
                                tmp = strrchr(namebuf, '!') + 1;
                                nstrcpy(tmp,
                                        sizeof (namebuf) - (tmp  - namebuf),
                                        cp);
                        }
                        nstrcat(namebuf, sizeof (namebuf), "!");
                        goto newname;
                } else
                        break;
        }
        for (cp = namebuf; *cp == '!'; cp++);
        while (ishost(host, cp))
                cp = strchr(cp, '!') + 1;
        if (value("mustbang") && !strchr(cp, '!')) {
                snprintf(linebuf, sizeof (linebuf), "%s!%s",
                        host, cp);
                cp = linebuf;
        }
        if (cp2 = hfield("from", mp, addto))
                return(splice(cp, cp2));
        else
                return(savestr(cp));
}

/*
 * Splice an address into a commented recipient header.
 */
char *
splice(char *addr, char *hdr)
{
        char buf[LINESIZE];
        char *cp, *cp2;

        if (cp = strchr(hdr, '<')) {
                cp2 = strchr(cp, '>');
                if (cp2 == NULL) {
                        nstrcpy(buf, sizeof (buf), addr);
                } else {
                        snprintf(buf, sizeof (buf), "%.*s%s%s",
                                cp - hdr + 1, hdr, addr, cp2);
                }
        } else if (cp = strchr(hdr, '(')) {
                snprintf(buf, sizeof (buf), "%s %s",
                        addr, cp);
        } else
                nstrcpy(buf, sizeof (buf), addr);
        return savestr(ripoff(buf));
}

static char *
ripoff(register char *buf)
{
        register char *cp;

        cp = buf + strlen(buf);
        while (--cp >= buf && isspace(*cp));
        if (cp >= buf && *cp == ',')
                cp--;
        *++cp = 0;
        return buf;
}

/*
 * Are any of the characters in the two strings the same?
 */

int
anyof(register char *s1, register char *s2)
{
        register int c;

        while ((c = *s1++) != 0)
                if (any(c, s2))
                        return(1);
        return(0);
}

/*
 * See if the given header field is supposed to be ignored.
 * Fields of the form "Content-*" can't be ignored when saving.
 */
int
isign(char *field, int saving)
{
        char realfld[BUFSIZ];

        /*
         * Lower-case the string, so that "Status" and "status"
         * will hash to the same place.
         */
        istrcpy(realfld, sizeof (realfld), field);

        if (saving && strncmp(realfld, "content-", 8) == 0)
                return (0);

        if (nretained > 0)
                return (!member(realfld, retain));
        else
                return (member(realfld, ignore));
}

int
member(register char *realfield, register struct ignore **table)
{
        register struct ignore *igp;

        for (igp = table[hash(realfield)]; igp != 0; igp = igp->i_link)
                if (equal(igp->i_field, realfield))
                        return (1);

        return (0);
}

/*
 * This routine looks for string2 in string1.
 * If found, it returns the position string2 is found at,
 * otherwise it returns a -1.
 */
int
substr(char *string1, char *string2)
{
        int i, j, len1, len2;

        len1 = strlen(string1);
        len2 = strlen(string2);
        for (i = 0; i < len1 - len2 + 1; i++) {
                for (j = 0; j < len2 && string1[i+j] == string2[j]; j++)
                        ;
                if (j == len2)
                        return(i);
        }
        return(-1);
}

/*
 * Copies src to the dstsize buffer at dst. The copy will never
 * overflow the destination buffer and the buffer will always be null
 * terminated.
 */
char *
nstrcpy(char *dst, int dstsize, char *src)
{
        char *cp, *cp2;

        cp2 = dst;
        cp = src;

        while (--dstsize > 0 && *cp != '\0')
                *cp2++ = *cp++;
        *cp2 = '\0';
        return(dst);
}

/*
 * Appends src to the dstsize buffer at dst. The append will never
 * overflow the destination buffer and the buffer will always be null
 * terminated.
 */
char *
nstrcat(char *dst, int dstsize, char *src)
{
        char *cp, *cp2;

        cp2 = dst;
        cp = src;

        while (*cp2 != '\0') {
                cp2++;
                dstsize--;
        }
        while (--dstsize > 0 && *cp != '\0')
                *cp2++ = *cp++;
        *cp2 = '\0';
        return(dst);
}