mshcmds.c

早期freebsd实现

    "nofast", 0,
#define	FLHDSW	3
    "header", 0,
#define	FLNHDSW	4
    "noheader", 0,
#define	FLPKSW	5
    "pack", 0,
#define	FLNPKSW	6
    "nopack", 0,
#define	FLRCSW	7
    "recurse", 0,
#define	FLNRCSW	8
    "norecurse", 0,
#define	FLTLSW	9
    "total", 0,
#define	FLNTLSW	10
    "nototal", 0,
#define	FLPRSW	11
    "print", 0,
#define	FLPUSW	12
    "push", 0,
#define	FLPOSW	13
    "pop", 0,
#define	FLLISW	14
    "list", 0,
#define	FLHELP	15
    "help", 4,

    NULL, 0
};

/*  */

foldcmd (args)
char  **args;
{
    int     fastsw = 0,
            headersw = 0,
	    packsw = 0,
	    hole,
	    msgnum;
    char   *cp,
           *folder = NULL,
           *msg = NULL,
            buf[BUFSIZ],
	  **vec = args;

    if (args == NULL)
	goto fast;

    while (cp = *args++) {
	if (*cp == '-')
	    switch (smatch (++cp, foldswit)) {
		case AMBIGSW: 
		    ambigsw (cp, foldswit);
		    return;
		case UNKWNSW: 
		    fprintf (stderr, "-%s unknown\n", cp);
		    return;
		case FLHELP: 
		    (void) sprintf (buf, "%s [+folder] [msg] [switches]",
			    cmd_name);
		    help (buf, foldswit);
		    return;

		case FLALSW:	/* not implemented */
		case FLRCSW: 
		case FLNRCSW: 
		case FLTLSW: 
		case FLNTLSW: 
		case FLPRSW:
		case FLPUSW:
		case FLPOSW:
		case FLLISW:
		    continue;

		case FLFASW: 
		    fastsw++;
		    continue;
		case FLNFASW: 
		    fastsw = 0;
		    continue;
		case FLHDSW: 
		    headersw++;
		    continue;
		case FLNHDSW: 
		    headersw = 0;
		    continue;
		case FLPKSW: 
		    packsw++;
		    continue;
		case FLNPKSW: 
		    packsw = 0;
		    continue;
	    }
	if (*cp == '+' || *cp == '@')
	    if (folder) {
		advise (NULLCP, "only one folder at a time!\n");
		return;
	    }
	    else
		folder = fmsh ? path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF)
			    : cp + 1;
	else
	    if (msg) {
		advise (NULLCP, "only one message at a time!\n");
		return;
	    }
	    else
		msg = cp;
    }

    if (folder) {
	if (*folder == 0) {
	    advise (NULLCP, "null folder names are not permitted");
	    return;
	}
	if (fmsh) {
	    if (access (m_maildir (folder), 04) == NOTOK) {
		advise (folder, "unable to read");
		return;
	    }
	}
	else {
	    (void) strcpy (buf, folder);
	    if (expand (buf) == NOTOK)
		return;
	    folder = buf;
	    if (access (folder, 04) == NOTOK) {
		advise (folder, "unable to read");
		return;
	    }
	}
	m_reset ();

	if (fmsh)
	    fsetup (folder);
	else
	    setup (folder);
	readids (0);
	display_info (0);
    }

    if (msg) {
	if (!m_convert (mp, msg))
	    return;
	m_setseq (mp);

	if (mp -> numsel > 1) {
	    advise (NULLCP, "only one message at a time!");
	    return;
	}
	m_setcur (mp, mp -> hghsel);
    }

    if (packsw) {
	if (fmsh) {
	    forkcmd (vec, cmd_name);
	    return;
	}

	if (mp -> lowmsg > 1 && (mp = m_remsg (mp, 1, mp -> hghmsg)) == NULL)
	    adios (NULLCP, "unable to allocate folder storage");
	for (msgnum = mp -> lowmsg, hole = 1; msgnum <= mp -> hghmsg; msgnum++)
	    if (mp -> msgstats[msgnum] & EXISTS) {
		if (msgnum != hole) {
		    Msgs[hole].m_bboard_id = Msgs[msgnum].m_bboard_id;
		    Msgs[hole].m_top = Msgs[msgnum].m_top;
		    Msgs[hole].m_start = Msgs[msgnum].m_start;
		    Msgs[hole].m_stop = Msgs[msgnum].m_stop;
		    Msgs[hole].m_scanl = NULL;
		    if (Msgs[msgnum].m_scanl) {
			free (Msgs[msgnum].m_scanl);
			Msgs[msgnum].m_scanl = NULL;
		    }
		    mp -> msgstats[hole] = mp -> msgstats[msgnum];
		    if (mp -> curmsg == msgnum)
			m_setcur (mp, hole);
		}
		hole++;
	    }
	if (mp -> nummsg > 0) {
	    mp -> lowmsg = 1;
	    mp -> hghmsg = hole - 1;
	}
	mp -> msgflags |= MODIFIED;
	modified++;
    }

