mhlsbr.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

    if (!(c1 -> c_flags & HDROUTPUT) && !(c1 -> c_flags & NOCOMPONENT)) {
        if (c1 -> c_flags & UPPERCASE)		/* uppercase component also */
	    for (cp = (c1 -> c_text ? c1 -> c_text : c1 -> c_name); *cp; cp++)
	        if (islower (*cp))
		    *cp = toupper (*cp);
	putstr (c1 -> c_text ? c1 -> c_text : c1 -> c_name);
	if (flag != BODYCOMP) {
	    putstr (": ");
	    if (!(c1 -> c_flags & SPLIT))
		c1 -> c_flags |= HDROUTPUT;

	cchdr++;
	if ((count = c1 -> c_cwidth -
		strlen (c1 -> c_text ? c1 -> c_text : c1 -> c_name) - 2) > 0)
	    while (count--)
		putstr (" ");
	}
	else
	    c1 -> c_flags |= HDROUTPUT;		/* for BODYCOMP */
    }

    if (flag == TWOCOMP
	    && !(c2 -> c_flags & HDROUTPUT)
	    && !(c2 -> c_flags & NOCOMPONENT)) {
        if (c1 -> c_flags & UPPERCASE)
	    for (cp = c2 -> c_name; *cp; cp++)
	        if (islower (*cp))
		    *cp = toupper (*cp);
	putstr (c2 -> c_name);
	putstr (": ");
	if (!(c1 -> c_flags & SPLIT))
	    c2 -> c_flags |= HDROUTPUT;

	cchdr++;
	if ((count = c1 -> c_cwidth - strlen (c2 -> c_name) - 2) > 0)
	    while (count--)
		putstr (" ");
    }
    if (c1 -> c_flags & UPPERCASE)
	for (cp = c2 -> c_text; *cp; cp++)
	    if (islower (*cp))
		*cp = toupper (*cp);

    count = 0;
    if (cchdr)
	if (flag == TWOCOMP)
	    count = (c1 -> c_cwidth >= 0) ? c1 -> c_cwidth
			: strlen (c2 -> c_name) + 2;
	else
	    count = (c1 -> c_cwidth >= 0) ? c1 -> c_cwidth
			: strlen (c1->c_text ? c1->c_text : c1->c_name) + 2;
    count += c1 -> c_offset;

    putstr (oneline (c2 -> c_text, c1 -> c_flags));
    if (term == '\n')
	putstr ("\n");
    while (cp = oneline (c2 -> c_text, c1 -> c_flags)) {
	lm = count;
	if (flag == BODYCOMP
		&& !(c1 -> c_flags & NOCOMPONENT))
	    putstr (c1 -> c_text ? c1 -> c_text : c1 -> c_name);
	if (*cp)
	    putstr (cp);
	if (term == '\n')
	    putstr ("\n");
    }
}

/*  */

static char *oneline (stuff, flags)
register char   *stuff;
long   flags;
{
    int     spc;
    register char   *cp,
		    *ret;

    if (onelp == NULL)
	onelp = stuff;
    if (*onelp == NULL)
	return (onelp = NULL);

    ret = onelp;
    term = 0;
    if (flags & COMPRESS) {
	for (spc = 1, cp = ret; *onelp; onelp++)
	    if (isspace (*onelp)) {
		if (*onelp == '\n' && (!onelp[1] || (flags & ADDRFMT))) {
		    term = '\n';
		    *onelp++ = NULL;
		    break;
		}
		else
		    if (!spc) {
			*cp++ = ' ';
			spc++;
		    }
	    }
	    else {
		*cp++ = *onelp;
		spc = 0;
	    }

	*cp = NULL;
    }
    else {
	while (*onelp && *onelp != '\n')
	    onelp++;
	if (*onelp == '\n') {
	    term = '\n';
	    *onelp++ = NULL;
	}
	if (flags & LEFTADJUST)
	    while (*ret == ' ' || *ret == '\t')
		ret++;
    }

    return ret;
}

/*  */

