source: trunk/third/nmh/uip/mhtest.c @ 12455

/*
 * mhtest.c -- test harness for MIME routines
 *
 * $Id: mhtest.c,v 1.1.1.1 1999-02-07 18:14:15 danw Exp $
 */

#include <h/mh.h>
#include <fcntl.h>
#include <h/signals.h>
#include <h/md5.h>
#include <errno.h>
#include <signal.h>
#include <zotnet/mts/mts.h>
#include <zotnet/tws/tws.h>
#include <h/mime.h>
#include <h/mhparse.h>
#include <h/mhcachesbr.h>

#ifdef HAVE_SYS_WAIT_H
# include <sys/wait.h>
#endif

/*
 * We allocate space for message names (msgs array)
 * this number of elements at a time.
 */
#define MAXMSGS  256


static struct swit switches[] = {
#define CHECKSW                 0
    { "check", 0 },
#define NCHECKSW                1
    { "nocheck", 0 },
#define VERBSW                  2
    { "verbose", 0 },
#define NVERBSW                 3
    { "noverbose", 0 },
#define FILESW                  4
    { "file file", 0 },
#define OUTFILESW               5
    { "outfile file", 0 },
#define PARTSW                  6
    { "part number", 0 },
#define TYPESW                  7
    { "type content", 0 },
#define RCACHESW                8
    { "rcache policy", 0 },
#define WCACHESW                9
    { "wcache policy", 0 },
#define VERSIONSW              10
    { "version", 0 },
#define HELPSW                 11
    { "help", 4 },

/*
 * switches for debugging
 */
#define DEBUGSW                12
    { "debug", -5 },
    { NULL, 0 }
};


extern int errno;

int ebcdicsw = 0;       /* hack for linking purposes */

/* mhparse.c */
extern int checksw;
extern char *tmp;       /* directory to place temp files */

/* mhcachesbr.c */
extern int rcachesw;
extern int wcachesw;
extern char *cache_public;
extern char *cache_private;

/* mhmisc.c */
extern int npart;
extern int ntype;
extern char *parts[NPARTS + 1];
extern char *types[NTYPES + 1];
extern int userrs;

/*
 * This is currently needed to keep mhparse happy.
 * This needs to be changed.
 */
pid_t xpid  = 0;

int debugsw = 0;
int verbosw = 0;

/* The list of top-level contents to display */
CT *cts = NULL;

#define quitser pipeser

/* mhparse.c */
CT parse_mime (char *);

/* mhoutsbr.c */
int output_message (CT, char *);

/* mhmisc.c */
int part_ok (CT, int);
int type_ok (CT, int);
void set_endian (void);
void flush_errors (void);

/* mhfree.c */
void free_content (CT);

/*
 * static prototypes
 */
static int write_content (CT *, char *);
static RETSIGTYPE pipeser (int);


int
main (int argc, char **argv)
{
    int nummsgs, maxmsgs, msgnum, *icachesw;
    char *cp, *file = NULL, *folder = NULL;
    char *maildir, buf[100], *outfile = NULL;
    char **argp, **arguments, **msgs;
    struct msgs *mp = NULL;
    CT ct, *ctp;

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

    /*
     * Allocate the initial space to record message
     * names, ranges, and sequences.
     */
    nummsgs = 0;
    maxmsgs = MAXMSGS;
    if (!(msgs = (char **) malloc ((size_t) (maxmsgs * sizeof(*msgs)))))
        adios (NULL, "unable to allocate storage");

    /*
     * 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 (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 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 DEBUGSW:
                debugsw = 1;
                continue;
            }
        }
        if (*cp == '+' || *cp == '@') {
            if (folder)
                adios (NULL, "only one folder at a time!");
            else
                folder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
        } else {
            /*
             * Check if we need to allocate more space
             * for message names/ranges/sequences.
             */
            if (nummsgs >= maxmsgs) {
                maxmsgs += MAXMSGS;
                if (!(msgs = (char **) realloc (msgs,
                        (size_t) (maxmsgs * sizeof(*msgs)))))
                    adios (NULL, "unable to reallocate msgs storage");
            }
            msgs[nummsgs++] = cp;
        }
    }

    /* null terminate the list of acceptable parts/types */
    parts[npart] = NULL;
    types[ntype] = NULL;

    set_endian ();

    if (outfile == NULL)
        adios (NULL, "must specify output file");

    /* 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 specified,
     * then 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));

    if (file && nummsgs)
        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;
    } else {
        /*
         * message(s) are coming from a folder
         */
        if (!nummsgs)
            msgs[nummsgs++] = "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)))
            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 < nummsgs; msgnum++)
            if (!m_convert (mp, 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 (!*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();
        }
    }

    /*
     * Write the content to a file
     */
    write_content (cts, outfile);

    /* 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 (0);
    /* NOTREACHED */
}


static int
write_content (CT *cts, char *outfile)
{
    CT ct, *ctp;

    for (ctp = cts; *ctp; ctp++) {
        ct = *ctp;
        output_message (ct, outfile);
    }

    flush_errors ();
    return OK;
}


static RETSIGTYPE
pipeser (int i)
{
    if (i == SIGQUIT) {
        unlink ("core");
        fflush (stdout);
        fprintf (stderr, "\n");
        fflush (stderr);
    }

    done (1);
    /* NOTREACHED */
}


void
done (int status)
{
    CT *ctp;

    if ((ctp = cts))
        for (; *ctp; ctp++)
            free_content (*ctp);

    exit (status);
}