Ultrix-3.1/src/ucb/Mail/aux.c
/**********************************************************************
* Copyright (c) Digital Equipment Corporation 1984, 1985, 1986. *
* All Rights Reserved. *
* Reference "/usr/src/COPYRIGHT" for applicable restrictions. *
**********************************************************************/
#ifndef lint
static char *Sccsid = "@(#)aux.c 3.1 12/3/87";
#endif
#include "rcv.h"
#include <sys/stat.h>
#include <ctype.h>
/*
* Mail -- a mail program
*
* Auxiliary functions.
*/
/*
* Based on
* static char *SccsId = "@(#)aux.c 2.10 6/28/83";
*/
/*
* Return a pointer to a dynamic copy of the argument.
*/
char *
savestr(str)
char *str;
{
register char *cp, *cp2, *top;
for (cp = str; *cp; cp++)
;
top = salloc(cp-str + 1);
if (top == NOSTR)
return(NOSTR);
for (cp = str, cp2 = top; *cp; cp++)
*cp2++ = *cp;
*cp2 = 0;
return(top);
}
/*
* Copy the name from the passed header line into the passed
* name buffer. Null pad the name buffer.
*/
copyname(linebuf, nbuf)
char *linebuf, *nbuf;
{
register char *cp, *cp2;
for (cp = linebuf + 5, cp2 = nbuf; *cp != ' ' && cp2-nbuf < 8; cp++)
*cp2++ = *cp;
while (cp2-nbuf < 8)
*cp2++ = 0;
}
/*
* Announce a fatal error and die.
*/
panic(str)
char *str;
{
prs("panic: ");
prs(str);
prs("\n");
exit(1);
}
/*
* Catch stdio errors and report them more nicely.
*/
_error(str)
char *str;
{
prs("Stdio Error: ");
prs(str);
prs("\n");
abort();
}
/*
* Print a string on diagnostic output.
*/
prs(str)
char *str;
{
register char *s;
for (s = str; *s; s++)
;
write(2, str, s-str);
}
/*
* 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.
*/
touch(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.
*/
isdir(name)
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.
*/
argcount(argv)
char **argv;
{
register char **ap;
for (ap = argv; *ap != NOSTR; ap++)
;
return(ap-argv);
}
/*
* Given a file address, determine the
* block number it represents.
*/
blockof(off)
off_t off;
{
off_t a;
a = off >> 9;
a &= 077777;
return((int) a);
}
/*
* Take a file address, and determine
* its offset in the current block.
*/
offsetof(off)
off_t off;
{
off_t a;
a = off & 0777;
return((int) a);
}
/*
* Determine if the passed file is actually a tty, via a call to
* gtty. This is not totally reliable, but . . .
*/
isatty(f)
{
struct sgttyb buf;
if (gtty(f, &buf) < 0)
return(0);
return(1);
}
/*
* Return the desired header line from the passed message
* pointer (or NOSTR if the desired header field is not available).
*/
char *
hfield(field, mp)
char field[];
struct message *mp;
{
register FILE *ibuf;
char linebuf[LINESIZE];
register int lc;
ibuf = setinput(mp);
if ((lc = mp->m_lines) <= 0)
return(NOSTR);
if (readline(ibuf, linebuf) < 0)
return(NOSTR);
lc--;
do {
lc = gethfield(ibuf, linebuf, lc);
if (lc == -1)
return(NOSTR);
if (ishfield(linebuf, field))
return(savestr(hcontents(linebuf)));
} while (lc > 0);
return(NOSTR);
}
/*
* Return the next header field found in the given message.
* Return > 0 if something found, <= 0 elsewise.
* Must deal with \ continuations & other such fraud.
*/
gethfield(f, linebuf, rem)
register FILE *f;
char linebuf[];
register int rem;
{
char line2[LINESIZE];
long loc;
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 (linebuf[0] == '>')
continue;
cp = index(linebuf, ':');
if (cp == NOSTR)
continue;
for (cp2 = linebuf; cp2 < cp; cp2++)
if (isdigit(*cp2))
continue;
/*
* I guess we got a headline.
* Handle wraparounding
*/
for (;;) {
if (rem <= 0)
break;
#ifdef CANTELL
loc = ftell(f);
if (readline(f, line2) < 0)
break;
rem--;
if (!isspace(line2[0])) {
fseek(f, loc, 0);
rem++;
break;
}
#else
c = getc(f);
ungetc(c, f);
/* rjg.. Remove check for lf. Causes subject
* to be ommitted on header command if an
* extra line feed is included before/after
* one of the header lines.
*/
#if 0
if (!isspace(c) || c == '\n')
#endif
if (!isspace(c) || c == '\t' || c == ' ')
break;
if (readline(f, line2) < 0)
break;
rem--;
#endif
cp2 = line2;
for (cp2 = line2; *cp2 != 0 && isspace(*cp2); cp2++)
;
if (strlen(linebuf) + strlen(cp2) >= 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++)
;
strcpy(cp, 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.
*/
ishfield(linebuf, field)
char linebuf[], field[];
{
register char *cp;
register int c;
if ((cp = index(linebuf, ':')) == NOSTR)
return(0);
if (cp == linebuf)
return(0);
cp--;
while (cp > linebuf && isspace(*cp))
cp--;
c = *++cp;
*cp = 0;
if (icequal(linebuf ,field)) {
*cp = c;
return(1);
}
*cp = c;
return(0);
}
/*
* Extract the non label information from the given header field
* and return it.
*/
char *
hcontents(hfield)
char hfield[];
{
register char *cp;
if ((cp = index(hfield, ':')) == NOSTR)
return(NOSTR);
cp++;
while (*cp && isspace(*cp))
cp++;
return(cp);
}
/*
* Compare two strings, ignoring case.
*/
icequal(s1, s2)
register char *s1, *s2;
{
while (raise(*s1++) == raise(*s2))
if (*s2++ == 0)
return(1);
return(0);
}
/*
* Copy a string, lowercasing it as we go.
*/
istrcpy(dest, src)
char *dest, *src;
{
register char *cp, *cp2;
cp2 = dest;
cp = src;
do {
*cp2++ = little(*cp);
} while (*cp++ != 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 */
struct sstack {
FILE *s_file; /* File we were in. */
int s_cond; /* Saved state of conditionals */
int s_loading; /* Loading .mailrc, etc. */
} sstack[_NFILE];
/*
* 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).
*/
source(name)
char name[];
{
register FILE *fi;
register char *cp;
if ((cp = expand(name)) == NOSTR)
return(1);
if ((fi = fopen(cp, "r")) == NULL) {
perror(cp);
return(1);
}
if (ssp >= _NFILE-2) {
printf("Too much \"sourcing\" going on.\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);
}
/*
* Source a file, but do nothing if the file cannot be opened.
*/
source1(name)
char name[];
{
register int f;
if ((f = open(name, 0)) < 0)
return(0);
close(f);
source(name);
}
/*
* Pop the current input back to the previous level.
* Update the "sourcing" flag as appropriate.
*/
unstack()
{
if (ssp < 0) {
printf("\"Source\" stack over-pop.\n");
sourcing = 0;
return(1);
}
fclose(input);
if (cond != CANY)
printf("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.
*/
alter(name)
char name[];
{
#ifdef UTIME
struct stat statb;
long time();
time_t time_p[2];
#else
register int pid, f;
char w;
#endif UTIME
#ifdef UTIME
if (stat(name, &statb) < 0)
return;
time_p[0] = time((long *) 0) + 1;
time_p[1] = statb.st_mtime;
utime(name, time_p);
#else
sleep(1);
if ((f = open(name, 0)) < 0)
return;
read(f, &w, 1);
exit(0);
#endif
}
/*
* Examine the passed line buffer and
* return true if it is all blanks and tabs.
*/
blankline(linebuf)
char linebuf[];
{
register char *cp;
for (cp = linebuf; *cp; cp++)
if (!any(*cp, " \t"))
return(0);
return(1);
}
/*
* Get sender's name from this message. If the message has
* a bunch of arpanet stuff in it, we may have to skin the name
* before returning it.
*/
char *
nameof(mp, reptype)
register struct message *mp;
{
register char *cp, *cp2;
cp = skin(name1(mp, reptype));
if (reptype != 0 || charcount(cp, '!') < 2)
return(cp);
cp2 = rindex(cp, '!');
cp2--;
while (cp2 > cp && *cp2 != '!')
cp2--;
if (*cp2 == '!')
return(cp2 + 1);
return(cp);
}
/*
* Skin an arpa net address according to the RFC 733 interpretation
* of "host-phrase."
*/
char *
skin(name)
char *name;
{
register int c;
register char *cp, *cp2;
int gotlt, lastsp;
char nbuf[BUFSIZ];
if (name == NOSTR)
return(NOSTR);
if (index(name, '(') == NOSTR && index(name, '<') == NOSTR
&& index(name, ' ') == NOSTR)
return(name);
gotlt = 0;
lastsp = 0;
for (cp = name, cp2 = nbuf; c = *cp++; ) {
switch (c) {
case '(':
while (*cp != ')' && *cp != 0)
cp++;
if (*cp)
cp++;
lastsp = 0;
break;
case ' ':
if (cp[0] == 'a' && cp[1] == 't' && cp[2] == ' ')
cp += 3, *cp2++ = '@';
else
if (cp[0] == '@' && cp[1] == ' ')
cp += 2, *cp2++ = '@';
else
lastsp = 1;
break;
case '<':
cp2 = nbuf;
gotlt++;
lastsp = 0;
break;
case '>':
if (gotlt)
goto done;
/* Fall into . . . */
default:
if (lastsp) {
lastsp = 0;
*cp2++ = ' ';
}
*cp2++ = c;
break;
}
}
done:
*cp2 = 0;
return(savestr(nbuf));
}
/*
* Fetch the sender's name from the passed message.
* Reptype can be
* 0 -- get sender's name for display purposes
* 1 -- get sender's name for reply
* 2 -- get sender's name for Reply
*/
char *
name1(mp, reptype)
register struct message *mp;
{
char namebuf[LINESIZE];
char linebuf[LINESIZE];
register char *cp, *cp2;
register FILE *ibuf;
int first = 1;
#ifdef SENDMAIL
if (sm_toobig == 1) {
if ((cp = hfield("from", mp)) != NOSTR)
return(cp);
if (reptype == 0 && (cp = hfield("sender", mp)) != NOSTR)
return(cp);
}
#else NOT SENDMAIL
if ((cp = hfield("from", mp)) != NOSTR)
return(cp);
if (reptype == 0 && (cp = hfield("sender", mp)) != NOSTR)
return(cp);
#endif SENDMAIL
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';
if (readline(ibuf, linebuf) <= 0)
return(savestr(namebuf));
if ((cp = index(linebuf, 'F')) == NULL)
return(savestr(namebuf));
if (strncmp(cp, "From", 4) != 0)
return(savestr(namebuf));
while ((cp = index(cp, 'r')) != NULL) {
if (strncmp(cp, "remote", 6) == 0) {
if ((cp = index(cp, 'f')) == NULL)
break;
if (strncmp(cp, "from", 4) != 0)
break;
if ((cp = index(cp, ' ')) == NULL)
break;
cp++;
if (first) {
copy(cp, namebuf);
first = 0;
} else
strcpy(rindex(namebuf, '!')+1, cp);
strcat(namebuf, "!");
goto newname;
}
cp++;
}
return(savestr(namebuf));
}
/*
* Count the occurances of c in str
*/
charcount(str, c)
char *str;
{
register char *cp;
register int i;
for (i = 0, cp = str; *cp; cp++)
if (*cp == c)
i++;
return(i);
}
/*
* Find the rightmost pointer to an instance of the
* character in the string and return it.
*/
char *
rindex(str, c)
char str[];
register int c;
{
register char *cp, *cp2;
for (cp = str, cp2 = NOSTR; *cp; cp++)
if (c == *cp)
cp2 = cp;
return(cp2);
}
/*
* See if the string is a number.
*/
numeric(str)
char str[];
{
register char *cp = str;
while (*cp)
if (!isdigit(*cp++))
return(0);
return(1);
}
/*
* Are any of the characters in the two strings the same?
*/
anyof(s1, s2)
register char *s1, *s2;
{
register int c;
while (c = *s1++)
if (any(c, s2))
return(1);
return(0);
}
/*
* Determine the leftmost index of the character
* in the string.
*/
char *
index(str, ch)
char *str;
{
register char *cp;
register int c;
for (c = ch, cp = str; *cp; cp++)
if (*cp == c)
return(cp);
return(NOSTR);
}
/*
* String compare two strings of bounded length.
*/
strncmp(as1, as2, an)
char *as1, *as2;
{
register char *s1, *s2;
register int n;
s1 = as1;
s2 = as2;
n = an;
while (--n >= 0 && *s1 == *s2++)
if (*s1++ == '\0')
return(0);
return(n<0 ? 0 : *s1 - *--s2);
}
/*
* See if the given header field is supposed to be ignored.
*/
isign(field)
char *field;
{
char realfld[BUFSIZ];
register int h;
register struct ignore *igp;
istrcpy(realfld, field);
h = hash(realfld);
for (igp = ignore[h]; igp != 0; igp = igp->i_link)
if (strcmp(igp->i_field, realfld) == 0)
return(1);
return(0);
}