msh.c

早期freebsd实现

                lasthgh = 0,
		lastnum = 0;

    oldhgh = mp -> hghmsg;
    if (check_folder (scansw) && oldhgh < mp -> hghmsg) {
	switch (winX (STATUS)) {
	    case NOTOK: 
		return NOTOK;

	    case OK: 
		printf ("new messages have arrived!");
		(void) fflush (stdout);
		(void) fflush (stderr);
		_exit (0);	/* NOTREACHED */

	    default: 
		lastlow = lastcur = lasthgh = lastnum = 0;
		break;
	}

	switch (winX (DISPLAY)) {
	    case NOTOK: 
		return NOTOK;

	    case OK: 
		scanrange (oldhgh + 1, mp -> hghmsg);
		(void) fflush (stdout);
		(void) fflush (stderr);
		_exit (0);	/* NOTREACHED */

	    default: 
		break;
	}
	return OK;
    }

    if (gap)
	switch (winX (STATUS)) {
	    case NOTOK:
		return NOTOK;

	    case OK:
		printf ("%s: gap in ID:s, last seen %d, lowest present %d\n",
		    myname ? myname : fmsh ? fmsh : mp -> foldpath, gap - 1,
		    readid (mp -> lowmsg));
		(void) fflush (stdout);
		(void) fflush (stderr);
		_exit (0);	/* NOTREACHED */

	    default:
		gap = 0;
		return OK;
	}

    if (mp -> lowmsg != lastlow
	    || mp -> curmsg != lastcur
	    || mp -> hghmsg != lasthgh
	    || mp -> nummsg != lastnum)
	switch (winX (STATUS)) {
	    case NOTOK: 
		return NOTOK;

	    case OK: 
		foldcmd (NULLVP);
		(void) fflush (stdout);
		(void) fflush (stderr);
		_exit (0);	/* NOTREACHED */

	    default: 
		lastlow = mp -> lowmsg;
		lastcur = mp -> curmsg;
		lasthgh = mp -> hghmsg;
		lastnum = mp -> nummsg;
		return OK;
	}

    return OK;
}

/*  */

static int  pQRY2 () {
    int     i,
            j,
	    k,
            msgnum,
            n;
    static int  cur = 0,
                num = 0,
		lo = 0,
		hi = 0;

    if (mp -> nummsg == 0 && mp -> nummsg != num)
	switch (winX (SCAN)) {
	    case NOTOK: 
		return NOTOK;

	    case OK: 
		printf ("empty!");
		(void) fflush (stdout);
		(void) fflush (stderr);
		_exit (0);	/* NOTREACHED */

	    default: 
		num = mp -> nummsg;
		return OK;
	}
    num = mp -> nummsg;

    i = 0;
    j = (k = windows[SCAN]) / 2;
    for (msgnum = mp -> curmsg; msgnum <= mp -> hghmsg; msgnum++)
	if (mp -> msgstats[msgnum] & EXISTS)
	    i++;
    if (i-- > 0)
	if (topcur)
	    k = i >= k ? 1 : k - i;
	else
	    k -= i > j ? j : i;

    i = j = 0;
    n = 1;
    for (msgnum = mp -> curmsg; msgnum >= mp -> lowmsg; msgnum--)
	if (mp -> msgstats[msgnum] & EXISTS) {
	    i = msgnum;
	    if (j == 0)
		j = msgnum;
	    if (n++ >= k)
		break;
	}
    for (msgnum = mp -> curmsg + 1; msgnum <= mp -> hghmsg; msgnum++)
	if (mp -> msgstats[msgnum] & EXISTS) {
	    if (i == 0)
		i = msgnum;
	    j = msgnum;
	    if (n++ >= windows[SCAN])
		break;
	}
    if (!topcur
	    && lo > 0
	    && hi > 0
	    && mp -> msgstats[lo] & EXISTS
	    && mp -> msgstats[hi] & EXISTS
	    && (lo < mp -> curmsg
		    || (lo == mp -> curmsg && lo == mp -> lowmsg))
	    && (mp -> curmsg < hi
		    || (hi == mp -> curmsg && hi == mp -> hghmsg))
	    && hi - lo == j - i)
	i = lo, j = hi;

    if (mp -> curmsg != cur || modified)
	switch (winN (NULLCMD, SCAN, 0)) {
	    case NOTOK: 
		return NOTOK;

	    case OK:
		return OK;

	    default: 
		scanrange (lo = i, hi = j);
		cur = mp -> curmsg;
		(void) winR (NULLCMD);
		return OK;
	}

    return OK;
}