fast: ;
    if (fastsw)
	printf ("%s\n", fmsh ? fmsh : mp -> foldpath);
    else {
	if (headersw)
	    printf ("\t\tFolder  %*s# of messages (%*srange%*s); cur%*smsg\n",
		DMAXFOLDER, "", DMAXFOLDER - 2, "", DMAXFOLDER - 2, "",
		DMAXFOLDER - 2, "");
	printf (args ? "%22s  " : "%s ", fmsh ? fmsh : mp -> foldpath);
	if (mp -> hghmsg == 0)
	    printf ("has   no messages%*s",
		    mp -> msgflags & OTHERS ? DMAXFOLDER * 2 + 4 : 0, "");
	else {
	    printf ("has %*d message%s (%*d-%*d)",
		    DMAXFOLDER, mp -> nummsg, mp -> nummsg != 1 ? "s" : "",
		    DMAXFOLDER, mp -> lowmsg, DMAXFOLDER, mp -> hghmsg);
	    if (mp -> curmsg >= mp -> lowmsg
		    && mp -> curmsg <= mp -> hghmsg)
		printf ("; cur=%*d", DMAXFOLDER, mp -> curmsg);
	}
	printf (".\n");
    }
}

/*  */

#ifndef	MIME
#define	MIMEminc(a)	(a)
#else	/* MIME */
#define	MIMEminc(a)	0
#endif	/* MIME */

static struct swit forwswit[] = {
#define	FOANSW	0
    "annotate", 0,
#define	FONANSW	1
    "noannotate", 0,
#define	FODFSW	2
    "draftfolder +folder", 0,
#define	FODMSW	3
    "draftmessage msg", 0,
#define	FONDFSW	4
    "nodraftfolder", 0,
#define	FOEDTSW	5
    "editor editor", 0,
#define	FONEDSW	6
    "noedit", 0,
#define	FOFTRSW	7
    "filter filterfile", 0,
#define	FOFRMSW	8
    "form formfile", 0,
#define	FOFTSW	9
    "format", 5,
#define	FONFTSW	10
    "noformat", 7,
#define	FOINSW	11
    "inplace", 0,
#define	FONINSW	12
    "noinplace", 0,
#define	FOMISW	13
    "mime", MIMEminc(-4),
#define	FONMISW	14
    "nomime", MIMEminc(-6),
#define	FOWHTSW	15
    "whatnowproc program", 0,
#define	FONWTSW	16
    "nowhatnow", 0,
#define	FOHELP	17
    "help", 4,

    NULL, 0
};

/*  */