static  putstr (string)
register char   *string;
{
    if (!column && lm > 0)
	while (lm > 0)
	    if (lm >= 8) {
		putch ('\t');
		lm -= 8;
	    }
	    else {
		putch (' ');
		lm--;
	    }
    lm = 0;
    while (*string)
	putch (*string++);
}

/*  */

static putch (ch)
register char	ch;
{
    char    buf[BUFSIZ];

    if (llim == 0)
	return;

    switch (ch) {
	case '\n': 
	    if (llim > 0)
		llim--;
	    column = 0;
	    row++;
	    if (ontty != ISTTY || row != global.c_length)
		break;
	    if (global.c_flags & BELL)
		(void) putchar ('\007');
	    (void) fflush (stdout);
	    buf[0] = NULL;
	    (void) read (fileno (stdout), buf, sizeof buf);
	    if (index (buf, '\n')) {
		if (global.c_flags & CLEARSCR)
		    clear_screen ();
		row = 0;
	    }
	    else {
		(void) putchar ('\n');
		row = global.c_length / 3;
	    }
	    return;

	case '\t': 
	    column |= 07;
	    column++;
	    break;

	case '\b': 
	    column--;
	    break;

	case '\r': 
	    column = 0;
	    break;

	default: 
	    if (column == 0 && forwflg && dashflg && ch == '-')
		(void) putchar ('-'), putchar (' ');
	    if (ch >= ' ')
		column++;
	    break;
    }

    if (column >= wid) {
	putch ('\n');
	if (ovoff > 0)
	    lm = ovoff;
	putstr (ovtxt ? ovtxt : "");
	putch (ch);
	return;
    }

    (void) putchar (ch);
}

/*  */

/* ARGSUSED */

static	int intrser (i)
int     i;
{
#ifndef	BSD42
    (void) signal (SIGINT, intrser);
#endif	BSD42

    discard (stdout);
    (void) putchar ('\n');

    longjmp (env, DONE);
}


/* ARGSUSED */

static	int pipeser (i)
int     i;
{
#ifndef	BSD42
    (void) signal (SIGPIPE, pipeser);
#endif	BSD42

    done (NOTOK);
}


/* ARGSUSED */

static	int quitser (i)
int     i;
{
#ifndef	BSD42
    (void) signal (SIGQUIT, quitser);
#endif	BSD42

    (void) putchar ('\n');
    (void) fflush (stdout);

    done (NOTOK);
}

/*  */

static	face_format (c1)
register struct mcomp *c1;
{
    register char  *cp;
    register struct mailname   *mp;

    if ((cp = c1 -> c_text) == NULL)
	return;

    if (cp = getname (cp)) {
	if (mp = getm (cp, NULLCP, 0, AD_NAME, NULLCP)) {
	    char *h, *o;
	    if ((h = mp -> m_host) == NULL)
		h = LocalName ();
	    if (o = OfficialName (h))
		h = o;
	    c1 -> c_face = concat ("address ", h, " ", mp -> m_mbox, NULLCP);
	}

	while (cp = getname (cp))
	    continue;
    }
}

/*  */

#if	defined(BSD42) || defined(SOCKETS)

/* faceproc is two elements defining the image agent's location:
	Internet host
	UDP port
 */

#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>