/*  */

static int pCMD (str, sw, cmdp)
char   *str;
struct swit *sw;
struct Cmd *cmdp;
{
    int     i;

    if (*str == '?')
	switch (winX (DISPLAY)) {
	    case NOTOK: 
		return NOTOK;

	    case OK: 
		printf ("commands:\n");
		printsw (ALL, sw, "");
		printf ("type ``quit'' to leave %s\n", invo_name);
		(void) fflush (stdout);
		(void) fflush (stderr);
		_exit (0);	/* NOTREACHED */

	    default: 
		(void) rc2peer (RC_EOF, 0, NULLCP);
		return NOTOK;
	}

    if (parse (str, cmdp) == NOTOK)
	return NOTOK;

    switch (i = smatch (cmdp -> args[0], sw)) {
	case AMBIGSW: 
	    switch (winX (DISPLAY)) {
		case NOTOK: 
		    return NOTOK;

		case OK: 
		    ambigsw (cmdp -> args[0], sw);
		    (void) fflush (stdout);
		    (void) fflush (stderr);
		    _exit (0);	/* NOTREACHED */

		default: 
		    (void) rc2peer (RC_EOF, 0, NULLCP);
		    return NOTOK;
	    }

	case UNKWNSW: 
	    (void) fmt2peer (RC_ERR,
		    "say what: ``%s'' -- type ? (or help) for help",
		    cmdp -> args[0]);
	    return NOTOK;

	default: 
	    return i;
    }
}

/*  */

static int  pFIN () {
    int     status;

    switch (setjmp (peerenv)) {
	case OK: 
	    (void) signal (SIGALRM, alrmser);
	    (void) alarm (ALARM);

	    status = peerwait ();

	    (void) alarm (0);
	    return status;

	default: 
	    return NOTOK;
    }
}


static int  peerwait () {
    struct record   rcs,
                   *rc = &rcs;

    initrc (rc);

    switch (peer2rc (rc)) {
	case RC_QRY: 
	case RC_CMD: 
	    (void) rc2peer (RC_FIN, 0, NULLCP);
	    return OK;

	case RC_XXX: 
	    advise (NULLCP, "%s", rc -> rc_data);
	    return NOTOK;

	default: 
	    (void) fmt2peer (RC_FIN, "pLOOP protocol screw-up");
	    return NOTOK;
    }
}


/* ARGSUSED */

static TYPESIG alrmser (i)
int	i;
{
    longjmp (peerenv, DONE);
}

/*  */

static int  ttyNaux (cmdp, s)
register struct Cmd *cmdp;
char   *s;
{
    struct record   rcs,
                   *rc = &rcs;

    initrc (rc);

    if (cmdp && init_io (cmdp, vmh) == NOTOK)
	return NOTOK;

    if (!fmsh)
	(void) fseek (fp, 0L, 0);/* XXX: fseek() too tricky for our own good */

    vmhtty = NOTOK;
    switch (rc2rc (RC_TTY, s ? strlen (s) : 0, s, rc)) {
	case RC_ACK: 
	    vmhtty = OK;	/* fall */
	case RC_ERR: 
	    break;

	case RC_XXX: 
	    padios (NULLCP, "%s", rc -> rc_data);/* NOTREACHED */

	default: 
	    (void) fmt2peer (RC_ERR, "pTTY protocol screw-up");
	    done (1);		/* NOTREACHED */
    }

#ifdef	SIGTSTP
    (void) signal (SIGTSTP, tstat);
#endif	/* SIGTSTP */
    return vmhtty;
}

/*  */

static int  ttyR (cmdp)
register struct Cmd *cmdp;
{
    struct record   rcs,
                   *rc = &rcs;

#ifdef	SIGTSTP
    (void) signal (SIGTSTP, SIG_IGN);
#endif	/* SIGTSTP */

    if (vmhtty != OK)
	return NOTOK;

    initrc (rc);

    if (cmdp)
	fin_io (cmdp, 0);

    vmhtty = NOTOK;
    switch (rc2rc (RC_EOF, 0, NULLCP, rc)) {
	case RC_ACK: 
	    (void) rc2peer (RC_EOF, 0, NULLCP);
	    return OK;

	case RC_XXX: 
	    padios (NULLCP, "%s", rc -> rc_data);/* NOTREACHED */

	default: 
	    (void) fmt2peer (RC_ERR, "pTTY protocol screw-up");
	    done (1);		/* NOTREACHED */
    }
}