forwcmd (args)
char  **args;
{
    int	    msgp = 0,
            vecp = 1,
            msgnum;
    char   *cp,
           *filter = NULL,
            buf[BUFSIZ],
           *msgs[MAXARGS],
           *vec[MAXARGS];

    if (fmsh) {
	forkcmd (args, cmd_name);
	return;
    }

    while (cp = *args++) {
	if (*cp == '-')
	    switch (smatch (++cp, forwswit)) {
		case AMBIGSW: 
		    ambigsw (cp, forwswit);
		    return;
		case UNKWNSW: 
		    fprintf (stderr, "-%s unknown\n", cp);
		    return;
		case FOHELP: 
		    (void) sprintf (buf, "%s [msgs] [switches]", cmd_name);
		    help (buf, forwswit);
		    return;

		case FOANSW:	/* not implemented */
		case FONANSW: 
		case FOINSW: 
		case FONINSW: 
		case FOMISW: 
		case FONMISW: 
		    continue;

		case FONDFSW:
		case FONEDSW:
		case FONWTSW:
		    vec[vecp++] = --cp;
		    continue;

		case FOEDTSW: 
		case FOFRMSW: 
		case FODFSW:
		case FODMSW:
		case FOWHTSW:
		    vec[vecp++] = --cp;
		    if (!(cp = *args++) || *cp == '-') {
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    vec[vecp++] = cp;
		    continue;
		case FOFTRSW: 
		    if (!(filter = *args++) || *filter == '-') {
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    continue;
		case FOFTSW: 
		    if (access (filter = myfilter, 04) == NOTOK) {
			advise (filter, "unable to read default filter file");
			return;
		    }
		    continue;
		case FONFTSW: 
		    filter = NULL;
		    continue;
	    }
	if (*cp == '+' || *cp == '@') {
	    advise (NULLCP, "sorry, no folders allowed!");
	    return;
	}
	else
	    msgs[msgp++] = cp;
    }

					/* foil search of .mh_profile */
    (void) sprintf (buf, "%sXXXXXX", invo_name);
    vec[0] = (char *)mktemp (buf);
    vec[vecp++] = "-file";
    vec[vecp] = NULL;
    if (!msgp)
	msgs[msgp++] = "cur";
    for (msgnum = 0; msgnum < msgp; msgnum++)
	if (!m_convert (mp, msgs[msgnum]))
	    return;
    m_setseq (mp);

    if (filter) {
	(void) strcpy (buf, filter);
	if (expand (buf) == NOTOK)
	    return;
	if (access (filter = getcpy (libpath (buf)), 04) == NOTOK) {
	    advise (filter, "unable to read");
	    free (filter);
	    return;
	}
    }
    forw (cmd_name, filter, vecp, vec);
    m_setcur (mp, mp -> hghsel);
    if (filter)
	free (filter);
}

/*  */

static	forw (proc, filter, vecp, vec)
int     vecp;
char   *proc,
       *filter,
      **vec;
{
    int     i,
            child_id,
            msgnum,
            msgcnt;
    char    tmpfil[80],
           *args[MAXARGS];
    FILE   *out;

    (void) strcpy (tmpfil, m_tmpfil (invo_name));
    interrupted = 0;
    if (filter)
	switch (child_id = fork ()) {
	    case NOTOK: 
		advise ("fork", "unable to");
		return;

	    case OK: 		/* "trust me" */
		if (freopen (tmpfil, "w", stdout) == NULL) {
		    fprintf (stderr, "unable to create ");
		    perror (tmpfil);
		    _exit (1);
		}
		args[0] = r1bindex (mhlproc, '/');
		i = 1;
		args[i++] = "-forwall";
		args[i++] = "-form";
		args[i++] = filter;
		for (msgnum = mp -> lowsel; msgnum <= mp -> hghsel; msgnum++)
		    if (mp -> msgstats[msgnum] & SELECTED)
			args[i++] = getcpy (m_name (msgnum));
		args[i] = NULL;
		(void) mhlsbr (i, args, mhl_action);
		m_eomsbr ((int (*) ()) 0);
		(void) fclose (stdout);
		_exit (0);

	    default: 
		if (pidXwait (child_id, NULLCP))
		    interrupted++;
		break;
	}
    else {
	if ((out = fopen (tmpfil, "w")) == NULL) {
	    advise (tmpfil, "unable to create temporary file");
	    return;
	}

	msgcnt = 1;
	for (msgnum = mp -> lowsel;
		msgnum <= mp -> hghsel && !interrupted;
		msgnum++)
	    if (mp -> msgstats[msgnum] & SELECTED) {
		fprintf (out, "\n\n-------");
		if (msgnum == mp -> lowsel)
		    fprintf (out, " Forwarded Message%s",
			    mp -> numsel > 1 ? "s" : "");
		else
		    fprintf (out, " Message %d", msgcnt);
		fprintf (out, "\n\n");
		copy_digest (msgnum, out);
		msgcnt++;
	    }

	fprintf (out, "\n\n------- End of Forwarded Message%s\n",
		mp -> numsel > 1 ? "s" : "");
	(void) fclose (out);
    }

    (void) fflush (stdout);
    if (!interrupted)
	switch (child_id = fork ()) {
	    case NOTOK: 
		advise ("fork", "unable to");
		break;

	    case OK: 
		closefds (3);
		(void) signal (SIGINT, istat);
		(void) signal (SIGQUIT, qstat);

		vec[vecp++] = tmpfil;
		vec[vecp] = NULL;

		execvp (proc, vec);
		fprintf (stderr, "unable to exec ");
		perror (proc);
		_exit (1);

	    default: 
		(void) pidXwait (child_id, NULLCP);
		break;
	}

    (void) unlink (tmpfil);
}

/*  */

static char *hlpmsg[] = {
    "The %s program emulates many of the commands found in the Rand MH",
    "system.  Instead of operating on MH folders, commands to %s concern",
    "a single file.",
    "",
    "To see the list of commands available, just type a ``?'' followed by",
    "the RETURN key.  To find out what switches each command takes, type",
    "the name of the command followed by ``-help''.  To leave %s, use the",
    "``quit'' command.",
    "",
    "Although a lot of MH commands are found in %s, not all are fully",
    "implemented.  %s will always recognize all legal switches for a",
    "given command though, and will let you know when you ask for an",
    "option that it is unable to perform.",
    "",
    "Running %s is fun, but using MH from your shell is far superior.",
    "After you have familiarized yourself with the MH style by using %s,",
    "you should try using MH from the shell.  You can still use %s for",
    "message files that aren't in MH format, such as BBoard files.",
    NULL
};


/* ARGSUSED */

helpcmd (args)
char  **args;
{
    int     i;

    for (i = 0; hlpmsg[i]; i++) {
	printf (hlpmsg[i], invo_name);
	(void) putchar ('\n');
    }
}

/*  */

static struct swit markswit[] = {
#define	MADDSW	0
    "add", 0,
#define	MDELSW	1
    "delete", 0,
#define	MLSTSW	2
    "list", 0,
#define	MSEQSW	3
    "sequence name", 0,
#define	MPUBSW	4
    "public", 0,
#define	MNPUBSW	5
    "nopublic", 0,
#define	MZERSW	6
    "zero", 0,
#define	MNZERSW	7
    "nozero", 0,
#define	MHELP	8
    "help", 4,
#define	MDBUGSW	9
    "debug", -5,

    NULL, 0
};

/*  */

markcmd (args)
char  **args;
{
    int     addsw = 0,
            deletesw = 0,
            debugsw = 0,
            listsw = 0,
            zerosw = 0,
            seqp = 0,
            msgp = 0,
            i,
            msgnum;
    char   *cp,
            buf[BUFSIZ],
           *seqs[NATTRS + 1],
           *msgs[MAXARGS];

    while (cp = *args++) {
	if (*cp == '-')
	    switch (smatch (++cp, markswit)) {
		case AMBIGSW: 
		    ambigsw (cp, markswit);
		    return;
		case UNKWNSW: 
		    fprintf (stderr, "-%s unknown\n", cp);
		    return;
		case MHELP: 
		    (void) sprintf (buf, "%s [msgs] [switches]", cmd_name);
		    help (buf, markswit);
		    return;

		case MADDSW: 
		    addsw++;
		    deletesw = listsw = 0;
		    continue;
		case MDELSW: 
		    deletesw++;
		    addsw = listsw = 0;
		    continue;
		case MLSTSW: 
		    listsw++;
		    addsw = deletesw = 0;
		    continue;

		case MSEQSW: 
		    if (!(cp = *args++) || *cp == '-') {
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    if (seqp < NATTRS)
			seqs[seqp++] = cp;
		    else {
			advise (NULLCP, "only %d sequences allowed!", NATTRS);
			return;
		    }
		    continue;

		case MPUBSW: 	/* not implemented */
		case MNPUBSW: 
		    continue;

		case MDBUGSW: 
		    debugsw++;
		    continue;

		case MZERSW: 
		    zerosw++;
		    continue;
		case MNZERSW: 
		    zerosw = 0;
		    continue;
	    }
	if (*cp == '+' || *cp == '@') {
	    advise (NULLCP, "sorry, no folders allowed!");
	    return;
	}
	else
	    msgs[msgp++] = cp;
    }

    if (!addsw && !deletesw && !listsw)
	if (seqp)
	    addsw++;
	else
	    if (debugsw)
		listsw++;
	    else {
		seqs[seqp++] = "unseen";
		deletesw++;
		zerosw = 0;
		if (!msgp)
		    msgs[msgp++] = "all";
	    }

    if (!msgp)
	msgs[msgp++] = listsw ? "all" :"cur";
    for (msgnum = 0; msgnum < msgp; msgnum++)