static int  doface (c1)
register struct mcomp *c1;
{
    int	    i,
	    result,
	    sd;
    struct sockaddr_in in_socket;
    register struct sockaddr_in *isock = &in_socket;
    static int inited = OK;
    static int addrlen;
    static struct in_addr addr;
    static u_short portno;

    if (inited == OK) {
	u_long	iaddr;
	char   *cp;
	char  **ap = brkstring (cp = getcpy (faceproc), " ", "\n");
	struct hostent *hp;

	if (ap[0] == NULL || ap[1] == NULL) {
bad_faceproc: ;
	    free (cp);
	    return (inited = NOTOK);
	}

	if (hp = gethostbyname (ap[0]))
	    bcopy (hp -> h_addr, (char *) &addr, addrlen = hp -> h_length);
	else
	    if (iaddr = inet_addr (ap[0]))
		bcopy ((char *) &iaddr, (char *) &addr,
			addrlen = sizeof iaddr);
	    else
		goto bad_faceproc;

	portno = htons ((u_short) atoi (ap[1]));
	free (cp);

	inited = DONE;
    }
    if (inited == NOTOK)
	return NOTOK;

    isock -> sin_family = AF_INET;
    isock -> sin_port = portno;
    bcopy ((char *) &addr, (char *) &isock -> sin_addr, addrlen);

    if ((sd = socket (AF_INET, SOCK_DGRAM, 0)) == NOTOK)
	return NOTOK;

    result = sendto (sd, c1 -> c_text, strlen (c1 -> c_text), 0,
		(struct sockaddr *) isock, sizeof *isock);

    (void) close (sd);

    return (result != NOTOK ? OK : NOTOK);
}

#else	not BSD42 and not SOCKETS

static int  doface (c1)
register struct mcomp *c1;
{
    register int    i,
                    len,
		    vecp;
    int     child_id,
	    result,
            pdi[2],
            pdo[2];
    register char  *bp,
		   *cp;
    char    buffer[BUFSIZ],
	   *vec[10];

    if (pipe (pdi) == NOTOK)
	return NOTOK;
    if (pipe (pdo) == NOTOK) {
	(void) close (pdi[0]);
	(void) close (pdi[1]);
	return NOTOK;
    }

    for (i = 0; (child_id = vfork ()) == NOTOK && i < 5; i++)
	sleep (5);

    switch (child_id) {
	case NOTOK: 
	    return NOTOK;

	case OK: 
	    (void) signal (SIGINT, SIG_IGN);
	    (void) signal (SIGQUIT, SIG_IGN);
	    if (pdi[0] != fileno (stdin)) {
		(void) dup2 (pdi[0], fileno (stdin));
		(void) close (pdi[0]);
	    }
	    (void) close (pdi[1]);
	    (void) close (pdo[0]);
	    if (pdo[1] != fileno (stdout)) {
		(void) dup2 (pdo[1], fileno (stdout));
		(void) close (pdo[1]);
	    }
	    vecp = 0;
	    vec[vecp++] = r1bindex (faceproc, '/');
	    vec[vecp++] = "-e";
	    if (sleepsw != NOTOK) {
		vec[vecp++] = "-s";
		(void) sprintf (buffer, "%d", sleepsw);
		vec[vecp++] = buffer;
	    }
	    vec[vecp] = NULL;
	    execvp (faceproc, vec);
	    fprintf (stderr, "unable to exec ");
	    perror (faceproc);
	    _exit (-1);		/* NOTREACHED */

	default: 
	    (void) close (pdi[0]);
	    i = strlen (c1 -> c_text);
	    if (write (pdi[1], c1 -> c_text, i) != i)
		adios ("pipe", "error writing to");
	    free (c1 -> c_text), c1 -> c_text = NULL;
	    (void) close (pdi[1]);

	    (void) close (pdo[1]);
	    cp = NULL, len = 0;
	    result = DONE;
	    while ((i = read (pdo[0], buffer, strlen (buffer))) > 0) {
		if (cp) {
		    register int    j;
		    register char  *dp;
		    if ((dp = realloc (cp, (unsigned) (j = len + i))) == NULL)
			adios (NULLCP, "unable to allocate face storage");
		    bcopy (buffer, dp + len, i);
		    cp = dp, len = j;
		}
		else {
		    if ((cp = malloc ((unsigned) i)) == NULL)
			adios (NULLCP, "unable to allocate face storage");
		    bcopy (buffer, cp, i);
		    len = i;
		}
		if (result == DONE)
		    for (bp = buffer + i - 1; bp >= buffer; bp--)
			if (!isascii (*bp) || iscntrl (*bp)) {
			    result = OK;
			    break;
			}
	    }
	    (void) close (pdo[0]);

/* no waiting for child... */

	    if (result == OK) {	/* binary */
		if (write (1, cp, len) != len)
		    adios ("writing", "error");
		free (cp);
	    }
	    else		/* empty */
		if ((c1 -> c_text = cp) == NULL)
		    result = OK;
	    break;
    }

    return result;
}
#endif	not BSD42 and not SOCKETS