/*  */

static int  winN (cmdp, n, eof)
register struct Cmd *cmdp;
int	n,
	eof;
{
    int     i,
            pd[2];
    char    buffer[BUFSIZ];
    struct record   rcs,
                   *rc = &rcs;

    if (vmhpid == NOTOK)
	return OK;

    initrc (rc);

    if (!fmsh)
	(void) fseek (fp, 0L, 0);/* XXX: fseek() too tricky for our own good */

    vmhpid = OK;

    (void) sprintf (buffer, "%d", n);
    switch (str2rc (RC_WIN, buffer, rc)) {
	case RC_ACK: 
	    break;

	case RC_ERR: 
	    return NOTOK;

	case RC_XXX: 
	    padios (NULLCP, "%s", rc -> rc_data);

	default: 
	    (void) fmt2peer (RC_ERR, "pWIN protocol screw-up");
	    done (1);
    }

    if (pipe (pd) == NOTOK) {
	(void) err2peer (RC_ERR, "pipe", "unable to");
	return NOTOK;
    }

    switch (vmhpid = fork ()) {
	case NOTOK: 
	    (void) err2peer (RC_ERR, "fork", "unable to");
	    (void) close (pd[0]);
	    (void) close (pd[1]);
	    return NOTOK;

	case OK: 
	    (void) close (pd[1]);
	    (void) signal (SIGPIPE, SIG_IGN);
	    while ((i = read (pd[0], buffer, sizeof buffer)) > 0)
		switch (rc2rc (RC_DATA, i, buffer, rc)) {
		    case RC_ACK: 
			break;

		    case RC_ERR: 
			_exit (1);

		    case RC_XXX: 
			advise (NULLCP, "%s", rc -> rc_data);
			_exit (2);

		    default: 
			(void) fmt2peer (RC_ERR, "pWIN protocol screw-up");
			_exit (2);
		}
	    if (i == OK)
		switch (rc2rc (RC_EOF, 0, NULLCP, rc)) {
		    case RC_ACK: 
			if (eof)
			    (void) rc2peer (RC_EOF, 0, NULLCP);
			i = 0;
			break;

		    case RC_XXX: 
			advise (NULLCP, "%s", rc -> rc_data);
			i = 2;
			break;

		    default: 
			(void) fmt2peer (RC_ERR, "pWIN protocol screw-up");
			i = 2;
			break;
		}
	    if (i == NOTOK)
		(void) err2peer (RC_ERR, "pipe", "error reading from");
	    (void) close (pd[0]);
	    _exit (i != NOTOK ? i : 1);

	default: 
	    if ((vmhfd0 = dup (fileno (stdin))) == NOTOK)
		padios ("standard input", "unable to dup");
	    if ((vmhfd1 = dup (fileno (stdout))) == NOTOK)
		padios ("standard output", "unable to dup");
	    if ((vmhfd2 = dup (fileno (stderr))) == NOTOK)
		padios ("diagnostic output", "unable to dup");

	    (void) close (0);
	    if ((i = open ("/dev/null", 0)) != NOTOK && i != fileno (stdin)) {
		(void) dup2 (i, fileno (stdin));
		(void) close (i);
	    }

	    (void) fflush (stdout);
	    if (dup2 (pd[1], fileno (stdout)) == NOTOK)
		padios ("standard output", "unable to dup2");
	    clearerr (stdout);

	    (void) fflush (stderr);
	    if (dup2 (pd[1], fileno (stderr)) == NOTOK)
		padios ("diagnostic output", "unable to dup2");
	    clearerr (stderr);

	    if (cmdp && init_io (cmdp, 0) == NOTOK)
		return NOTOK;
	    pstat = signal (SIGPIPE, pipeser);
	    broken_pipe = 1;

	    (void) close (pd[0]);
	    (void) close (pd[1]);

	    return vmhpid;
    }
}

/*  */

