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; }