/*  */

#undef	adios
#undef	done

int     mhlsbr (argc, argv, action)
int     argc;
char  **argv;
FP    (*action) ();
{
    TYPESIG (*istat) (), (*pstat) (), (*qstat) ();
    char   *cp;
    struct mcomp  *c1;

    switch (setjmp (mhlenv)) {
	case OK: 
	    cp = invo_name;
	    sleepsw = 0;	/* XXX */
	    bellflg = clearflg = forwflg = forwall = exitstat = 0;
	    digest = NULL;
	    ontty = NOTTY;
	    mhl_action = action;
	    if ((istat = signal (SIGINT, SIG_IGN)) != SIG_DFL)
		(void) signal (SIGINT, istat);
	    if ((qstat = signal (SIGQUIT, SIG_IGN)) != SIG_DFL)
		(void) signal (SIGQUIT, qstat);
	    pstat = signal (SIGPIPE, pipeser);
	    (void) mhl (argc, argv);	/* fall */

	default: 
	    (void) signal (SIGINT, istat);
	    (void) signal (SIGQUIT, qstat);
	    (void) signal (SIGPIPE, SIG_IGN);/* XXX */
	    if (ontty == PITTY)
		m_pclose ();
	    (void) signal (SIGPIPE, pstat);
	    invo_name = cp;
	    if (holder.c_text) {
		free (holder.c_text);
		holder.c_text = NULL;
	    }
	    free_queue (&msghd, &msgtl);
	    for (c1 = fmthd; c1; c1 = c1 -> c_next)
		c1 -> c_flags &= ~HDROUTPUT;
	    return exitstat;
    }
}

/*  */

/* VARARGS2 */

static void mhladios (what, fmt, a, b, c, d, e, f)
char   *what,
       *fmt,
       *a,
       *b,
       *c,
       *d,
       *e,
       *f;
{
    advise (what, fmt, a, b, c, d, e, f);
    mhldone (1);
}


static void mhldone (status)
int     status;
{
    exitstat = status;
    if (mhl_action)
	longjmp (mhlenv, DONE);
    else
	done (exitstat);
}

/*  */

static	int m_pid = NOTOK;
static  int sd = NOTOK;


static	m_popen (name)
char *name;
{
    int     pd[2];

    if (mhl_action && (sd = dup (fileno (stdout))) == NOTOK)
	adios ("standard output", "unable to dup()");

    if (pipe (pd) == NOTOK)
	adios ("pipe", "unable to");

    switch (m_pid = vfork ()) {
	case NOTOK: 
	    adios ("fork", "unable to");

	case OK: 
	    (void) signal (SIGINT, SIG_DFL);
	    (void) signal (SIGQUIT, SIG_DFL);

	    (void) close (pd[1]);
	    if (pd[0] != fileno (stdin)) {
		(void) dup2 (pd[0], fileno (stdin));
		(void) close (pd[0]);
	    }
	    execlp (name, r1bindex (name, '/'), NULLCP);
	    fprintf (stderr, "unable to exec ");
	    perror (name);
	    _exit (-1);

	default: 
	    (void) close (pd[0]);
	    if (pd[1] != fileno (stdout)) {
		(void) dup2 (pd[1], fileno (stdout));
		(void) close (pd[1]);
	    }
    }
}


m_pclose () {
    if (m_pid == NOTOK)
	return;

    if (sd != NOTOK) {
	(void) fflush (stdout);
	if (dup2 (sd, fileno (stdout)) == NOTOK)
	    adios ("standard output", "unable to dup2()");

	clearerr (stdout);
	(void) close (sd);
	sd = NOTOK;
    }
    else
	(void) fclose (stdout);

    (void) pidwait (m_pid, OK);
    m_pid = NOTOK;
}