From 9b50d9027575220cb6dd09b3e62f03f511e908b8 Mon Sep 17 00:00:00 2001 From: "Rodney W. Grimes" Date: Fri, 27 May 1994 12:33:43 +0000 Subject: BSD 4.4 Lite Usr.bin Sources --- usr.bin/mail/list.c | 801 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 801 insertions(+) create mode 100644 usr.bin/mail/list.c (limited to 'usr.bin/mail/list.c') diff --git a/usr.bin/mail/list.c b/usr.bin/mail/list.c new file mode 100644 index 000000000000..18cf1eb6d11e --- /dev/null +++ b/usr.bin/mail/list.c @@ -0,0 +1,801 @@ +/* + * Copyright (c) 1980, 1993 + * The Regents of the University of California. All rights reserved. + * + * 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. 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. + */ + +#ifndef lint +static char sccsid[] = "@(#)list.c 8.2 (Berkeley) 4/19/94"; +#endif /* not lint */ + +#include "rcv.h" +#include +#include "extern.h" + +/* + * Mail -- a mail program + * + * Message list handling. + */ + +/* + * Convert the user string of message numbers and + * store the numbers into vector. + * + * Returns the count of messages picked up or -1 on error. + */ +int +getmsglist(buf, vector, flags) + char *buf; + int *vector, flags; +{ + register int *ip; + register struct message *mp; + + if (msgCount == 0) { + *vector = 0; + return 0; + } + if (markall(buf, flags) < 0) + return(-1); + ip = vector; + for (mp = &message[0]; mp < &message[msgCount]; mp++) + if (mp->m_flag & MMARK) + *ip++ = mp - &message[0] + 1; + *ip = 0; + return(ip - vector); +} + +/* + * Mark all messages that the user wanted from the command + * line in the message structure. Return 0 on success, -1 + * on error. + */ + +/* + * Bit values for colon modifiers. + */ + +#define CMNEW 01 /* New messages */ +#define CMOLD 02 /* Old messages */ +#define CMUNREAD 04 /* Unread messages */ +#define CMDELETED 010 /* Deleted messages */ +#define CMREAD 020 /* Read messages */ + +/* + * The following table describes the letters which can follow + * the colon and gives the corresponding modifier bit. + */ + +struct coltab { + char co_char; /* What to find past : */ + int co_bit; /* Associated modifier bit */ + int co_mask; /* m_status bits to mask */ + int co_equal; /* ... must equal this */ +} coltab[] = { + 'n', CMNEW, MNEW, MNEW, + 'o', CMOLD, MNEW, 0, + 'u', CMUNREAD, MREAD, 0, + 'd', CMDELETED, MDELETED, MDELETED, + 'r', CMREAD, MREAD, MREAD, + 0, 0, 0, 0 +}; + +static int lastcolmod; + +int +markall(buf, f) + char buf[]; + int f; +{ + register char **np; + register int i; + register struct message *mp; + char *namelist[NMLSIZE], *bufp; + int tok, beg, mc, star, other, valdot, colmod, colresult; + + valdot = dot - &message[0] + 1; + colmod = 0; + for (i = 1; i <= msgCount; i++) + unmark(i); + bufp = buf; + mc = 0; + np = &namelist[0]; + scaninit(); + tok = scan(&bufp); + star = 0; + other = 0; + beg = 0; + while (tok != TEOL) { + switch (tok) { + case TNUMBER: +number: + if (star) { + printf("No numbers mixed with *\n"); + return(-1); + } + mc++; + other++; + if (beg != 0) { + if (check(lexnumber, f)) + return(-1); + for (i = beg; i <= lexnumber; i++) + if (f == MDELETED || (message[i - 1].m_flag & MDELETED) == 0) + mark(i); + beg = 0; + break; + } + beg = lexnumber; + if (check(beg, f)) + return(-1); + tok = scan(&bufp); + regret(tok); + if (tok != TDASH) { + mark(beg); + beg = 0; + } + break; + + case TPLUS: + if (beg != 0) { + printf("Non-numeric second argument\n"); + return(-1); + } + i = valdot; + do { + i++; + if (i > msgCount) { + printf("Referencing beyond EOF\n"); + return(-1); + } + } while ((message[i - 1].m_flag & MDELETED) != f); + mark(i); + break; + + case TDASH: + if (beg == 0) { + i = valdot; + do { + i--; + if (i <= 0) { + printf("Referencing before 1\n"); + return(-1); + } + } while ((message[i - 1].m_flag & MDELETED) != f); + mark(i); + } + break; + + case TSTRING: + if (beg != 0) { + printf("Non-numeric second argument\n"); + return(-1); + } + other++; + if (lexstring[0] == ':') { + colresult = evalcol(lexstring[1]); + if (colresult == 0) { + printf("Unknown colon modifier \"%s\"\n", + lexstring); + return(-1); + } + colmod |= colresult; + } + else + *np++ = savestr(lexstring); + break; + + case TDOLLAR: + case TUP: + case TDOT: + lexnumber = metamess(lexstring[0], f); + if (lexnumber == -1) + return(-1); + goto number; + + case TSTAR: + if (other) { + printf("Can't mix \"*\" with anything\n"); + return(-1); + } + star++; + break; + + case TERROR: + return -1; + } + tok = scan(&bufp); + } + lastcolmod = colmod; + *np = NOSTR; + mc = 0; + if (star) { + for (i = 0; i < msgCount; i++) + if ((message[i].m_flag & MDELETED) == f) { + mark(i+1); + mc++; + } + if (mc == 0) { + printf("No applicable messages.\n"); + return(-1); + } + return(0); + } + + /* + * If no numbers were given, mark all of the messages, + * so that we can unmark any whose sender was not selected + * if any user names were given. + */ + + if ((np > namelist || colmod != 0) && mc == 0) + for (i = 1; i <= msgCount; i++) + if ((message[i-1].m_flag & MDELETED) == f) + mark(i); + + /* + * If any names were given, go through and eliminate any + * messages whose senders were not requested. + */ + + if (np > namelist) { + for (i = 1; i <= msgCount; i++) { + for (mc = 0, np = &namelist[0]; *np != NOSTR; np++) + if (**np == '/') { + if (matchsubj(*np, i)) { + mc++; + break; + } + } + else { + if (matchsender(*np, i)) { + mc++; + break; + } + } + if (mc == 0) + unmark(i); + } + + /* + * Make sure we got some decent messages. + */ + + mc = 0; + for (i = 1; i <= msgCount; i++) + if (message[i-1].m_flag & MMARK) { + mc++; + break; + } + if (mc == 0) { + printf("No applicable messages from {%s", + namelist[0]); + for (np = &namelist[1]; *np != NOSTR; np++) + printf(", %s", *np); + printf("}\n"); + return(-1); + } + } + + /* + * If any colon modifiers were given, go through and + * unmark any messages which do not satisfy the modifiers. + */ + + if (colmod != 0) { + for (i = 1; i <= msgCount; i++) { + register struct coltab *colp; + + mp = &message[i - 1]; + for (colp = &coltab[0]; colp->co_char; colp++) + if (colp->co_bit & colmod) + if ((mp->m_flag & colp->co_mask) + != colp->co_equal) + unmark(i); + + } + for (mp = &message[0]; mp < &message[msgCount]; mp++) + if (mp->m_flag & MMARK) + break; + if (mp >= &message[msgCount]) { + register struct coltab *colp; + + printf("No messages satisfy"); + for (colp = &coltab[0]; colp->co_char; colp++) + if (colp->co_bit & colmod) + printf(" :%c", colp->co_char); + printf("\n"); + return(-1); + } + } + return(0); +} + +/* + * Turn the character after a colon modifier into a bit + * value. + */ +int +evalcol(col) + int col; +{ + register struct coltab *colp; + + if (col == 0) + return(lastcolmod); + for (colp = &coltab[0]; colp->co_char; colp++) + if (colp->co_char == col) + return(colp->co_bit); + return(0); +} + +/* + * Check the passed message number for legality and proper flags. + * If f is MDELETED, then either kind will do. Otherwise, the message + * has to be undeleted. + */ +int +check(mesg, f) + int mesg, f; +{ + register struct message *mp; + + if (mesg < 1 || mesg > msgCount) { + printf("%d: Invalid message number\n", mesg); + return(-1); + } + mp = &message[mesg-1]; + if (f != MDELETED && (mp->m_flag & MDELETED) != 0) { + printf("%d: Inappropriate message\n", mesg); + return(-1); + } + return(0); +} + +/* + * Scan out the list of string arguments, shell style + * for a RAWLIST. + */ +int +getrawlist(line, argv, argc) + char line[]; + char **argv; + int argc; +{ + register char c, *cp, *cp2, quotec; + int argn; + char linebuf[BUFSIZ]; + + argn = 0; + cp = line; + for (;;) { + for (; *cp == ' ' || *cp == '\t'; cp++) + ; + if (*cp == '\0') + break; + if (argn >= argc - 1) { + printf( + "Too many elements in the list; excess discarded.\n"); + break; + } + cp2 = linebuf; + quotec = '\0'; + while ((c = *cp) != '\0') { + cp++; + if (quotec != '\0') { + if (c == quotec) + quotec = '\0'; + else if (c == '\\') + switch (c = *cp++) { + case '\0': + *cp2++ = '\\'; + cp--; + break; + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + c -= '0'; + if (*cp >= '0' && *cp <= '7') + c = c * 8 + *cp++ - '0'; + if (*cp >= '0' && *cp <= '7') + c = c * 8 + *cp++ - '0'; + *cp2++ = c; + break; + case 'b': + *cp2++ = '\b'; + break; + case 'f': + *cp2++ = '\f'; + break; + case 'n': + *cp2++ = '\n'; + break; + case 'r': + *cp2++ = '\r'; + break; + case 't': + *cp2++ = '\t'; + break; + case 'v': + *cp2++ = '\v'; + break; + default: + *cp2++ = c; + } + else if (c == '^') { + c = *cp++; + if (c == '?') + *cp2++ = '\177'; + /* null doesn't show up anyway */ + else if (c >= 'A' && c <= '_' || + c >= 'a' && c <= 'z') + *cp2++ = c & 037; + else { + *cp2++ = '^'; + cp--; + } + } else + *cp2++ = c; + } else if (c == '"' || c == '\'') + quotec = c; + else if (c == ' ' || c == '\t') + break; + else + *cp2++ = c; + } + *cp2 = '\0'; + argv[argn++] = savestr(linebuf); + } + argv[argn] = NOSTR; + return argn; +} + +/* + * scan out a single lexical item and return its token number, + * updating the string pointer passed **p. Also, store the value + * of the number or string scanned in lexnumber or lexstring as + * appropriate. In any event, store the scanned `thing' in lexstring. + */ + +struct lex { + char l_char; + char l_token; +} singles[] = { + '$', TDOLLAR, + '.', TDOT, + '^', TUP, + '*', TSTAR, + '-', TDASH, + '+', TPLUS, + '(', TOPEN, + ')', TCLOSE, + 0, 0 +}; + +int +scan(sp) + char **sp; +{ + register char *cp, *cp2; + register int c; + register struct lex *lp; + int quotec; + + if (regretp >= 0) { + strcpy(lexstring, string_stack[regretp]); + lexnumber = numberstack[regretp]; + return(regretstack[regretp--]); + } + cp = *sp; + cp2 = lexstring; + c = *cp++; + + /* + * strip away leading white space. + */ + + while (c == ' ' || c == '\t') + c = *cp++; + + /* + * If no characters remain, we are at end of line, + * so report that. + */ + + if (c == '\0') { + *sp = --cp; + return(TEOL); + } + + /* + * If the leading character is a digit, scan + * the number and convert it on the fly. + * Return TNUMBER when done. + */ + + if (isdigit(c)) { + lexnumber = 0; + while (isdigit(c)) { + lexnumber = lexnumber*10 + c - '0'; + *cp2++ = c; + c = *cp++; + } + *cp2 = '\0'; + *sp = --cp; + return(TNUMBER); + } + + /* + * Check for single character tokens; return such + * if found. + */ + + for (lp = &singles[0]; lp->l_char != 0; lp++) + if (c == lp->l_char) { + lexstring[0] = c; + lexstring[1] = '\0'; + *sp = cp; + return(lp->l_token); + } + + /* + * We've got a string! Copy all the characters + * of the string into lexstring, until we see + * a null, space, or tab. + * If the lead character is a " or ', save it + * and scan until you get another. + */ + + quotec = 0; + if (c == '\'' || c == '"') { + quotec = c; + c = *cp++; + } + while (c != '\0') { + if (c == quotec) { + cp++; + break; + } + if (quotec == 0 && (c == ' ' || c == '\t')) + break; + if (cp2 - lexstring < STRINGLEN-1) + *cp2++ = c; + c = *cp++; + } + if (quotec && c == 0) { + fprintf(stderr, "Missing %c\n", quotec); + return TERROR; + } + *sp = --cp; + *cp2 = '\0'; + return(TSTRING); +} + +/* + * Unscan the named token by pushing it onto the regret stack. + */ +void +regret(token) + int token; +{ + if (++regretp >= REGDEP) + panic("Too many regrets"); + regretstack[regretp] = token; + lexstring[STRINGLEN-1] = '\0'; + string_stack[regretp] = savestr(lexstring); + numberstack[regretp] = lexnumber; +} + +/* + * Reset all the scanner global variables. + */ +void +scaninit() +{ + regretp = -1; +} + +/* + * Find the first message whose flags & m == f and return + * its message number. + */ +int +first(f, m) + int f, m; +{ + register struct message *mp; + + if (msgCount == 0) + return 0; + f &= MDELETED; + m &= MDELETED; + for (mp = dot; mp < &message[msgCount]; mp++) + if ((mp->m_flag & m) == f) + return mp - message + 1; + for (mp = dot-1; mp >= &message[0]; mp--) + if ((mp->m_flag & m) == f) + return mp - message + 1; + return 0; +} + +/* + * See if the passed name sent the passed message number. Return true + * if so. + */ +int +matchsender(str, mesg) + char *str; + int mesg; +{ + register char *cp, *cp2, *backup; + + if (!*str) /* null string matches nothing instead of everything */ + return 0; + backup = cp2 = nameof(&message[mesg - 1], 0); + cp = str; + while (*cp2) { + if (*cp == 0) + return(1); + if (raise(*cp++) != raise(*cp2++)) { + cp2 = ++backup; + cp = str; + } + } + return(*cp == 0); +} + +/* + * See if the given string matches inside the subject field of the + * given message. For the purpose of the scan, we ignore case differences. + * If it does, return true. The string search argument is assumed to + * have the form "/search-string." If it is of the form "/," we use the + * previous search string. + */ + +char lastscan[128]; +int +matchsubj(str, mesg) + char *str; + int mesg; +{ + register struct message *mp; + register char *cp, *cp2, *backup; + + str++; + if (strlen(str) == 0) + str = lastscan; + else + strcpy(lastscan, str); + mp = &message[mesg-1]; + + /* + * Now look, ignoring case, for the word in the string. + */ + + if (value("searchheaders") && (cp = index(str, ':'))) { + *cp++ = '\0'; + cp2 = hfield(str, mp); + cp[-1] = ':'; + str = cp; + } else { + cp = str; + cp2 = hfield("subject", mp); + } + if (cp2 == NOSTR) + return(0); + backup = cp2; + while (*cp2) { + if (*cp == 0) + return(1); + if (raise(*cp++) != raise(*cp2++)) { + cp2 = ++backup; + cp = str; + } + } + return(*cp == 0); +} + +/* + * Mark the named message by setting its mark bit. + */ +void +mark(mesg) + int mesg; +{ + register int i; + + i = mesg; + if (i < 1 || i > msgCount) + panic("Bad message number to mark"); + message[i-1].m_flag |= MMARK; +} + +/* + * Unmark the named message. + */ +void +unmark(mesg) + int mesg; +{ + register int i; + + i = mesg; + if (i < 1 || i > msgCount) + panic("Bad message number to unmark"); + message[i-1].m_flag &= ~MMARK; +} + +/* + * Return the message number corresponding to the passed meta character. + */ +int +metamess(meta, f) + int meta, f; +{ + register int c, m; + register struct message *mp; + + c = meta; + switch (c) { + case '^': + /* + * First 'good' message left. + */ + for (mp = &message[0]; mp < &message[msgCount]; mp++) + if ((mp->m_flag & MDELETED) == f) + return(mp - &message[0] + 1); + printf("No applicable messages\n"); + return(-1); + + case '$': + /* + * Last 'good message left. + */ + for (mp = &message[msgCount-1]; mp >= &message[0]; mp--) + if ((mp->m_flag & MDELETED) == f) + return(mp - &message[0] + 1); + printf("No applicable messages\n"); + return(-1); + + case '.': + /* + * Current message. + */ + m = dot - &message[0] + 1; + if ((dot->m_flag & MDELETED) != f) { + printf("%d: Inappropriate message\n", m); + return(-1); + } + return(m); + + default: + printf("Unknown metachar (%c)\n", c); + return(-1); + } +} -- cgit v1.2.3