-
-/*
- * mhcachesbr.c -- routines to manipulate the MIME content cache
+/* mhcachesbr.c -- routines to manipulate the MIME content cache
*
* This code is Copyright (c) 2002, by the authors of nmh. See the
* COPYRIGHT file in the root directory of the nmh distribution for
#include <h/mh.h>
#include <fcntl.h>
-#include <h/signals.h>
#include <h/md5.h>
-#include <errno.h>
-#include <setjmp.h>
-#include <signal.h>
#include <h/mts.h>
#include <h/tws.h>
#include <h/mime.h>
#include <h/mhparse.h>
#include <h/mhcachesbr.h>
#include <h/utils.h>
+#include "mhmisc.h"
+#include "sbr/lock_file.h"
+#include "sbr/m_mktemp.h"
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
#endif
#include <time.h>
-extern int debugsw;
+#define X(sw, minchars, id) { sw, minchars, id },
+DEFINE_SWITCH_ARRAY(CACHE, caches);
+#undef X
+struct swit *cache_policy = caches;
-extern pid_t xpid; /* mhshowsbr.c or mhbuildsbr.c */
+extern int debugsw;
/* cache policies */
int rcachesw = CACHE_ASK;
char *cache_public;
char *cache_private;
-
-/* mhparse.c (OR) mhbuildsbr.c */
-int pidcheck (int);
-
-/* mhmisc.c */
-int part_ok (CT, int);
-int type_ok (CT, int);
-int make_intermediates (char *);
-void content_error (char *, CT, char *, ...);
-void flush_errors (void);
-
-/*
- * prototypes
- */
-void cache_all_messages (CT *);
-int find_cache (CT, int, int *, char *, char *, int);
-
/*
* static prototypes
*/
{
int cachetype;
char *file, cachefile[BUFSIZ];
- CE ce = ct->c_cefile;
+ CE ce = &ct->c_cefile;
if (!ct->c_id) {
- advise (NULL, "no %s: field in %s", ID_FIELD, ct->c_file);
+ inform("no %s: field in %s", ID_FIELD, ct->c_file);
return;
}
if (!ce) {
- advise (NULL, "unable to decode %s", ct->c_file);
+ inform("unable to decode %s", ct->c_file);
return;
}
-/* THIS NEEDS TO BE FIXED */
-#if 0
- if (ct->c_ceopenfnx == openMail) {
- advise (NULL, "a radish may no know Greek, but I do...");
- return;
- }
-#endif
-
if (find_cache (NULL, wcachesw != CACHE_NEVER ? wcachesw : CACHE_ASK,
&cachetype, ct->c_id, cachefile, sizeof(cachefile))
== NOTOK) {
- advise (NULL, "unable to cache %s's contents", ct->c_file);
+ inform("unable to cache %s's contents", ct->c_file);
return;
}
if (wcachesw != CACHE_NEVER && wcachesw != CACHE_ASK) {
while ((cc = fread (buffer, sizeof(*buffer), sizeof(buffer), gp))
> 0)
- fwrite (buffer, sizeof(*buffer), cc, fp);
+ if ((int) fwrite (buffer, sizeof(*buffer), cc, fp) < cc) {
+ advise ("cache_content", "fwrite");
+ }
fflush (fp);
if (ferror (gp)) {
admonish (ce->ce_file, "error reading");
- unlink (cachefile);
+ (void) m_unlink (cachefile);
} else {
if (ferror (fp)) {
admonish (cachefile, "error writing");
- unlink (cachefile);
+ (void) m_unlink (cachefile);
}
}
fclose (fp);
case CACHE_PUBLIC:
if (cache_private
&& !writing
- && find_cache_aux (writing ? 2 : 0, cache_private, id,
+ && find_cache_aux (0, cache_private, id,
buffer, buflen) == OK) {
if (access (buffer, R_OK) != NOTOK) {
got_private:
int len, buflen;
char *bp, query[BUFSIZ];
- if (xpid) {
- if (xpid < 0)
- xpid = -xpid;
- pidcheck (pidwait (xpid, NOTOK));
- xpid = 0;
- }
-
/* Get buffer ready to go */
bp = query;
buflen = sizeof(query);
/* Now, construct query */
if (writing) {
- snprintf (bp, buflen, "Make cached, publically-accessible copy");
+ snprintf (bp, buflen, "Make cached, publicly-accessible copy");
} else {
struct stat st;
snprintf (bp, buflen, "\n in file %s? ", buffer);
/* Now, check answer */
- if (!getanswer (query))
+ if (!read_yes_or_no_if_tty (query))
status = NOTOK;
}
if (status == OK && writing) {
if (*writing && strchr(buffer, '/'))
make_intermediates (buffer);
- unlink (buffer);
+ (void) m_unlink (buffer);
}
free (id);
int mask, usemap;
char mapfile[BUFSIZ], mapname[BUFSIZ];
FILE *fp;
+ int failed_to_lock = 0;
static int partno, pid;
static time_t clock = 0;
make_intermediates (mapfile);
mask = umask (writing == 2 ? 0077 : 0);
- if (!(fp = lkfopen (mapfile, "a")) && errno == ENOENT) {
+ if (!(fp = lkfopendata (mapfile, "a", &failed_to_lock)) && errno == ENOENT) {
int fd;
if ((fd = creat (mapfile, 0666)) != NOTOK) {
close (fd);
- fp = lkfopen (mapfile, "a");
+ fp = lkfopendata (mapfile, "a", &failed_to_lock);
+ if (failed_to_lock) {
+ adios (mapfile, "failed to lock");
+ }
}
}
umask (mask);
if (!fp)
return NOTOK;
fprintf (fp, "%s: %s\n", mapname, id);
- lkfclose (fp, mapfile);
+ lkfclosedata (fp, mapfile);
done_map:
if (*mapname == '/')
find_cache_aux2 (char *mapfile, char *id, char *mapname, int namelen)
{
int state;
- char buf[BUFSIZ], name[NAMESZ];
+ char buf[NMH_BUFSIZ], name[NAMESZ];
FILE *fp;
+ m_getfld_state_t gstate;
+ int failed_to_lock = 0;
- if (!(fp = lkfopen (mapfile, "r")))
+ if (!(fp = lkfopendata (mapfile, "r", &failed_to_lock)))
return NOTOK;
- for (state = FLD;;) {
+ gstate = m_getfld_state_init(fp);
+ for (;;) {
int result;
char *cp, *dp;
+ int bufsz = sizeof buf;
- switch (state = m_getfld (state, name, buf, sizeof(buf), fp)) {
+ switch (state = m_getfld2(&gstate, name, buf, &bufsz)) {
case FLD:
case FLDPLUS:
- case FLDEOF:
strncpy (mapname, name, namelen);
if (state != FLDPLUS)
cp = buf;
else {
- cp = add (buf, NULL);
+ cp = mh_xstrdup(buf);
while (state == FLDPLUS) {
- state = m_getfld (state, name, buf, sizeof(buf), fp);
+ bufsz = sizeof buf;
+ state = m_getfld2(&gstate, name, buf, &bufsz);
cp = add (buf, cp);
}
}
result = strcmp (id, dp);
free (dp);
if (result == 0) {
- lkfclose (fp, mapfile);
+ lkfclosedata (fp, mapfile);
return OK;
}
- if (state != FLDEOF)
- continue;
- /* else fall... */
+ continue;
case BODY:
- case BODYEOF:
case FILEEOF:
default:
break;
}
break;
}
+ m_getfld_state_destroy (&gstate);
- lkfclose (fp, mapfile);
+ lkfclosedata (fp, mapfile);
return NOTOK;
}
projects / nmh / blobdiff