int
map_chk (char *file, int fd, struct drop *dp, long pos, int noisy)
{
ssize_t count;
struct drop d, tmpd;
register struct drop *dl;
if (read (fd, (char *) &tmpd, sizeof(*dp)) != sizeof(*dp)) {
#ifdef notdef
admonish (NULL, "%s: missing or partial index", file);
#endif /* notdef */
return NOTOK;
}
#ifndef NTOHLSWAP
*dp = tmpd; /* if ntohl(n)=(n), can use struct assign */
#else
dp->d_id = ntohl(tmpd.d_id);
dp->d_size = ntohl(tmpd.d_size);
dp->d_start = ntohl(tmpd.d_start);
dp->d_stop = ntohl(tmpd.d_stop);
#endif
if (dp->d_size != DRVRSN) {
if (noisy)
admonish (NULL, "%s: version mismatch (%d != %d)", file,
dp->d_size, DRVRSN);
return NOTOK;
}
if (dp->d_stop != pos) {
if (noisy && pos != (long) 0)
admonish (NULL,
"%s: pointer mismatch or incomplete index (%ld!=%ld)",
file, dp->d_stop, (long) pos);
return NOTOK;
}
if ((long) ((dp->d_id + 1) * sizeof(*dp)) != (long) lseek (fd, (off_t) 0, SEEK_END)) {
if (noisy)
admonish (NULL, "%s: corrupt index(1)", file);
return NOTOK;
}
dl = &d;
count = strlen (mmdlm2);
lseek (fd, (off_t) (dp->d_id * sizeof(*dp)), SEEK_SET);
if (read (fd, (char *) dl, sizeof(*dl)) != sizeof(*dl)
|| (ntohl(dl->d_stop) != dp->d_stop
&& ntohl(dl->d_stop) + count != dp->d_stop)) {
if (noisy)
admonish (NULL, "%s: corrupt index(2)", file);
return NOTOK;
}
return OK;
}
int
nmh_get_credentials (char *host, char *user, int sasl, nmh_creds_t creds) {
char *cred_style = context_find ("credentials");
init_credentials_file ();
creds->host = host;
if (cred_style == NULL || ! strcmp (cred_style, "legacy")) {
if (sasl) {
/* This is what inc.c and msgchk.c used to contain. */
/* Only inc.c and msgchk.c do this. smtp.c doesn't. */
creds->user = user == NULL ? getusername () : user;
creds->password = getusername ();
}
} else if (! strncasecmp (cred_style, "file:", 5)) {
/*
* Determine user using the first of:
* 1) -user switch
* 2) matching host entry with login in a credentials file
* such as ~/.netrc
* 3) interactively request from user (as long as the
* credentials file didn't have a "default" token)
*/
creds->user = user;
} else {
admonish (NULL, "unknown credentials style %s", cred_style);
return NOTOK;
}
ruserpass (host, &creds->user, &creds->password);
return OK;
}
void
init_credentials_file () {
if (credentials_file == NULL) {
char *cred_style = context_find ("credentials");
if (cred_style == NULL || ! strcmp (cred_style, "legacy")) {
char *hdir = getenv ("HOME");
credentials_file = concat (hdir ? hdir : ".", "/.netrc", NULL);
} else if (! strncasecmp (cred_style, "file:", 5)) {
struct stat st;
char *filename = cred_style + 5;
while (*filename && isspace ((int) *filename)) ++filename;
if (*filename == '/') {
credentials_file = filename;
} else {
credentials_file = m_maildir (filename);
if (stat (credentials_file, &st) != OK) {
credentials_file =
concat (mypath ? mypath : ".", "/", filename, NULL);
if (stat (credentials_file, &st) != OK) {
admonish (NULL, "unable to find credentials file %s",
filename);
}
}
}
}
}
}
char *pwd () {
register char *cp;
#ifndef BSD42
#ifndef SYS5DIR
if (getwd (curwd) == NOTOK) {
admonish (NULL, "unable to determine working directory");
#else /* SYS5DIR */
if (getcwd (curwd, MAXPATHLEN) == NULL) {
admonish (NULL, "unable to determine working directory");
#endif /* SYS5DIR */
#else /* BSD42 */
if (getwd (curwd) == 0) {
admonish (NULLCP, "unable to determine working directory: %s", curwd);
#endif /* BSD42 */
if (mypath == NULL
|| *mypath == 0
|| ((void) strcpy (curwd, mypath), chdir (curwd)) == NOTOK) {
(void) strcpy (curwd, "/");
(void) chdir (curwd);
}
return curwd;
}
if ((cp = curwd + strlen (curwd) - 1) > curwd && *cp == '/')
*cp = 0;
return curwd;
}
/* */
#if !defined (BSD42) && !defined (SYS5DIR)
/* getwd() - get the current working directory */
/* Algorithm from several sources, -ljobs, pwd.c, etc., etc. */
getwd (cwd)
register char *cwd;
{
int found;
char tmp1[BUFSIZ],
tmp2[BUFSIZ];
struct stat st1,
st2,
root;
register struct direct *dp;
register DIR * dd;
(void) strcpy (cwd, "/");
(void) stat ("/", &root);
for (;;) {
if ((dd = opendir ("..")) == NULL)
return NOTOK;
if (stat (".", &st2) == NOTOK || stat ("..", &st1) == NOTOK)
goto out;
if (st2.st_ino == root.st_ino && st2.st_dev == root.st_dev) {
closedir (dd);
return chdir (cwd);
}
if (st2.st_ino == st1.st_ino && st2.st_dev == st1.st_dev) {
closedir (dd);
(void) chdir ("/");
if ((dd = opendir (".")) == NULL)
return NOTOK;
if (stat (".", &st1) < 0)
goto out;
if (st2.st_dev != st1.st_dev)
while (dp = readdir (dd)) {
if (stat (dp -> d_name, &st1) == NOTOK)
goto out;
if (st2.st_dev == st1.st_dev) {
(void) sprintf (tmp1, "%s%s", dp -> d_name, cwd);
(void) strcpy (cwd + 1, tmp1);
closedir (dd);
return (chdir (cwd));
}
}
else {
closedir (dd);
return (chdir (cwd));
}
}
found = 0;
while (dp = readdir (dd)) {
(void) sprintf (tmp2, "../%s", dp -> d_name);
if (stat (tmp2, &st1) != NOTOK
&& st1.st_ino == st2.st_ino
&& st1.st_dev == st2.st_dev) {
closedir (dd);
found++;
(void) chdir ("..");
(void) sprintf (tmp1, "%s%s", dp -> d_name, cwd);
(void) strcpy (cwd + 1, tmp1);
break;
}
}
if (!found)
goto out;
}
out: ;
closedir (dd);
return NOTOK;
}
int
main (int argc, char **argv)
{
int msgnum, *icachesw;
char *cp, *file = NULL, *outfile = NULL, *folder = NULL;
char *maildir, buf[100], **argp;
char **arguments;
struct msgs_array msgs = { 0, 0, NULL };
struct msgs *mp = NULL;
CT ct, *ctp;
FILE *fp;
if (nmh_init(argv[0], 1)) { return 1; }
done=freects_done;
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
/*
* Parse arguments
*/
while ((cp = *argp++)) {
if (*cp == '-') {
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [+folder] [msgs] [switches]",
invo_name);
print_help (buf, switches, 1);
done (0);
case VERSIONSW:
print_version(invo_name);
done (0);
case AUTOSW:
autosw++;
continue;
case NAUTOSW:
autosw = 0;
continue;
case RCACHESW:
icachesw = &rcachesw;
goto do_cache;
case WCACHESW:
icachesw = &wcachesw;
do_cache:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
switch (*icachesw = smatch (cp, caches)) {
case AMBIGSW:
ambigsw (cp, caches);
done (1);
case UNKWNSW:
adios (NULL, "%s unknown", cp);
default:
break;
}
continue;
case CHECKSW:
checksw++;
continue;
case NCHECKSW:
checksw = 0;
continue;
case PARTSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if (npart >= NPARTS)
adios (NULL, "too many parts (starting with %s), %d max",
cp, NPARTS);
parts[npart++] = cp;
continue;
case TYPESW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if (ntype >= NTYPES)
adios (NULL, "too many types (starting with %s), %d max",
cp, NTYPES);
types[ntype++] = cp;
continue;
case FILESW:
if (!(cp = *argp++) || (*cp == '-' && cp[1]))
adios (NULL, "missing argument to %s", argp[-2]);
file = *cp == '-' ? cp : path (cp, TFILE);
continue;
case OUTFILESW:
if (!(cp = *argp++) || (*cp == '-' && cp[1]))
adios (NULL, "missing argument to %s", argp[-2]);
outfile = *cp == '-' ? cp : path (cp, TFILE);
continue;
case VERBSW:
verbosw = 1;
continue;
case NVERBSW:
verbosw = 0;
continue;
case CLOBBERSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if (save_clobber_policy (cp)) {
adios (NULL, "invalid argument, %s, to %s", argp[-1],
argp[-2]);
}
continue;
case DEBUGSW:
debugsw = 1;
continue;
}
}
if (*cp == '+' || *cp == '@') {
if (folder)
adios (NULL, "only one folder at a time!");
else
folder = pluspath (cp);
} else
app_msgarg(&msgs, cp);
}
/* null terminate the list of acceptable parts/types */
parts[npart] = NULL;
types[ntype] = NULL;
/*
* Check if we've specified an additional profile
*/
if ((cp = getenv ("MHSTORE"))) {
if ((fp = fopen (cp, "r"))) {
readconfig ((struct node **) 0, fp, cp, 0);
fclose (fp);
} else {
admonish ("", "unable to read $MHSTORE profile (%s)", cp);
}
}
/*
* Read the standard profile setup
*/
if ((fp = fopen (cp = etcpath ("mhn.defaults"), "r"))) {
readconfig ((struct node **) 0, fp, cp, 0);
fclose (fp);
}
/* Check for public cache location */
if ((cache_public = context_find (nmhcache)) && *cache_public != '/')
cache_public = NULL;
/* Check for private cache location */
if (!(cache_private = context_find (nmhprivcache)))
cache_private = ".cache";
cache_private = getcpy (m_maildir (cache_private));
/*
* Cache the current directory before we do any chdirs()'s.
*/
cwd = getcpy (pwd());
if (!context_find ("path"))
free (path ("./", TFOLDER));
if (file && msgs.size)
adios (NULL, "cannot specify msg and file at same time!");
/*
* check if message is coming from file
*/
if (file) {
if (!(cts = (CT *) calloc ((size_t) 2, sizeof(*cts))))
adios (NULL, "out of memory");
ctp = cts;
if ((ct = parse_mime (file))) {
*ctp++ = ct;
if (outfile) {
ct->c_storage = outfile;
}
}
} else {
/*
* message(s) are coming from a folder
*/
if (!msgs.size)
app_msgarg(&msgs, "cur");
if (!folder)
folder = getfolder (1);
maildir = m_maildir (folder);
if (chdir (maildir) == NOTOK)
adios (maildir, "unable to change directory to");
/* read folder and create message structure */
if (!(mp = folder_read (folder, 1)))
adios (NULL, "unable to read folder %s", folder);
/* check for empty folder */
if (mp->nummsg == 0)
adios (NULL, "no messages in %s", folder);
/* parse all the message ranges/sequences and set SELECTED */
for (msgnum = 0; msgnum < msgs.size; msgnum++)
if (!m_convert (mp, msgs.msgs[msgnum]))
done (1);
seq_setprev (mp); /* set the previous-sequence */
if (!(cts = (CT *) calloc ((size_t) (mp->numsel + 1), sizeof(*cts))))
adios (NULL, "out of memory");
ctp = cts;
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
if (is_selected(mp, msgnum)) {
char *msgnam;
msgnam = m_name (msgnum);
if ((ct = parse_mime (msgnam))) {
*ctp++ = ct;
if (outfile) {
ct->c_storage = add (outfile, NULL);
}
}
}
}
}
if (!*cts)
done (1);
userrs = 1;
SIGNAL (SIGQUIT, quitser);
SIGNAL (SIGPIPE, pipeser);
/*
* Get the associated umask for the relevant contents.
*/
for (ctp = cts; *ctp; ctp++) {
struct stat st;
ct = *ctp;
if (type_ok (ct, 1) && !ct->c_umask) {
if (stat (ct->c_file, &st) != NOTOK)
ct->c_umask = ~(st.st_mode & 0777);
else
ct->c_umask = ~m_gmprot();
}
}
/*
* Store the message content
*/
store_all_messages (cts);
/* Now free all the structures for the content */
for (ctp = cts; *ctp; ctp++)
free_content (*ctp);
free ((char *) cts);
cts = NULL;
/* If reading from a folder, do some updating */
if (mp) {
context_replace (pfolder, folder);/* update current folder */
seq_setcur (mp, mp->hghsel); /* update current message */
seq_save (mp); /* synchronize sequences */
context_save (); /* save the context file */
}
done (files_not_clobbered);
return 1;
}
void
seq_save (struct msgs *mp)
{
size_t i;
char flags, *cp, attr[BUFSIZ], seqfile[PATH_MAX];
FILE *fp;
sigset_t set, oset;
/* check if sequence information has changed */
if (!(mp->msgflags & SEQMOD)) {
if (mp->seqhandle) {
lkfclosedata (mp->seqhandle, mp->seqname);
mp->seqhandle = NULL;
free(mp->seqname);
mp->seqname = NULL;
}
return;
}
mp->msgflags &= ~SEQMOD;
fp = NULL;
flags = mp->msgflags; /* record folder flags */
/*
* If no mh-sequences file is defined, or if a mh-sequences file
* is defined but empty (*mh_seq == '\0'), then pretend folder
* is readonly. This will force all sequences to be private.
*/
if (mh_seq == NULL || *mh_seq == '\0')
set_readonly (mp);
else
snprintf (seqfile, sizeof(seqfile), "%s/%s", mp->foldpath, mh_seq);
for (i = 0; i < svector_size (mp->msgattrs); i++) {
snprintf (attr, sizeof(attr), "atr-%s-%s",
svector_at (mp->msgattrs, i), mp->foldpath);
/* get space separated list of sequence ranges */
if (!(cp = seq_list(mp, svector_at (mp->msgattrs, i)))) {
context_del (attr); /* delete sequence from context */
continue;
}
if (is_readonly(mp) || is_seq_private(mp, i)) {
priv:
/*
* sequence is private
*/
context_replace (attr, cp); /* update sequence in context */
} else {
/*
* sequence is public
*/
context_del (attr); /* delete sequence from context */
if (!fp) {
/*
* Attempt to open file for public sequences.
* If that fails (probably because folder is
* readonly), then make sequence private.
*/
if (mp->seqhandle) {
fp = mp->seqhandle;
mp->seqhandle = NULL;
free(mp->seqname);
mp->seqname = NULL;
rewind(fp);
ftruncate(fileno(fp), 0);
} else if ((fp = lkfopendata (seqfile, "w")) == NULL
&& (m_unlink (seqfile) == -1 ||
(fp = lkfopendata (seqfile, "w")) == NULL)) {
admonish (attr, "unable to write");
goto priv;
}
/* block a few signals */
sigemptyset (&set);
sigaddset(&set, SIGHUP);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGQUIT);
sigaddset(&set, SIGTERM);
sigprocmask (SIG_BLOCK, &set, &oset);
}
fprintf (fp, "%s: %s\n", svector_at (mp->msgattrs, i), cp);
}
}
if (fp) {
lkfclosedata (fp, seqfile);
sigprocmask (SIG_SETMASK, &oset, &set); /* reset signal mask */
} else {
/*
* If folder is not readonly, and we didn't save any
* public sequences, then remove that file.
*/
if (!is_readonly(mp))
(void) m_unlink (seqfile);
}
/*
* Reset folder flag, since we may be
* pretending that folder is readonly.
*/
mp->msgflags = flags;
}
int
main (int argc, char **argv)
{
int sizesw = 1, headsw = 1;
int *icachesw;
char *cp, buf[BUFSIZ];
char buffer[BUFSIZ], *compfile = NULL;
char **argp, **arguments;
CT ct, cts[2];
FILE *fp = NULL;
FILE *fp_out = NULL;
done=unlink_done;
#ifdef LOCALE
setlocale(LC_ALL, "");
#endif
invo_name = r1bindex (argv[0], '/');
/* read user profile/context */
context_read();
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
while ((cp = *argp++)) {
if (cp[0] == '-' && cp[1] == '\0') {
if (compfile)
adios (NULL, "cannot specify both standard input and a file");
else
compfile = cp;
listsw = 0; /* turn off -list if using standard in/out */
verbosw = 0; /* turn off -verbose listings */
break;
}
if (*cp == '-') {
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [switches] file", invo_name);
print_help (buf, switches, 1);
done (1);
case VERSIONSW:
print_version(invo_name);
done (1);
case RCACHESW:
icachesw = &rcachesw;
goto do_cache;
case WCACHESW:
icachesw = &wcachesw;
do_cache: ;
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
switch (*icachesw = smatch (cp, caches)) {
case AMBIGSW:
ambigsw (cp, caches);
done (1);
case UNKWNSW:
adios (NULL, "%s unknown", cp);
default:
break;
}
continue;
case CHECKSW:
checksw++;
continue;
case NCHECKSW:
checksw = 0;
continue;
case EBCDICSW:
ebcdicsw++;
continue;
case NEBCDICSW:
ebcdicsw = 0;
continue;
case HEADSW:
headsw++;
continue;
case NHEADSW:
headsw = 0;
continue;
case LISTSW:
listsw++;
continue;
case NLISTSW:
listsw = 0;
continue;
case RFC934SW:
rfc934sw++;
continue;
case NRFC934SW:
rfc934sw = 0;
continue;
case SIZESW:
sizesw++;
continue;
case NSIZESW:
sizesw = 0;
continue;
case CONTENTIDSW:
contentidsw = 1;
continue;
case NCONTENTIDSW:
contentidsw = 0;
continue;
case VERBSW:
verbosw++;
continue;
case NVERBSW:
verbosw = 0;
continue;
case DEBUGSW:
debugsw = 1;
continue;
}
}
if (compfile)
adios (NULL, "only one composition file allowed");
else
compfile = cp;
}
set_endian ();
if ((cp = getenv ("MM_NOASK")) && !strcmp (cp, "1"))
listsw = 0;
/*
* Check if we've specified an additional profile
*/
if ((cp = getenv ("MHBUILD"))) {
if ((fp = fopen (cp, "r"))) {
readconfig ((struct node **) 0, fp, cp, 0);
fclose (fp);
} else {
admonish ("", "unable to read $MHBUILD profile (%s)", cp);
}
}
/*
* Read the standard profile setup
*/
if ((fp = fopen (cp = etcpath ("mhn.defaults"), "r"))) {
readconfig ((struct node **) 0, fp, cp, 0);
fclose (fp);
}
/* Check for public cache location */
if ((cache_public = context_find (nmhcache)) && *cache_public != '/')
cache_public = NULL;
/* Check for private cache location */
if (!(cache_private = context_find (nmhprivcache)))
cache_private = ".cache";
cache_private = getcpy (m_maildir (cache_private));
/*
* Check for storage directory. If defined, we
* will store temporary files there. Else we
* store them in standard nmh directory.
*/
if ((cp = context_find (nmhstorage)) && *cp)
tmp = concat (cp, "/", invo_name, NULL);
else
tmp = add (m_maildir (invo_name), NULL);
if (!context_find ("path"))
free (path ("./", TFOLDER));
/* Check if we have a file to process */
if (!compfile)
adios (NULL, "need to specify a %s composition file", invo_name);
/*
* Process the composition file from standard input.
*/
if (compfile[0] == '-' && compfile[1] == '\0') {
/* copy standard input to temporary file */
strncpy (infile, m_mktemp(invo_name, NULL, &fp), sizeof(infile));
while (fgets (buffer, BUFSIZ, stdin))
fputs (buffer, fp);
fclose (fp);
unlink_infile = 1;
/* build the content structures for MIME message */
ct = build_mime (infile);
cts[0] = ct;
cts[1] = NULL;
/* output MIME message to this temporary file */
strncpy (outfile, m_mktemp(invo_name, NULL, &fp_out), sizeof(outfile));
unlink_outfile = 1;
/* output the message */
output_message_fp (ct, fp_out, outfile);
fclose(fp_out);
/* output the temp file to standard output */
if ((fp = fopen (outfile, "r")) == NULL)
adios (outfile, "unable to open");
while (fgets (buffer, BUFSIZ, fp))
fputs (buffer, stdout);
fclose (fp);
unlink (infile);
unlink_infile = 0;
unlink (outfile);
unlink_outfile = 0;
free_content (ct);
done (0);
}
/*
* Process the composition file from a file.
*/
/* build the content structures for MIME message */
ct = build_mime (compfile);
cts[0] = ct;
cts[1] = NULL;
/* output MIME message to this temporary file */
strncpy(outfile, m_mktemp2(compfile, invo_name, NULL, &fp_out),
sizeof(outfile));
unlink_outfile = 1;
/* output the message */
output_message_fp (ct, fp_out, outfile);
fclose(fp_out);
/*
* List the message info
*/
if (listsw)
list_all_messages (cts, headsw, sizesw, verbosw, debugsw);
/* Rename composition draft */
snprintf (buffer, sizeof(buffer), "%s.orig", m_backup (compfile));
if (rename (compfile, buffer) == NOTOK) {
adios (compfile, "unable to rename comp draft %s to", buffer);
}
/* Rename output file to take its place */
if (rename (outfile, compfile) == NOTOK) {
advise (outfile, "unable to rename output %s to", compfile);
rename (buffer, compfile);
done (1);
}
unlink_outfile = 0;
free_content (ct);
done (0);
return 1;
}
int
map_write (char *mailbox, int md, int id, long last, off_t start,
off_t stop, long pos, int size, int noisy)
{
register int i;
int clear, fd, td;
char *file;
register struct drop *dp;
struct drop d1, d2, *rp;
register FILE *fp;
struct stat st;
if ((fd = map_open (file = map_name (mailbox), md)) == NOTOK)
return NOTOK;
if ((fstat (fd, &st) == OK) && (st.st_size > 0))
clear = 0;
else
clear = 1;
if (!clear && map_chk (file, fd, &d1, pos, noisy)) {
(void) m_unlink (file);
mbx_close (file, fd);
if ((fd = map_open (file, md)) == NOTOK)
return NOTOK;
clear++;
}
if (clear) {
if ((td = dup (md)) == NOTOK || (fp = fdopen (td, "r")) == NULL) {
if (noisy)
admonish (file, "unable to %s", td != NOTOK ? "fdopen" : "dup");
if (td != NOTOK)
close (td);
mbx_close (file, fd);
return NOTOK;
}
switch (i = mbx_read (fp, 0, &rp, noisy)) {
case NOTOK:
fclose (fp);
mbx_close (file, fd);
return NOTOK;
case OK:
fclose (fp);
break;
default:
d1.d_id = 0;
for (dp = rp; i-- >0; dp++) {
if (dp->d_start == start)
dp->d_id = id;
lseek (fd, (off_t) (++d1.d_id * sizeof(*dp)), SEEK_SET);
if (write (fd, (char *) dp, sizeof(*dp)) != sizeof(*dp)) {
if (noisy)
admonish (file, "write error");
mbx_close (file, fd);
fclose (fp);
return NOTOK;
}
}
free ((char *) rp);
fclose (fp);
break;
}
}
else {
if (last == 0)
last = d1.d_start;
dp = &d2;
dp->d_id = id;
dp->d_size = (long) (size ? size : mbx_size (fd, start, stop));
dp->d_start = start;
dp->d_stop = stop;
lseek (fd, (off_t) (++d1.d_id * sizeof(*dp)), SEEK_SET);
if (write (fd, (char *) dp, sizeof(*dp)) != sizeof(*dp)) {
if (noisy)
admonish (file, "write error");
mbx_close (file, fd);
return NOTOK;
}
}
dp = &d1;
dp->d_size = DRVRSN;
dp->d_start = (long) last;
dp->d_stop = lseek (md, (off_t) 0, SEEK_CUR);
lseek (fd, (off_t) 0, SEEK_SET);
if (write (fd, (char *) dp, sizeof(*dp)) != sizeof(*dp)) {
if (noisy)
admonish (file, "write error");
mbx_close (file, fd);
return NOTOK;
}
mbx_close (file, fd);
return OK;
}
int
mbx_read (FILE *fp, long pos, struct drop **drops, int noisy)
{
register int len, size;
register long ld1, ld2;
register char *bp;
char buffer[BUFSIZ];
register struct drop *cp, *dp, *ep, *pp;
pp = (struct drop *) calloc ((size_t) (len = MAXFOLDER), sizeof(*dp));
if (pp == NULL) {
if (noisy)
admonish (NULL, "unable to allocate drop storage");
return NOTOK;
}
ld1 = (long) strlen (mmdlm1);
ld2 = (long) strlen (mmdlm2);
fseek (fp, pos, SEEK_SET);
for (ep = (dp = pp) + len - 1; fgets (buffer, sizeof(buffer), fp);) {
size = 0;
if (strcmp (buffer, mmdlm1) == 0)
pos += ld1, dp->d_start = (long) pos;
else {
dp->d_start = (long)pos , pos += (long) strlen (buffer);
for (bp = buffer; *bp; bp++, size++)
if (*bp == '\n')
size++;
}
while (fgets (buffer, sizeof(buffer), fp) != NULL)
if (strcmp (buffer, mmdlm2) == 0)
break;
else {
pos += (long) strlen (buffer);
for (bp = buffer; *bp; bp++, size++)
if (*bp == '\n')
size++;
}
if (dp->d_start != (long) pos) {
dp->d_id = 0;
dp->d_size = (long) size;
dp->d_stop = pos;
dp++;
}
pos += ld2;
if (dp >= ep) {
register int curlen = dp - pp;
cp = (struct drop *) mh_xrealloc ((char *) pp,
(size_t) (len += MAXFOLDER) * sizeof(*pp));
dp = cp + curlen, ep = (pp = cp) + len - 1;
}
}
if (dp == pp)
free ((char *) pp);
else
*drops = pp;
return (dp - pp);
}
static int
advance (char *alp, char *aep)
{
register unsigned char *lp, *ep, *curlp;
lp = (unsigned char *)alp;
ep = (unsigned char *)aep;
for (;;)
switch (*ep++) {
case CCHR:
if (*ep++ == *lp++ || ep[-1] == cc[lp[-1]])
continue;
return 0;
case CDOT:
if (*lp++)
continue;
return 0;
case CDOL:
if (*lp == 0)
continue;
return 0;
case CEOF:
return 1;
case CCL:
if (cclass (ep, *lp++, 1)) {
ep += *ep + 1;
continue;
}
return 0;
case NCCL:
if (cclass (ep, *lp++, 0)) {
ep += *ep + 1;
continue;
}
return 0;
case CDOT | STAR:
curlp = lp;
while (*lp++)
continue;
goto star;
case CCHR | STAR:
curlp = lp;
while (*lp++ == *ep || cc[lp[-1]] == *ep)
continue;
ep++;
goto star;
case CCL | STAR:
case NCCL | STAR:
curlp = lp;
while (cclass (ep, *lp++, ep[-1] == (CCL | STAR)))
continue;
ep += *ep + 1;
goto star;
star:
do {
lp--;
if (advance (lp, ep))
return (1);
} while (lp > curlp);
return 0;
default:
admonish (NULL, "advance() botch -- you lose big");
return 0;
}
}
static void
copy_draft (int out, char *digest, char *file, int volume, int issue, int dashstuff)
{
int fd,i, msgcnt, msgnum;
int len, buflen;
register char *bp, *msgnam;
char buffer[BUFSIZ];
msgcnt = 1;
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
if (is_selected (mp, msgnum)) {
if (digest) {
strncpy (buffer, msgnum == mp->lowsel ? delim3 : delim4,
sizeof(buffer));
} else {
/* Get buffer ready to go */
bp = buffer;
buflen = sizeof(buffer);
strncpy (bp, "\n-------", buflen);
len = strlen (bp);
bp += len;
buflen -= len;
if (msgnum == mp->lowsel) {
snprintf (bp, buflen, " Forwarded Message%s",
mp->numsel > 1 ? "s" : "");
} else {
snprintf (bp, buflen, " Message %d", msgcnt);
}
len = strlen (bp);
bp += len;
buflen -= len;
strncpy (bp, "\n\n", buflen);
}
write (out, buffer, strlen (buffer));
if ((fd = open (msgnam = m_name (msgnum), O_RDONLY)) == NOTOK) {
admonish (msgnam, "unable to read message");
continue;
}
/*
* Copy the message. Add RFC934 quoting (dashstuffing)
* unless given the -nodashstuffing flag.
*/
if (dashstuff >= 0)
cpydgst (fd, out, msgnam, file);
else
cpydata (fd, out, msgnam, file);
close (fd);
msgcnt++;
}
}
if (digest) {
strncpy (buffer, delim4, sizeof(buffer));
} else {
snprintf (buffer, sizeof(buffer), "\n------- End of Forwarded Message%s\n",
mp->numsel > 1 ? "s" : "");
}
write (out, buffer, strlen (buffer));
if (digest) {
snprintf (buffer, sizeof(buffer), "End of %s Digest [Volume %d Issue %d]\n",
digest, volume, issue);
i = strlen (buffer);
for (bp = buffer + i; i > 1; i--)
*bp++ = '*';
*bp++ = '\n';
*bp = 0;
write (out, buffer, strlen (buffer));
}
}
int
main (int argc, char **argv)
{
int publicsw = -1, zerosw = 1, seqp = 0, vecp = 0;
int quietsw = 0;
int lo, hi, msgnum;
char *maildir, *folder = NULL, buf[100];
char *cp, **argp, **arguments;
char *seqs[NUMATTRS + 1], *vec[MAXARGS];
struct msgs_array msgs = { 0, 0, NULL };
struct msgs *mp;
register FILE *fp;
done=putzero_done;
#ifdef LOCALE
setlocale(LC_ALL, "");
#endif
invo_name = r1bindex (argv[0], '/');
/* read user profile/context */
context_read();
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
while ((cp = *argp++)) {
if (*cp == '-') {
if (*++cp == '-') {
vec[vecp++] = --cp;
goto pattern;
}
switch (smatch (cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
listsw = 0; /* HACK */
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [+folder] [msgs] [switches]",
invo_name);
print_help (buf, switches, 1);
listsw = 0; /* HACK */
done (1);
case VERSIONSW:
print_version(invo_name);
listsw = 0; /* HACK */
done (1);
case CCSW:
case DATESW:
case FROMSW:
case SUBJSW:
case TOSW:
case DATFDSW:
case AFTRSW:
case BEFRSW:
case SRCHSW:
vec[vecp++] = --cp;
pattern:
if (!(cp = *argp++))/* allow -xyz arguments */
adios (NULL, "missing argument to %s", argp[-2]);
vec[vecp++] = cp;
continue;
case OTHRSW:
adios (NULL, "internal error!");
case ANDSW:
case ORSW:
case NOTSW:
case LBRSW:
case RBRSW:
vec[vecp++] = --cp;
continue;
case SEQSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
/* check if too many sequences specified */
if (seqp >= NUMATTRS)
adios (NULL, "too many sequences (more than %d) specified", NUMATTRS);
if (!seq_nameok (cp))
done (1);
seqs[seqp++] = cp;
continue;
case PUBLSW:
publicsw = 1;
continue;
case NPUBLSW:
publicsw = 0;
continue;
case ZEROSW:
zerosw++;
continue;
case NZEROSW:
zerosw = 0;
continue;
case LISTSW:
listsw = 1;
continue;
case NLISTSW:
listsw = 0;
continue;
case QUIETSW:
quietsw = 1;
continue;
}
}
if (*cp == '+' || *cp == '@') {
if (folder)
adios (NULL, "only one folder at a time!");
else
folder = pluspath (cp);
} else
app_msgarg(&msgs, cp);
}
vec[vecp] = NULL;
if (!context_find ("path"))
free (path ("./", TFOLDER));
/*
* If we didn't specify which messages to search,
* then search the whole folder.
*/
if (!msgs.size)
app_msgarg(&msgs, "all");
if (!folder)
folder = getfolder (1);
maildir = m_maildir (folder);
if (chdir (maildir) == NOTOK)
adios (maildir, "unable to change directory to");
/* read folder and create message structure */
if (!(mp = folder_read (folder)))
adios (NULL, "unable to read folder %s", folder);
/* check for empty folder */
if (mp->nummsg == 0)
adios (NULL, "no messages in %s", folder);
/* parse all the message ranges/sequences and set SELECTED */
for (msgnum = 0; msgnum < msgs.size; msgnum++)
if (!m_convert (mp, msgs.msgs[msgnum]))
done (1);
seq_setprev (mp); /* set the previous-sequence */
/*
* If we aren't saving the results to a sequence,
* we default to list the results.
*/
if (listsw == -1)
listsw = !seqp;
if (publicsw == 1 && is_readonly(mp))
adios (NULL, "folder %s is read-only, so -public not allowed", folder);
if (!pcompile (vec, NULL))
done (1);
lo = mp->lowsel;
hi = mp->hghsel;
/* If printing message numbers to standard out, force line buffering on.
*/
if (listsw)
setvbuf (stdout, NULL, _IOLBF, 0);
/*
* Scan through all the SELECTED messages and check for a
* match. If the message does not match, then unselect it.
*/
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
if (is_selected (mp, msgnum)) {
if ((fp = fopen (cp = m_name (msgnum), "r")) == NULL)
admonish (cp, "unable to read message");
if (fp && pmatches (fp, msgnum, 0L, 0L)) {
if (msgnum < lo)
lo = msgnum;
if (msgnum > hi)
hi = msgnum;
if (listsw)
printf ("%s\n", m_name (msgnum));
} else {
/* if it doesn't match, then unselect it */
unset_selected (mp, msgnum);
mp->numsel--;
}
if (fp)
fclose (fp);
}
}
mp->lowsel = lo;
mp->hghsel = hi;
if (mp->numsel <= 0 && !quietsw)
adios (NULL, "no messages match specification");
seqs[seqp] = NULL;
/*
* Add the matching messages to sequences
*/
for (seqp = 0; seqs[seqp]; seqp++)
if (!seq_addsel (mp, seqs[seqp], publicsw, zerosw))
done (1);
/*
* Print total matched if not printing each matched message number.
*/
if (!listsw) {
printf ("%d hit%s\n", mp->numsel, mp->numsel == 1 ? "" : "s");
}
context_replace (pfolder, folder); /* update current folder */
seq_save (mp); /* synchronize message sequences */
context_save (); /* save the context file */
folder_free (mp); /* free folder/message structure */
done (0);
return 1;
}
void
readconfig (struct node **npp, FILE *ib, char *file, int ctx)
{
register int state;
register char *cp;
char name[NAMESZ], field[BUFSIZ];
register struct node *np;
register struct procstr *ps;
if (npp == NULL && (npp = opp) == NULL) {
admonish (NULL, "bug: readconfig called but pump not primed");
return;
}
for (state = FLD;;) {
switch (state = m_getfld (state, name, field, sizeof(field), ib)) {
case FLD:
case FLDPLUS:
case FLDEOF:
np = (struct node *) mh_xmalloc (sizeof(*np));
*npp = np;
*(npp = &np->n_next) = NULL;
np->n_name = getcpy (name);
if (state == FLDPLUS) {
cp = getcpy (field);
while (state == FLDPLUS) {
state = m_getfld (state, name, field, sizeof(field), ib);
cp = add (field, cp);
}
np->n_field = trimcpy (cp);
free (cp);
} else {
np->n_field = trimcpy (field);
}
np->n_context = ctx;
/*
* Now scan the list of `procs' and link in the
* field value to the global variable.
*/
for (ps = procs; ps->procname; ps++)
if (strcmp (np->n_name, ps->procname) == 0) {
*ps->procnaddr = np->n_field;
break;
}
if (state == FLDEOF)
break;
continue;
case BODY:
case BODYEOF:
adios (NULL, "no blank lines are permitted in %s", file);
case FILEEOF:
break;
default:
adios (NULL, "%s is poorly formatted", file);
}
break;
}
opp = npp;
}