static int  winR (cmdp)
register struct Cmd *cmdp;
{
    int     status;

    if (vmhpid <= OK)
	return NOTOK;

    if (cmdp)
	fin_io (cmdp, 0);

    if (dup2 (vmhfd0, fileno (stdin)) == NOTOK)
	padios ("standard input", "unable to dup2");
    clearerr (stdin);
    (void) close (vmhfd0);

    (void) fflush (stdout);
    if (dup2 (vmhfd1, fileno (stdout)) == NOTOK)
	padios ("standard output", "unable to dup2");
    clearerr (stdout);
    (void) close (vmhfd1);

    (void) fflush (stderr);
    if (dup2 (vmhfd2, fileno (stderr)) == NOTOK)
	padios ("diagnostic output", "unable to dup2");
    clearerr (stderr);
    (void) close (vmhfd2);

    (void) signal (SIGPIPE, pstat);

    if ((status = pidwait (vmhpid, OK)) == 2)
	done (1);

    vmhpid = OK;
    return (status == 0 ? OK : NOTOK);
}

/*  */

static int  winX (n)
int	n;
{
    int     i,
            pid,
            pd[2];
    char    buffer[BUFSIZ];
    struct record   rcs,
                   *rc = &rcs;

    initrc (rc);

    if (!fmsh)
	(void) fseek (fp, 0L, 0);/* XXX: fseek() too tricky for our own good */

    (void) sprintf (buffer, "%d", n);
    switch (str2rc (RC_WIN, buffer, rc)) {
	case RC_ACK: 
	    break;

	case RC_ERR: 
	    return NOTOK;

	case RC_XXX: 
	    padios (NULLCP, "%s", rc -> rc_data);

	default: 
	    (void) fmt2peer (RC_ERR, "pWIN protocol screw-up");
	    done (1);
    }

    if (pipe (pd) == NOTOK) {
	(void) err2peer (RC_ERR, "pipe", "unable to");
	return NOTOK;
    }

    switch (pid = fork ()) {
	case NOTOK: 
	    (void) err2peer (RC_ERR, "fork", "unable to");
	    (void) close (pd[0]);
	    (void) close (pd[1]);
	    return NOTOK;

	case OK: 
	    (void) close (fileno (stdin));
	    if ((i = open ("/dev/null", 0)) != NOTOK && i != fileno (stdin)) {
		(void) dup2 (i, fileno (stdin));
		(void) close (i);
	    }
	    (void) dup2 (pd[1], fileno (stdout));
	    (void) dup2 (pd[1], fileno (stderr));
	    (void) close (pd[0]);
	    (void) close (pd[1]);
	    vmhpid = NOTOK;
	    return OK;

	default: 
	    (void) close (pd[1]);
	    while ((i = read (pd[0], buffer, sizeof buffer)) > 0)
		switch (rc2rc (RC_DATA, i, buffer, rc)) {
		    case RC_ACK: 
			break;

		    case RC_ERR: 
			(void) close (pd[0]);
			(void) pidwait (pid, OK);
			return NOTOK;

		    case RC_XXX: 
			padios (NULLCP, "%s", rc -> rc_data);

		    default: 
			(void) fmt2peer (RC_ERR, "pWIN protocol screw-up");
			done (1);
		}
	    if (i == OK)
		switch (rc2rc (RC_EOF, 0, NULLCP, rc)) {
		    case RC_ACK: 
			break;

		    case RC_XXX: 
			padios (NULLCP, "%s", rc -> rc_data);

		    default: 
			(void) fmt2peer (RC_ERR, "pWIN protocol screw-up");
			done (1);
		}
	    if (i == NOTOK)
		(void) err2peer (RC_ERR, "pipe", "error reading from");

	    (void) close (pd[0]);
	    (void) pidwait (pid, OK);
	    return (i != NOTOK ? pid : NOTOK);
    }
}

/*  */

/* VARARGS2 */

void	padios (what, fmt, a, b, c, d, e, f)
char   *what,
       *fmt,
       *a,
       *b,
       *c,
       *d,
       *e,
       *f;
{
    if (vmh) {
	(void) err2peer (RC_FIN, what, fmt, a, b, c, d, e, f);
	(void) rcdone ();
    }
    else
	advise (what, fmt, a, b, c, d, e, f);

    done (1);
}


/* VARARGS2 */

void	padvise (what, fmt, a, b, c, d, e, f)
char   *what,
       *fmt,
       *a,
       *b,
       *c,
       *d,
       *e,
       *f;
{
    if (vmh)
	(void) err2peer (RC_ERR, what, fmt, a, b, c, d, e, f);
    else
	advise (what, fmt, a, b, c, d, e, f);
}