Garbo/Garbo.cdr/mac/unix/uw_shar.sit/uw-42-part4.shar

Text File | 1989-09-14 | 61KB | 2,429 lines

#Date: Wed, 2 Mar 88 10:01:04 PST
#From: [e-mail] (Edward Rothberg)
#Subject: UW 4.2 part 4 of 8
: This is a shar archive.  Extract with sh, not csh.
if test ! -d server; then
    echo mkdir server
    mkdir server
fi
echo x - server/uw_ipc.c
sed -e 's/^X//' > server/uw_ipc.c << '!EOF!server/uw_ipc.c!'
X/*
X *    uw IPC
X *
X * Copyright 1986 by John D. Bruner.  All rights reserved.  Permission to
X * copy this program is given provided that the copy is not sold and that
X * this copyright notice is included.
X */
X
X#include <sys/types.h>
X#include <sys/file.h>
X#include <sys/stat.h>
X#include <sys/socket.h>
X#include <sys/un.h>
X#include <sys/ioctl.h>
X#include <sys/uio.h>
X#include <netinet/in.h>
X#include <strings.h>
X#include <netdb.h>
X#include <errno.h>
X#include <stdio.h>
X
X#include "uw_param.h"
X#include "uw_err.h"
X#include "uw_opt.h"
X#include "uw_win.h"
X#include "uw_fd.h"
X#include "uw_pcl.h"
X#include "uw_ipc.h"
X
X#ifndef ntohs
X/* declaring these as one-element arrays or as NULL pointers is a HACK */
Xextern unsigned long ntohl(), htonl();
Xextern unsigned short ntohs(), htons();
Xstatic struct netadj na_ntoh[1] = {
X    (short (*)())ntohs, (long (*)())ntohl, ntohs, ntohl
X};
Xstatic struct netadj na_hton[1] = {
X    (short (*)())htons, (long (*)())htonl, htons, htonl
X};
X#else
Xstatic struct netadj *na_ntoh = NULL;
Xstatic struct netadj *na_hton = NULL;
X#endif
X
Xstatic int have_udport;
Xstatic char uipc_port[] = "/tmp/uwXXXXXX";
X
Xstatic int inet_sd;
Xstatic struct ipcmsg {
X    int        im_len;
X    struct uwipc    im_msg;
X} *inet_buf;
X
Xextern int errno;
X
Xipc_init(use_uipc)
X{
X    ipc_isinit();
X    if (use_uipc)
X        ipc_udinit();
X}
X
X
X/*
X * UNIX-domain
X */
X
Xstatic
Xipc_udinit()
X{
X    register int len;
X    register char *cp;
X    register fildes_t sd;
X    auto struct sockaddr_un sa;
X    auto char *env[2];
X    extern char *mktemp();
X
X    len = strlen(UIPC_ENV) + sizeof uipc_port + 1;
X    if ((cp = malloc(len)) != NULL) {
X        (void)sprintf(cp, "%s=%s", UIPC_ENV, mktemp(uipc_port));
X        env[0] = cp;
X        env[1] = (char *)0;
X        env_set(env);
X
X        sa.sun_family = AF_UNIX;
X        (void)strncpy(sa.sun_path, uipc_port, sizeof sa.sun_path-1);
X        sa.sun_path[sizeof sa.sun_path-1] = '\0';
X        if ((sd = socket(AF_UNIX, SOCK_DGRAM, 0)) >= 0 &&
X            bind(sd,&sa,sizeof sa.sun_family+strlen(sa.sun_path)) >= 0){
X            have_udport = 1;
X            (void)chmod(uipc_port, S_IREAD|S_IWRITE);
X            (void)fcntl(sd, F_SETFL, FNDELAY);
X            fdmap[sd].f_type = FDT_UDSOCK;
X            FD_SET(sd, &selmask[0].sm_rd);
X        }
X    }
X}
X
Xipc_exit()
X{
X    if (have_udport)
X        (void)unlink(uipc_port);
X}
X
Xipc_udrecv(sd)
Xregister fildes_t sd;
X{
X    register struct window *w;
X    register int cnt;
X    struct msghdr msg;
X    auto int fd;
X    struct iovec iov;
X    struct stat st1, st2;
X    union {
X        struct uwipc uwip;
X        char data[1024];
X    } buf;
X
X
X    /*
X     * main() calls this routine when there is a message waiting on
X     * the UNIX-domain socket.  The message's access rights are
X     * expected to contain the file descriptor for the "master" side
X     * of a pseudo-tty.  The message contains the name of the pty.
X     * The sender is expected to start up a process on the slave side
X     * of the pty.  This allows the host end to create windows which
X     * run something other than the shell.
X     */
X    fd = -1;
X
X    iov.iov_base = (caddr_t)buf.data;
X    iov.iov_len = sizeof buf - 1;
X
X    msg.msg_name = (caddr_t)0;
X    msg.msg_namelen = 0;
X    msg.msg_iov = &iov;
X    msg.msg_iovlen = 1;
X    msg.msg_accrights = (caddr_t)&fd;
X    msg.msg_accrightslen = sizeof fd;
X
X    if ((cnt=recvmsg(sd, &msg, 0)) < 0 || cnt != buf.uwip.uwip_len)
X        return;
X    switch (buf.uwip.uwip_cmd) {
X    case UWC_NEWT:
X        if (msg.msg_accrightslen > 0 && fd >= 0) {
X            /*
X             * We can't trust the process which connected to us,
X             * so we verify that it really passed us a pseudo-tty's
X             * file descriptor by checking the device name and its
X             * inode number.  [Of course, if someone else wants to
X             * hand us a terminal session running under their
X             * uid....]
X             */
X            if (cnt == sizeof buf)
X                cnt--;
X            buf.data[cnt] = '\0';
X            if (strncmp(buf.uwip.uwip_newt.uwnt_pty,
X                "/dev/pty", sizeof "/dev/pty"-1) ||
X                fstat(fd, &st1) < 0 ||
X                stat(buf.uwip.uwip_newt.uwnt_pty, &st2) < 0 ||
X                st1.st_dev != st2.st_dev ||
X                st1.st_ino != st2.st_ino) {
X                (void)close(fd);
X                return;
X            }
X            /*
X             * OK, we believe the sender.  We allocate a window and
X             * tell the Macintosh to create that window on its end.
X             * If we have no free windows, then we close the file
X             * descriptor (which will terminate the slave process).
X             */
X            w = PCL_NEWW(0, WC_INTERNAL,
X                  buf.uwip.uwip_newt.uwnt_type,
X                  (nwin_t)0, buf.uwip.uwip_newt.uwnt_id,
X                  fd, (fildes_t)-1);
X            if (w != NULL) {
X                (void)strncpy(w->w_tty,
X                    buf.uwip.uwip_newt.uwnt_pty,
X                    sizeof w->w_tty-1);
X                w->w_tty[5] = 't'; /* switch to "/dev/ttyp?" */
X                utmp_add(w->w_tty);
X            } else
X                (void)close(fd);
X        }
X        break;
X    case UWC_OPTION:
X        w = win_search(buf.uwip.uwip_option.uwop_id,
X            protocol->p_maxwin);
X        if (w != NULL) {
X            opt_extopt((caddr_t)w, &w->w_optdefn,
X                (woptcmd_t)buf.uwip.uwip_option.uwop_cmd,
X                (woption_t)buf.uwip.uwip_option.uwop_opt,
X                (char *)&buf.uwip.uwip_option.uwop_val,
X                (struct netadj *)0);
X        }
X        break;
X    }
X}
X
X
X/*
X * Internet domain
X */
X
Xstatic
Xipc_isinit()
X{
X    register fildes_t sd;
X    register char *cp;
X    struct hostent *h;
X    struct sockaddr_in sin;
X    auto int sinlen;
X    char hostname[32];
X    char *env[2];
X
X    /*
X     * Allocate enough buffers for each file descriptor to have one.
X     * This is overkill.
X     */
X    inet_buf = (struct ipcmsg *)malloc(nfds * sizeof(struct ipcmsg));
X    if (inet_buf == NULL)
X        return;
X
X    /*
X     * Determine our host name and get an Internet stream socket.
X     * We really should specify the protocol here (rather than 0)
X     * but we "know" that it defaults to TCP.
X     */
X    if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
X        return;
X    sin.sin_family = AF_INET;
X    sin.sin_port = 0;
X    bzero(sin.sin_zero, sizeof sin.sin_zero);
X    if (gethostname(hostname, sizeof hostname) < 0 || hostname[0] == '\0')
X        (void)strcpy(hostname, "localhost");
X    if ((h = gethostbyname(hostname)) != NULL)
X        bcopy(h->h_addr, (char *)&sin.sin_addr, h->h_length);
X    else
X        sin.sin_addr.s_addr = htonl(0x7f000001L); /* 128.0.0.1 (lo0) */
X    if (bind(sd, &sin, sizeof sin) < 0) {
X        /*
X         * Unable to bind to unspecified port -- try once more with
X         * loopback device.  If we already were using the loopback
X         * device we just suffer the inefficiency of doing this twice.
X         */
X        sin.sin_addr.s_addr = htonl(0x7f000001L);
X        if (bind(sd, &sin, sizeof sin) < 0) {
X            (void)close(sd);
X            return;
X        }
X    }
X
X    /*
X     * Listen for incoming connections
X     */
X    if (listen(sd, NWINDOW) < 0) {
X        (void)close(sd);
X        return;
X    }
X
X    /*
X     * Determine our port number and put our address in the environment.
X     */
X    sinlen = sizeof sin;
X    if (getsockname(sd, (char *)&sin, &sinlen) < 0) {
X        /* huh?  Oh well, give up */
X        (void)close(sd);
X        return;
X    }
X    if ((cp = malloc(sizeof INET_ENV + 1 + 8 + 1 + 5)) == NULL) {
X        /* no memory, give up */
X        (void)close(sd);
X        return;
X    }
X    sprintf(cp, "%s=%08lx.%05u", INET_ENV,
X        ntohl(sin.sin_addr.s_addr), ntohs(sin.sin_port));
X    env[0] = cp;
X    env[1] = (char *)0;
X    env_set(env);
X
X    inet_sd = sd;
X    fdmap[sd].f_type = FDT_ISSOCK;
X    FD_SET(sd, &selmask[0].sm_rd);
X}
X
Xipc_isrecv(sd)
Xregister fildes_t sd;
X{
X    register fildes_t fd;
X    register struct uwipc *uwip;
X    register struct window *w;
X    register uwerr_t uwerr;
X    register int len;
X    struct sockaddr sin;
X    struct uwipc reply;
X    auto int sinlen;
X
X    /*
X     * This routine is called when one of two conditions occur.  It is
X     * called when an outside process tries to establish a steam
X     * Internet connection.
X     *
X     * Later, as soon as data is available, this routine will be
X     * called again to handle the external message (which must be
X     * a "new window" command).
X     */
X    if (sd == inet_sd) {
X        sinlen = sizeof sin;
X        if ((fd = accept(sd, &sin, &sinlen)) >= 0) {
X            (void)fcntl(fd, F_SETFL, FNDELAY);
X            fdmap[fd].f_type = FDT_ISSOCK;
X            fdmap[fd].f_win = (struct window *)0;
X            FD_SET(fd, &selmask[0].sm_rd);
X            inet_buf[fd].im_len = 0;
X        }
X    } else {
X        switch (ipc_getmsg(sd, inet_buf + sd)) {
X        case -1:
X            (void)close(sd);
X            fdmap[sd].f_type = FDT_NONE;
X            FD_CLR(sd, &selmask[0].sm_rd);
X            FD_CLR(sd, &selmask[0].sm_wt);
X            FD_CLR(sd, &selmask[0].sm_ex);
X            break;
X        case 1:
X            uwip = &inet_buf[sd].im_msg;
X            uwerr = UWE_NONE;
X            if ((uwip->uwip_len < sizeof(struct uwneww) +
X                ((char *)&uwip->uwip_neww - (char *)uwip)) ||
X                uwip->uwip_cmd != UWC_NEWW) {
X                uwerr = UWE_NXTYPE;
X            } else {
X                fd = ipc_ctlopen(sd,
X                    (unsigned)uwip->uwip_neww.uwnw_ctlport);
X                w = PCL_NEWW(0, WC_EXTERNAL,
X                      ntohs(uwip->uwip_neww.uwnw_type),
X                      (nwin_t)0, ntohl(uwip->uwip_neww.uwnw_id),
X                      sd, fd);
X                if (w == (struct window *)0)
X                    uwerr = UWE_NXTYPE;    /* for now */
X                else
X                    uwerr = UWE_NONE;
X            }
X            len = sizeof(struct uwstatus) +
X                ((char *)&reply.uwip_status - (char *)&reply);
X            reply.uwip_len = htons(len);
X            reply.uwip_cmd = htons(UWC_STATUS);
X            reply.uwip_status.uwst_err = htons(uwerr);
X            reply.uwip_status.uwst_errno = htons(errno);
X            if (uwerr == UWE_NONE)
X                reply.uwip_status.uwst_id = htonl(w->w_id);
X            else
X                reply.uwip_status.uwst_id = 0;
X            (void)write(sd, (char *)&reply, len);
X            if (uwerr != UWE_NONE) {
X                (void)close(sd);
X                fdmap[sd].f_type = FDT_NONE;
X                FD_CLR(sd, &selmask[0].sm_rd);
X                FD_CLR(sd, &selmask[0].sm_wt);
X                FD_CLR(sd, &selmask[0].sm_ex);
X            }
X            inet_buf[sd].im_len = 0;
X        }
X    }
X}
X
Xipc_ctlopen(sd, port)
Xfildes_t sd;
Xunsigned port;
X{
X    register int fd;
X    auto struct sockaddr_in sin;
X    auto int sinlen;
X
X    /*
X     * Create a control socket and connect it to the same host as
X     * "sd" on the specified port.
X     */
X    sinlen = sizeof sin;
X    if (port == 0 ||
X        getpeername(sd, (struct sockaddr *)&sin, &sinlen) < 0 ||
X        (fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
X        return(-1);
X    } else {
X        sin.sin_port = port;
X        (void)fcntl(fd, F_SETFL, FNDELAY);
X        if (connect(fd, &sin, sinlen) < 0 && errno != EINPROGRESS) {
X            (void)close(fd);
X            return(-1);
X        } else
X            return(fd);
X    }
X}
X
Xvoid
Xipc_optmsg(win, optcmd, optnum, data, datalen)
Xcaddr_t win;
Xwoptcmd_t optcmd;
Xwoption_t optnum;
Xchar *data;
Xunsigned datalen;
X{
X    register struct window *w;
X    register int len;
X    struct uwipc uwip;
X
X    /*
X     * Propagate a window option message (WILL, WONT, SET) from the Mac
X     * to the remote process (external windows only).
X     */
X    if ((w = (struct window *)win) != NULL && w->w_alloc &&
X        w->w_class == WC_EXTERNAL && w->w_ctlfd >= 0 &&
X        optnum <= WONUM_MAX && (optcmd == WOC_WILL || optcmd == WOC_WONT ||
X         (optcmd == WOC_SET && data != NULL))) {
X        len = datalen +
X            ((char *)&uwip.uwip_option.uwop_val - (char *)&uwip);
X        uwip.uwip_len = htons(len);
X        uwip.uwip_cmd = htons(UWC_OPTION);
X        uwip.uwip_option.uwop_id = htonl(w->w_id);
X        uwip.uwip_option.uwop_opt = htons(optnum);
X        uwip.uwip_option.uwop_cmd = htons(optcmd);
X        if (optcmd == WOC_SET) {
X            bcopy(data, (char *)&uwip.uwip_option.uwop_val,
X                (int)datalen);
X            opt_netadj(w->w_optdefn.wod_optlst[optnum].wol_argdefn,
X                (char *)&uwip.uwip_option.uwop_val, na_hton);
X        }
X        (void)write(w->w_ctlfd, (char *)&uwip, len);
X    }
X}
X
Xipc_ctlrecv(mfd, sd, win)
Xfildes_t mfd;
Xregister fildes_t sd;
Xregister struct window *win;
X{
X    register struct window *w;
X    register struct uwipc *uwip;
X
X    switch (ipc_getmsg(sd, inet_buf + sd)) {
X    case -1:
X        (void)close(sd);
X        fdmap[sd].f_type = FDT_NONE;
X        FD_CLR(sd, &selmask[0].sm_rd);
X        FD_CLR(sd, &selmask[0].sm_wt);
X        FD_CLR(sd, &selmask[0].sm_ex);
X        break;
X    case 1:
X        uwip = &inet_buf[sd].im_msg;
X        switch (uwip->uwip_cmd) {
X        case UWC_KILLW:
X            if ((uwip->uwip_len == sizeof(struct uwkillw) +
X                ((char *)&uwip->uwip_killw - (char *)uwip))) {
X                w = win_search(ntohl(uwip->uwip_killw.uwkw_id),
X                    protocol->p_maxwin);
X                if (w == win)
X                    PCL_KILLW(mfd, w);
X            }
X            break;
X        case UWC_OPTION:
X            /* hope the message is long enough... sigh */
X            if (uwip->uwip_len >
X             ((char *)&uwip->uwip_option.uwop_val - (char *)uwip)) {
X                w = win_search(ntohl(uwip->uwip_option.uwop_id),
X                    protocol->p_maxwin);
X                if (w == win) {
X                    opt_extopt((caddr_t)w, &w->w_optdefn,
X                        (woptcmd_t)ntohs(uwip->uwip_option.uwop_cmd),
X                        (woption_t)ntohs(uwip->uwip_option.uwop_opt),
X                        (char *)&uwip->uwip_option.uwop_val,
X                        na_ntoh);
X                }
X            }
X            break;
X        }
X        inet_buf[sd].im_len = 0;
X    }
X}
X
Xipc_getmsg(sd, im)
Xregister fildes_t sd;
Xregister struct ipcmsg *im;
X{
X    register int len;
X    register char *cp;
X
X    /*
X     * Read some more bytes from socket "sd" into the message buffer
X     * contained in "im".  Return 1 if the message is now complete,
X     * -1 if an EOF was reached, or 0 otherwise.  Before returning 1,
X     * the byte order of the common parameters (command, length) is
X     * changed from network to host order.
X     *
X     * This routine expects the socket to use non-blocking I/O (which
X     * is enabled by ipc_isrecv() when the connection is accepted).
X     */
X    cp = (char *)&im->im_msg + im->im_len;
X    if (im->im_len < sizeof(im->im_msg.uwip_len)) {
X        len = read(sd, cp, sizeof im->im_msg.uwip_len - im->im_len);
X        if (len == 0 || (len < 0 && errno != EWOULDBLOCK))
X            return(-1);
X        if ((im->im_len += len) < sizeof im->im_msg.uwip_len)
X            return(0);
X        im->im_msg.uwip_len = ntohs(im->im_msg.uwip_len);
X        if (im->im_msg.uwip_len == sizeof im->im_msg.uwip_len)
X            return(1);
X        cp += len;
X    }
X    if (im->im_msg.uwip_len > sizeof(struct ipcmsg))
X        im->im_msg.uwip_len = sizeof(struct ipcmsg);
X    len = read(sd, cp, im->im_msg.uwip_len - im->im_len);
X    if (len == 0)
X        return(-1);
X    if (len < 0)
X        return((errno==EWOULDBLOCK) ? 0 : -1);
X    if ((im->im_len += len) == im->im_msg.uwip_len) {
X        im->im_msg.uwip_cmd = ntohs(im->im_msg.uwip_cmd);
X        return(1);
X    } else
X        return(0);
X}
!EOF!server/uw_ipc.c!
echo x - server/uw_opt.c
sed -e 's/^X//' > server/uw_opt.c << '!EOF!server/uw_opt.c!'
X/*
X *    uw_opt - window option handling for UW
X *
X * Copyright 1986 by John D. Bruner.  All rights reserved.  Permission to
X * copy this program is given provided that the copy is not sold and that
X * this copyright notice is included.
X */
X
X#include <sys/types.h>
X
X#include "uw_param.h"
X#include "uw_opt.h"
X
X/*
X * The following variable is a kludge for efficiency.  It is set to
X * a nonzero value when a bitmask is changed, indicating that opt_scan()
X * should be called.
X */
Xint calloptscan;            /* pending,do,dont awaits opt_scan */
X
X/* option input state variables */
Xstatic caddr_t optwin;            /* window */
Xstatic struct woptdefn *optwod;        /* window option definition */
Xstatic woptcmd_t optcmd;        /* option command */
Xstatic woption_t optnum;        /* current option number */
Xstatic woptarg_t *optarg;        /* current encoding */
Xstatic int optcnt;            /* count in current encoding */
Xstatic char *optout;            /* decoded option */
Xstatic char optbuf[512];        /* buffer for decoded option */
X
Xopt_new(wod, generic, unique)
Xregister struct woptdefn *wod, *generic, *unique;
X{
X    register int n, mask;
X
X    /*
X     * Set up the option definition structure pointed to by "wod" to
X     * correspond with the option definitions in "generic" (common to
X     * all window types) and "unique" (per-window).
X     */
X    mask = (1<<(WONUM_GENERIC+1))-1;
X    if (unique) {
X        wod->wod_askrpt = unique->wod_askrpt & ~mask;
X        wod->wod_pending = unique->wod_pending & ~mask;
X        for (n=WONUM_GENERIC+1; n <= WONUM_MAX; n++)
X            wod->wod_optlst[n] = unique->wod_optlst[n];
X    } else {
X        wod->wod_askrpt = 0;
X        wod->wod_pending = 0;
X        for (n=WONUM_GENERIC+1; n <= WONUM_MAX; n++)
X            wod->wod_optlst[n].wol_argdefn = (woptarg_t *)0;
X    }
X    if (generic) {
X        wod->wod_askrpt |= generic->wod_askrpt & mask;
X        wod->wod_pending |= generic->wod_pending & mask;
X        for (n=1; n <= WONUM_GENERIC; n++)
X            wod->wod_optlst[n] = generic->wod_optlst[n];
X    } else {
X        for (n=1; n <= WONUM_GENERIC; n++)
X            wod->wod_optlst[n].wol_argdefn = (woptarg_t *)0;
X    }
X    wod->wod_do = wod->wod_askrpt;
X    wod->wod_dont = 0;
X    wod->wod_inquire = 0;
X    calloptscan = 1;
X}
X
Xopt_renew(wod, report)
Xregister struct woptdefn *wod;
Xint report;
X{
X    /*
X     * Reset "wod_do" for all window options that we want the Macintosh
X     * to report to us.  If "report" is nonzero, send the Mac the
X     * current values of these options.
X     */
X    wod->wod_do = wod->wod_askrpt;
X    wod->wod_dont = 0;
X    if (report)
X        wod->wod_pending = wod->wod_askrpt;
X    calloptscan = 1;
X}
X
Xopt_newtype(wod, generic, unique)
Xregister struct woptdefn *wod, *generic, *unique;
X{
X    register int n, bit;
X    register woptbmask_t oldask;
X
X    /*
X     * Change the window options to reflect a new window emulation type.
X     * The new emulation may not support all of the events that the old
X     * one did, and in any event they may not mean the same thing.
X     */
X    oldask = wod->wod_askrpt;
X    opt_new(wod, generic, unique);
X    for (n=1, bit=2; n <= WONUM_GENERIC; n++,bit<<=1) {
X        if ((oldask&bit) && !(wod->wod_askrpt&bit))
X            wod->wod_dont |= bit;
X        if (!(oldask&bit) && (wod->wod_askrpt&bit))
X            wod->wod_do |= bit;
X    }
X    for ( ; n <= WONUM_MAX; n++, bit<<=1)
X        if (wod->wod_askrpt&bit)
X            wod->wod_do |= bit;
X    calloptscan = 1;
X}
X
Xopt_setext(wod, fn)
Xregister struct woptdefn *wod;
Xregister void (*fn)();
X{
X    register int n;
X
X    /*
X     * Set "wol_ext" to "fn" for each option that has a defined "wol_set".
X     */
X    for (n=1; n <= WONUM_MAX; n++)
X        if (wod->wod_optlst[n].wol_set)
X            wod->wod_optlst[n].wol_ext = fn;
X}
X
Xopt_scan(w, wod, fn, mfd, cmd)
Xcaddr_t w;
Xregister struct woptdefn *wod;
Xvoid (*fn)();
Xfildes_t mfd;
Xint cmd;
X{
X    register struct woptlst *wol;
X    register char *cp;
X    register int n, bit, maxsize;
X    char buf[512];
X
X    /*
X     * Scan the entire list of options for pending ones.  For each
X     * one, call "fn".  "cmd" is the command that we are to pass as the
X     * first argument to "fn".
X     *
X     * Note that we must send data (wod_pending) before processing
X     * DO commands (wod_do); otherwise, the host and Mac may not
X     * agree upon the value of a window option.  (The Mac might
X     * respond to the "do" command before it sees the new value.)
X     */
X    cp = buf;
X#ifdef notdef
X    for (n=1,bit=2,wol=wod->wod_optlst+1; n<=WONUM_MAX; n++,bit<<=1,wol++) {
X#else
X    for (n=WONUM_MAX, bit=(1<<WONUM_MAX), wol=wod->wod_optlst+WONUM_MAX;
X         n > 0;
X         n--, bit >>= 1, wol--) {
X#endif
X        if (wod->wod_pending&bit) {
X            wod->wod_pending &= ~bit;
X            if (wol->wol_argdefn) {
X                maxsize = 2 +
X                    opt_size(wol->wol_argdefn);
X                if (cp > buf + sizeof buf - maxsize - 1) {
X                    *cp++ = 0;
X                    (*fn)(mfd, cmd, buf, cp-buf);
X                    cp = buf;
X                }
X                if (WONUM_USELONG(n)) {
X                    *cp++ = WOC_SET|WONUM_LPREFIX;
X                    *cp++ = WONUM_LENCODE(n);
X                } else
X                    *cp++ = WOC_SET|WONUM_SENCODE(n);
X                cp += opt_encode(cp, wol->wol_argdefn,
X                    (*wol->wol_get)(w, n));
X            }
X        }
X        if (wod->wod_inquire&bit) {
X            wod->wod_inquire &= ~bit;
X            if (cp > buf + sizeof buf - 3) {
X                *cp++ = 0;
X                (*fn)(mfd, cmd, buf, cp-buf);
X                cp = buf;
X            }
X            if (wol->wol_argdefn) {
X                if (WONUM_USELONG(n)) {
X                    *cp++ = WOC_INQUIRE|WONUM_LPREFIX;
X                    *cp++ = WONUM_LENCODE(n);
X                } else
X                    *cp++ = WOC_INQUIRE|WONUM_SENCODE(n);
X            }
X        }
X        if ((wod->wod_do|wod->wod_dont)&bit) {
X            if (cp > buf + sizeof buf - 3) {
X                *cp++ = 0;
X                (*fn)(mfd, cmd, buf, cp-buf);
X                cp = buf;
X            }
X            if (wod->wod_do&bit) {
X                wod->wod_do &= ~bit;
X                wod->wod_dont &= ~bit;
X                if (wol->wol_argdefn) {
X                    if (WONUM_USELONG(n)) {
X                        *cp++ = WOC_DO|WONUM_LPREFIX;
X                        *cp++ = WONUM_LENCODE(n);
X                    } else
X                        *cp++ = WOC_DO|WONUM_SENCODE(n);
X                }
X            } else if (wod->wod_dont&bit) {
X                wod->wod_do &= ~bit;
X                wod->wod_dont &= ~bit;
X                if (wol->wol_argdefn) {
X                    if (WONUM_USELONG(n)) {
X                        *cp++ = WOC_DONT|WONUM_LPREFIX;
X                        *cp++ = WONUM_LENCODE(n);
X                    } else
X                        *cp++=WOC_DONT|WONUM_SENCODE(n);
X                }
X            }
X        }
X        if (cp > buf) {
X            *cp++ = 0;
X            (*fn)(mfd, cmd, buf, cp-buf);
X            cp = buf;
X        }
X    }
X}
X
Xopt_size(woa)
Xregister woptarg_t *woa;
X{
X    register int size, cnt;
X
X    /*
X     * Determine the maximum size of an option whose argument encoding
X     * is specified by "woa".  This does NOT include additional encoding
X     * (e.g. for meta characters) at the protocol level.
X     */
X    if (woa) {
X        for (size=0; *woa != WOA_END; woa++) {
X            cnt = *woa & ~WOA_CMDMASK;
X            switch (*woa & WOA_CMDMASK) {
X            case WOA_CHARS(0):
X            case WOA_STRING(0):
X                size += cnt;
X                break;
X            case WOA_UDATA(0):
X                size += (cnt + 5) / 6;
X                break;
X            }
X        }
X    } else
X        size = 0;
X    return(size);
X}
X
Xopt_encode(buf, woa, data)
Xchar *buf;
Xregister woptarg_t *woa;
Xchar *data;
X{
X    register char *cp, *cq;
X    register int n, cnt;
X    register unsigned long ival;
X    union {
X        struct {
X            char    c1;
X            short    s;
X        }    cs;
X        struct {
X            char    c2;
X            long    l;
X        }    cl;
X    } u;
X
X    /*
X     * Encode "data" according to the option argument specifier "woa"
X     * into the buffer "buf".  Return the number of bytes of "buf"
X     * actually used.  The caller has already verified that "buf" is
X     * large enough.
X     */
X    if (!data)
X        return(0);
X    for (cp=buf,cq=data; *woa != WOA_END; woa++) {
X        cnt = *woa & ~WOA_CMDMASK;
X        switch (*woa & WOA_CMDMASK) {
X        case WOA_CHARS(0):
X            for (n=0; n < cnt; n++)
X                *cp++ = *cq++;
X            break;
X        case WOA_STRING(0):
X            for (n=0; n < cnt-1 && *cq; n++)
X                *cp++ = *cq++;
X            if (n < cnt)
X                cq += cnt-n;
X            *cp++ = '\0';
X            break;
X        case WOA_UDATA(0):
X            if (cnt <= NBBY) {
X                ival = (unsigned char)*cq++;
X            } else if (cnt <= sizeof(short)*NBBY) {
X                while ((int)cq & ((char *)&u.cs.s-&u.cs.c1-1))
X                    cq++;
X                ival = *(unsigned short *)cq;
X                cq += sizeof(short);
X            } else {
X                while ((int)cq & ((char *)&u.cl.l-&u.cl.c2-1))
X                    cq++;
X                ival = *(unsigned long *)cq;
X                cq += sizeof(long);
X            }
X            if (cnt != sizeof(long)*NBBY)
X                ival &= (1<<cnt) - 1;
X            for (n=0; n < cnt; n += 6, ival >>= 6)
X                *cp++ = (ival & 077) | 0100;
X            break;
X        }
X    }
X    return(cp-buf);
X}
X
Xopt_istart(w, wod)
Xcaddr_t w;
Xstruct woptdefn *wod;
X{
X    /*
X     * Start collecting input for a window option specification.
X     */
X    optwin = w;
X    optwod = wod;
X    optnum = 0;
X}
X
Xopt_input(c)
Xchar c;
X{
X    register int cnt, bit;
X    register struct woptdefn *wod;
X    register struct woptlst *wol;
X    register unsigned long ival;
X    union {
X        struct {
X            char    c1;
X            short    s;
X        }    cs;
X        struct {
X            char    c2;
X            long    l;
X        }    cl;
X    } u;
X
X    /*
X     * Add the received character "c" to the current option specification.
X     * If it is complete, take the appropriate action.  If option 0
X     * (the endmarker) is received, return 0 (to notify the caller that
X     * we are done).  Otherwise, return 1 -- more option data remains
X     * to be processed.
X     *
X     * This code isn't as readable as it should be; there are far too
X     * many return statements floating around.  Sorry about that.
X     */
X    if (optwin) {
X        wod = optwod;
X        if (optnum == 0 || optnum == WONUM_MAX+1) {
X            /* start (or continue) decoding a new option */
X            if (optnum == 0) {
X                /* start new option (or decode endmarker) */
X                if (c & WONUM_MASK) {
X                    /* new option */
X                    optcmd = c & WOC_MASK;
X                    if (WOC_BADCMD(optcmd)) {
X                        opt_iflush();
X                        return(0);
X                    }
X                    if (c == WONUM_LPREFIX) {
X                        optnum = WONUM_MAX+1;
X                        return(1);
X                    } else
X                        optnum = WONUM_SDECODE(c);
X                } else {
X                    /* end of options */
X                    opt_iflush();
X                    return(0);
X                }
X            } else {
X                /* read second byte of long option number */
X                optnum = WONUM_LDECODE(c);
X                if (optnum > WONUM_MAX) {
X                    opt_iflush();
X                    return(0);
X                }
X            }
X            /*
X             * This point is reached when the option number has
X             * been completely decoded.  If the command is not
X             * WOC_SET, then it has no arguments and we can
X             * process it immediately.
X             */
X            wol = &wod->wod_optlst[optnum];
X            bit = 1<<optnum;
X            if (optcmd == WOC_SET) {
X                optout = optbuf;
X                optcnt = 0;
X                optarg = wol->wol_argdefn;
X                if (!optarg) {
X                    opt_iflush();
X                    return(0);
X                }
X            } else {
X                if (wol->wol_ext &&
X                    (optcmd == WOC_WILL || optcmd == WOC_WONT))
X                    (*wol->wol_ext)(optwin, optcmd,
X                        optnum, (char *)0, 0);
X                switch (optcmd) {
X                case WOC_INQUIRE:
X                    wod->wod_pending |= bit;
X                    calloptscan = 1;
X                    break;
X                case WOC_DO:
X                case WOC_DONT:
X                    break;
X                case WOC_WILL:
X                    wod->wod_askrpt |= bit;
X                    wod->wod_do &= ~bit;
X                    break;
X                case WOC_WONT:
X                    wod->wod_askrpt &= ~bit;
X                    wod->wod_dont &= ~bit;
X                    break;
X                }
X                optnum = 0;
X            }
X            return(1);
X        } else {
X            /* continue processing argument to option */
X            wol = &wod->wod_optlst[optnum];
X            bit = 1<<optnum;
X            cnt = *optarg & ~WOA_CMDMASK;
X            switch (*optarg & WOA_CMDMASK) {
X            case WOA_CHARS(0):
X                *optout++ = c;
X                optcnt++;
X                break;
X            case WOA_STRING(0):
X                *optout++ = c;
X                optcnt++;
X                if (!c) {
X                    optout += cnt - optcnt;
X                    optcnt = cnt;
X                } else if (optcnt == cnt-1) {
X                    *optout++ = '\0';
X                    optcnt = cnt;
X                }
X                break;
X            case WOA_UDATA(0):
X                if (optcnt == 0) {
X                    if (cnt <= NBBY) {
X                        *optout = 0;
X                    } else if (cnt <= sizeof(short)*NBBY) {
X                        while ((int)optout & ((char *)&u.cs.s-&u.cs.c1-1))
X                            optout++;
X                        *(short *)optout = 0;
X                    } else {
X                        while ((int)optout & ((char *)&u.cl.l-&u.cl.c2-1))
X                            optout++;
X                        *(long *)optout = 0;
X                    }
X                }
X                ival = (c & 077) << optcnt;
X                if (cnt != NBBY*sizeof(long))
X                    ival &= (1<<cnt) - 1;
X                optcnt += 6;
X                if (cnt <= NBBY) {
X                    *(unsigned char *)optout |= (unsigned char)ival;
X                    if (optcnt >= cnt)
X                        optout++;
X                } else if (cnt <= sizeof(short)*NBBY) {
X                    *(unsigned short *)optout |= (unsigned short)ival;
X                    if (optcnt >= cnt)
X                        optout += sizeof(short);
X                } else {
X                    *(unsigned long *)optout |= ival;
X                    if (optcnt >= cnt)
X                        optout += sizeof(long);
X                }
X                break;
X            }
X            if (optcnt >= cnt) {
X                optcnt = 0;
X                if (*++optarg == WOA_END) {
X                    wod->wod_pending &= ~bit;
X                    (*wol->wol_set)(optwin, optnum, optbuf);
X                    if (wol->wol_ext) {
X                        (*wol->wol_ext)(optwin, WOC_SET,
X                            optnum, optbuf,
X                            optout-optbuf);
X                    }
X                    optnum = 0;
X                }
X            }
X            return(1);
X        }
X        /*NOTREACHED*/
X    }
X    return(0);
X}
X
Xopt_iflush()
X{
X    optwin = (caddr_t)0;
X}
X
Xopt_extopt(w, wod, cmd, num, data, na)
Xcaddr_t w;
Xregister struct woptdefn *wod;
Xwoptcmd_t cmd;
Xwoption_t num;
Xchar *data;
Xstruct netadj *na;
X{
X    register struct woptlst *wol;
X
X    if (w != NULL && wod != NULL && num <= WONUM_MAX) {
X        wol = wod->wod_optlst + num;
X        if (wol->wol_argdefn) {
X            switch (cmd) {
X            case WOC_SET:
X                if (data && wol->wol_set) {
X                    if (na) {
X                        opt_netadj(wol->wol_argdefn,
X                            data, na);
X                    }
X                    /*
X                     * Set the new value and notify the Mac.
X                     * Because of a race condition (the Mac
X                     * might concurrently be sending us its
X                     * value for this option), we ask the
X                     * Mac to send back the value after it
X                     * is set.
X                     */
X                    (*wol->wol_set)(w, num, data);
X                    WOPT_SET(wod->wod_pending, num);
X                    WOPT_SET(wod->wod_inquire, num);
X                    calloptscan = 1;
X                }
X                break;
X            case WOC_INQUIRE:
X                WOPT_SET(wod->wod_inquire, num);
X                calloptscan = 1;
X                break;
X            case WOC_DO:
X                WOPT_SET(wod->wod_do, num);
X                WOPT_SET(wod->wod_askrpt, num);
X                calloptscan = 1;
X                break;
X            case WOC_DONT:
X                WOPT_SET(wod->wod_dont, num);
X                WOPT_CLR(wod->wod_askrpt, num);
X                calloptscan = 1;
X                break;
X            }
X        }
X    }
X}
X
Xopt_netadj(woa, data, na)
Xregister woptarg_t *woa;
Xchar *data;
Xregister struct netadj *na;
X{
X    register char *cp;
X    register int cnt;
X    union {
X        struct {
X            char    c1;
X            short    s;
X        }    cs;
X        struct {
X            char    c2;
X            long    l;
X        }    cl;
X    } u;
X
X    /*
X     * Convert an option (in internal format) from host byte order
X     * to network byte order.  If the two are the same then this is
X     * a NOP.
X     */
X    if (data && na) {
X        for (cp=data; *woa != WOA_END; woa++) {
X            cnt = *woa & ~WOA_CMDMASK;
X            switch (*woa & WOA_CMDMASK) {
X            case WOA_CHARS(0):
X            case WOA_STRING(0):
X                cp += cnt;
X                break;
X            case WOA_UDATA(0):
X                if (cnt <= NBBY) {
X                    cp++;
X                } else if (cnt <= sizeof(short)*NBBY) {
X                    while ((int)cp & ((char *)&u.cs.s-&u.cs.c1-1))
X                        cp++;
X                    *(u_short *)cp =
X                        (*na->na_ushort)(*(u_short *)cp);
X                    cp += sizeof(short);
X                } else {
X                    while ((int)cp & ((char *)&u.cl.l-&u.cl.c2-1))
X                        cp++;
X                    *(u_short *)cp =
X                        (*na->na_ushort)(*(u_short *)cp);
X                    cp += sizeof(long);
X                }
X            }
X        }
X    }
X}
!EOF!server/uw_opt.c!
echo x - server/uw_pcl.c
sed -e 's/^X//' > server/uw_pcl.c << '!EOF!server/uw_pcl.c!'
X/*
X *    uw_pcl - protocol handling for UW
X *
X * Copyright 1985,1986 by John D. Bruner.  All rights reserved.  Permission to
X * copy this program is given provided that the copy is not sold and that
X * this copyright notice is included.
X */
X
X#include <sys/types.h>
X#include <sys/ioctl.h>
X#include <errno.h>
X
X#include "uw_param.h"
X#include "uw_clk.h"
X#include "uw_opt.h"
X#include "uw_win.h"
X#include "uw_pcl.h"
X#include "openpty.h"
X
X#define    XON    0021            /* ASCII XON */
X#define    XOFF    0023            /* ASCII XOFF */
X#define    RUB    0177            /* ASCII RUBout */
X#define    META    0200            /* "meta" bit for whatever it's worth */
X
X/*
X * Protocol negotiation is performed by a finite state machine (implemented
X * in pcl_haggle()).  The states are defined as the enumerated type
X * "pnstate_t".  The inputs have type "pnreq_t".
X */
Xtypedef enum {
X    PNST_NOP,            /* no protocol negotiation */
X    PNST_AWAIT,            /* timing out an ASKPCL */
X    PNST_CWAIT,            /* timing out a CANPCL */
X    PNST_OK,            /* negotiations completed */
X    PNST_FAIL            /* negotiation failed */
X} pnstate_t;
X
Xtypedef unsigned short pnreq_t;        /* finite state machine requests */
X#define    PNRQ_PCL    0000377        /* protocol mask */
X#define    PNRQ_CMD    0177400        /* command mask: */
X#define    PNRQ_NONE    (pnreq_t)(0<<8)    /*    no request */
X#define    PNRQ_START    (pnreq_t)(1<<8)    /*    start negotiation */
X#define    PNRQ_AWAIT    (pnreq_t)(2<<8)    /*    timeout waiting for ASKPCL */
X#define    PNRQ_ASK    (pnreq_t)(3<<8)    /*    process received ASKPCL */
X#define    PNRQ_CAN    (pnreq_t)(4<<8)    /*    process received CANPCL */
X#define    PNRQ_SET    (pnreq_t)(5<<8)    /*    process received SETPCL */
X#define    PNRQ_CWAIT    (pnreq_t)(6<<8)    /*    timeout waiting for CANPCL */
X#define    PNRQ_INIT    (pnreq_t)(7<<8)    /*    initialize everything */
X
Xstatic int p1_ctlch[] = { -1, P1_IAC, XON, XOFF, -1, -1, -1, -1 };
X
Xextern void p1_entry(), p1_renew(), p2_renew();
Xextern struct window *p1_neww(), *p2_neww();
Xextern void p1_killw(), p1_xmit(), p1_recv();
Xextern void p1_askpcl(), p1_canpcl(), p1_setpcl();
Xextern void p2_recv(), p2_chkopt(), p2_sendopt();
X
Xstatic struct protocol pcl_table[] = {
X    {
X      ' ',
X      P1_NWINDOW,
X      p1_ctlch, sizeof p1_ctlch / sizeof p1_ctlch[0],
X      p1_entry, NULL, p1_renew,
X      p1_neww, p1_killw,
X      p1_xmit, p1_recv, NULL, NULL,
X      p1_askpcl, p1_canpcl, p1_setpcl
X    },
X    {
X      '!',
X      P2_NWINDOW,
X      p1_ctlch, sizeof p1_ctlch / sizeof p1_ctlch[0],
X      p1_entry, NULL, p2_renew,
X      p2_neww, p1_killw,
X      p1_xmit, p2_recv, p2_chkopt, p2_sendopt,
X      p1_askpcl, p1_canpcl, p1_setpcl
X    },
X};
X
Xstruct protocol *protocol = pcl_table;
X
X/*
X * Two "current" windows are defined: the current input window (for
X * input from the Macintosh) and the current output window (for output
X * to the Macintosh).
X */
Xstatic struct {
X    struct window    *in;
X    struct window    *out;
X} curwin;
X
X
Xpcl_entry(mfd)
Xregister fildes_t mfd;
X{
X    /*
X     * This routine is called to start up protocol handling.  We always
X     * start with protocol 1 (the original UW protocol).
X     */
X    protocol = pcl_table;
X    pcl_haggle(mfd, PNRQ_INIT);
X    if (protocol->p_entry)
X        (*protocol->p_entry)(mfd);
X}
X
Xpcl_exit(mfd)
Xregister fildes_t mfd;
X{
X    /*
X     * This routine is called when we shut down (just before the server
X     * exits).
X     */
X    if (protocol->p_exit)
X        (*protocol->p_exit)(mfd);
X    protocol = pcl_table;
X}
X
Xstatic
Xpcl_newpcl(newproto)
Xstruct protocol *newproto;
X{
X    extern void rc_kludge();
X
X    /*
X     * Switch to new protocol "newproto".  Right now we can get away
X     * with just changing the value of "protocol".  Eventually we will
X     * probably want to call protocol-dependent functions to shut down
X     * the old protocol and start up the new one.
X     */
X    protocol = newproto;
X
X    /*
X     * This is a horrible kludge.  See rc_kludge() in "main.c" for
X     * further details.
X     */
X    rc_kludge();
X}
X
Xstatic
Xvoid
Xpcl_tohaggle(arg)
Xregister toarg_t arg;
X{
X    /*
X     * This is a kludge to get around the single-argument restriction
X     * on clk_timeout.  We split the argument "arg" into two 16-bit
X     * pieces and invoke pcl_haggle.
X     */
X    pcl_haggle((fildes_t)((arg>>16)&0177777), (pnreq_t)(arg&0177777));
X}
X
Xstatic
Xpcl_haggle(mfd, req)
Xfildes_t mfd;
Xregister pnreq_t req;
X{
X    register struct protocol *p, *q;
X    register char pname;
X    register int request;
X    static pnstate_t pnstate;
X    static int waitcnt;
X
X    /*
X     * This routine implements the finite-state machine that handles
X     * protocol negotiation.  This routine is called by routines which
X     * recognize incoming protocol commands and at 5 second intervals
X     * when negotiations are in progress.  The current protocol is
X     * described by the variable "protocol".
X     */
X    if (req == PNRQ_INIT) {
X        waitcnt = 0;
X        pnstate = PNST_NOP;
X        req = PNRQ_NONE;
X    }
X    if (!(p = protocol) || !p->p_askpcl || !p->p_canpcl || !p->p_setpcl) {
X        req = PNRQ_NONE;
X    } else {
X        pname = req & PNRQ_PCL;
X        request = req & PNRQ_CMD;
X        switch (request) {
X        case PNRQ_START:    /* start protocol negotiation */
X            /*
X             * The Macintosh is responsible for starting protocol
X             * negotiation (if it wants something other than the
X             * standard protocol).  This code is present for
X             * purposes of exposition only.
X             */
X            (*p->p_askpcl)(mfd);
X            req = PNRQ_AWAIT | pname;
X            waitcnt = 0;
X            pnstate = PNST_AWAIT;
X            break;
X        case PNRQ_AWAIT:    /* timeout an ASKPCL */
X            /*
X             * This state also is not reached on the host.
X             */
X            if (pnstate == PNST_AWAIT) {
X                if (++waitcnt > 3) {
X                    pnstate = PNST_FAIL;
X                    req = PNRQ_NONE;
X                } else
X                    (*p->p_askpcl)(mfd);
X            } else
X                req = PNRQ_NONE;
X            break;
X        case PNRQ_ASK:        /* handle received ASKPCL */
X            q = pcl_table+sizeof pcl_table/sizeof pcl_table[0] - 1;
X            (*p->p_canpcl)(mfd, q->p_name);
X            pnstate = PNST_CWAIT;
X            req = PNRQ_CWAIT | q->p_name;
X            waitcnt = 0;
X            break;
X        case PNRQ_CAN:        /* handle received CANPCL */
X            for (q=pcl_table+sizeof pcl_table/sizeof pcl_table[0]-1;
X                 q > pcl_table && q->p_name > pname;
X                 q--)
X                ;
X            if (q->p_name == pname || q == pcl_table) {
X                (*p->p_setpcl)(mfd, q->p_name);
X                pcl_newpcl(q);
X                pnstate = PNST_OK;
X                req = PNRQ_NONE;
X            } else {
X                (*p->p_canpcl)(mfd, q->p_name);
X                pnstate = PNST_CWAIT;
X                req = PNRQ_CWAIT | q->p_name;
X                waitcnt = 0;
X            }
X            break;
X        case PNRQ_CWAIT:    /* timeout a CANPCL */
X            if (pnstate == PNST_CWAIT) {
X                if (++waitcnt > 3) {
X                    pnstate = PNST_FAIL;
X                    req = PNRQ_NONE;
X                } else
X                    (*p->p_canpcl)(mfd, pname);
X            } else
X                req = PNRQ_NONE;
X            break;
X        case PNRQ_SET:        /* handle a received SETPCL */
X            for (q=pcl_table+sizeof pcl_table/sizeof pcl_table[0]-1;
X                 q > pcl_table && q->p_name != pname;
X                 q--)
X                ;
X            if (q->p_name == pname) {
X                pcl_newpcl(q);
X                pnstate = PNST_OK;
X                req = PNRQ_NONE;
X            } else {
X                /*
X                 * We are in trouble now -- the Mac has
X                 * instructed us to switch to a protocol
X                 * that we can't support.  We switch back
X                 * to protocol 1 and hope that our message
X                 * to the Mac (telling it to switch to
X                 * protocol 1) will be interpreted correctly.
X                 */
X                pnstate = PNST_FAIL;
X                req = PNRQ_NONE;
X                (*p->p_setpcl)(mfd, ' ');
X                if (p != pcl_table)
X                    pcl_newpcl(pcl_table);
X            }
X            break;
X        }
X        if (req != PNRQ_NONE)
X            (void)clk_timeout(5*CLK_HZ,
X                pcl_tohaggle, (toarg_t)(((long)mfd<<16)|req));
X    }
X}
X
Xstatic
Xvoid
Xp1_entry(mfd)
Xfildes_t mfd;
X{
X    static char cmdbuf[2] = { P1_IAC };
X
X    cmdbuf[1] = P1_DIR_HTOM|P1_FN_MAINT|P1_MF_ENTRY;
X    (void)write(mfd, cmdbuf, sizeof cmdbuf);
X}
X
Xstatic
Xstruct window *
Xp1_neww(mfd, wclass, wtype, wnum, wid, datafd, ctlfd)
Xfildes_t mfd;
Xwclass_t wclass;
Xwtype_t wtype;
Xnwin_t wnum;
Xlong wid;
Xfildes_t datafd;
Xfildes_t ctlfd;
X{
X    register struct window *w;
X    static char cmdbuf[2] = { P1_IAC, 0 };
X
X    /*
X     * Create a new window for the host.  This routine is not called when
X     * the Macintosh creates a window.
X     */
X    w = win_neww(wclass, wtype, wnum, protocol->p_maxwin, wid,
X        datafd, ctlfd, (struct woptdefn *)0);
X    if (w) {
X        cmdbuf[1] = P1_DIR_HTOM|P1_FN_NEWW|WIN_NUM(w);
X        (void)write(mfd, cmdbuf, sizeof cmdbuf);
X    }
X    return(w);
X}
X
Xstatic
Xvoid
Xp1_killw(mfd, w)
Xregister struct window *w;
X{
X    static char cmdbuf[] = { P1_IAC, P1_DIR_HTOM|P1_FN_KILLW };
X
X    /*
X     * Kill window "w" and tell the Macintosh to do the same.
X     */
X    if (w && w->w_alloc) {
X        if (curwin.in == w)
X            curwin.in = (struct window *)0;
X        if (curwin.out == w)
X            curwin.out = (struct window *)0;
X        cmdbuf[1] = P1_DIR_HTOM|P1_FN_KILLW|WIN_NUM(w);
X        (void)write(mfd, cmdbuf, sizeof cmdbuf);
X        win_killw(w);
X    }
X}
X
Xstatic
Xvoid
Xp1_xmit(mfd, w)
Xfildes_t mfd;
Xregister struct window *w;
X{
X    register char *cp, *cq;
X    register int i, len;
X    char ibuf[32], obuf[32];
X    static char refresh;
X    static char cmdbuf[] = { P1_IAC, 0 };
X    extern int errno;
X
X    /*
X     * Transmit data to the Macintosh (via file descriptor "mfd)
X     * on behalf of window "w".  Be sure to convert any embedded
X     * control characters and meta characters.
X     *
X     * Note that the input/output buffers should NOT be very large.
X     * It is undesirable to perform large reads and effectively
X     * "lock out" all other file descriptors.  The chosen size
X     * should preserve a reasonable amount of efficiency.
X     *
X     * The UW protocol only requires an OSELW command when the
X     * output window changes.  We issue this command more often
X     * to "refresh" the Mac's idea of what the output window is.
X     * This helps (slightly) to overcome spurious output redirects
X     * caused by a noisy line.
X     */
X    if (w && w->w_alloc) {
X        if (curwin.out != w || ++refresh == 0) {
X            refresh = 0;
X            curwin.out = w;
X            cmdbuf[1] = P1_DIR_HTOM|P1_FN_OSELW|WIN_NUM(w);
X            (void)write(mfd, cmdbuf, sizeof cmdbuf);
X        }
X        cq = obuf;
X        if ((len = read(w->w_datafd, ibuf, sizeof ibuf)) < 0 &&
X            errno != EWOULDBLOCK)
X            (*protocol->p_killw)(mfd, w);
X        for (cp=ibuf; cp < ibuf+len; cp++) {
X            if (*cp&META) {
X                if (cq > obuf) {
X                    (void)write(mfd, obuf, cq-obuf);
X                    cq = obuf;
X                }
X                cmdbuf[1] = P1_DIR_HTOM|P1_FN_META;
X                (void)write(mfd, cmdbuf, sizeof cmdbuf);
X                *cp &= ~META;
X            }
X            i = -1;
X            if (*cp == RUB || *cp < ' ') {
X                i = protocol->p_szctlch - 1;
X                while (i >= 0 && protocol->p_ctlch[i] != *cp)
X                    i--;
X            }
X            if (i >= 0) {
X                if (cq > obuf) {
X                    (void)write(mfd, obuf, cq-obuf);
X                    cq = obuf;
X                }
X                cmdbuf[1] = P1_DIR_HTOM|P1_FN_CTLCH|i;
X                (void)write(mfd, cmdbuf, sizeof cmdbuf);
X            } else {
X                *cq++ = *cp;
X                if (cq >= obuf+sizeof obuf) {
X                    (void)write(mfd, obuf, cq-obuf);
X                    cq = obuf;
X                }
X            }
X        }
X        if (cq > obuf)
X            (void)write(mfd, obuf, cq-obuf);
X    } else
X        (void)read(w->w_datafd, ibuf, sizeof ibuf);
X}
X
Xstatic
Xvoid
Xp1_recv(mfd, cbuf, clen)
Xfildes_t mfd;
Xchar *cbuf;
Xint clen;
X{
X    register int len;
X    register char *buf, *cp, *cq;
X    register struct window *w;
X    nwin_t wnum;
X    auto int nready;
X    char ibuf[512], obuf[512];
X    static int seen_iac, seen_meta;
X    static pnreq_t pnrq_cmd;
X    static char cmdbuf[2] = { P1_IAC };
X
X    /*
X     * The received bytestream is examined.  Non-command bytes are
X     * written to the file descriptor corresponding to the current
X     * "input" window (relative to the Macintosh -- the window the
X     * user types input to).
X     *
X     * If "clen" is nonzero, then the contents of the buffer "cbuf"
X     * are processed before any input is read.
X     */
X    if (ioctl(mfd, (int)FIONREAD, (char *)&nready) < 0) {
X        perror("FIONREAD");
X        return;
X    }
X    nready += clen;
X
X    for (cq = obuf; nready > 0; nready -= len) {
X        if (clen > 0) {
X            len = clen;
X            buf = cbuf;
X            clen = 0;
X        } else {
X            if (nready > sizeof ibuf)
X                len = read(mfd, ibuf, sizeof ibuf);
X            else
X                len = read(mfd, ibuf, nready);
X            if (len <= 0) {
X                perror("read");
X                return;
X            }
X            buf = ibuf;
X        }
X        for (cp=buf; cp < buf+len; cp++) {
X            if (pnrq_cmd) {
X                pcl_haggle(mfd, pnrq_cmd|*cp);
X                pnrq_cmd = 0;
X                /* pcl_haggle may have changed the protocol */
X                if (protocol != pcl_table) {
X                    if (protocol->p_recv)
X                        (*protocol->p_recv)(mfd,
X                            cp+1, buf+len-cp-1);
X                    return;
X                }
X            } else if (seen_iac) {
X                if ((*cp&P1_DIR) == P1_DIR_MTOH) {
X                    if (cq > obuf) {
X                        (void)write(curwin.in->w_datafd,
X                                obuf, cq-obuf);
X                        cq = obuf;
X                    }
X                    switch (*cp & P1_FN) {
X                    case P1_FN_NEWW:
X                        wnum = *cp & P1_WINDOW;
X                        if (!wnum)
X                            break;
X                        w = WIN_PTR(wnum);
X                        if (w->w_alloc)
X                            break;
X                        if (!win_neww(WC_INTERNAL,
X                            defwtype, wnum,
X                            protocol->p_maxwin, 0L,
X                            (fildes_t)-1, (fildes_t)-1,
X                            (struct woptdefn *)0)) {
X                            cmdbuf[1] = P1_DIR_HTOM|
X                                P1_FN_KILLW|wnum;
X                            (void)write(mfd, cmdbuf,
X                                sizeof cmdbuf);
X                        }
X                        break;
X                    case P1_FN_KILLW:
X                        wnum = *cp & P1_WINDOW;
X                        if (!wnum)
X                            break;
X                        win_killw(WIN_PTR(wnum));
X                        break;
X                    case P1_FN_ISELW:
X                        wnum = *cp & P1_WINDOW;
X                        if (!wnum)
X                            break;
X                        w = WIN_PTR(wnum);
X                        if (w->w_alloc)
X                            curwin.in = w;
X                        else
X                            curwin.in = NULL;
X                        break;
X                    case P1_FN_META:
X                        seen_meta = 1;
X                        break;
X                    case P1_FN_CTLCH:
X                        *cq = protocol->p_ctlch[*cp&P1_CC];
X                        if (seen_meta) {
X                            seen_meta = 0;
X                            *cq |= META;
X                        }
X                        if (curwin.in)
X                            cq++;
X                        break;
X                    case P1_FN_MAINT:
X                        switch (*cp & P1_MF) {
X                        case P1_MF_ENTRY:
X                            (*protocol->p_renew)(mfd);
X                            break;
X                        case P1_MF_ASKPCL:
X                            pcl_haggle(mfd,PNRQ_ASK);
X                            break;
X                        case P1_MF_CANPCL:
X                            pnrq_cmd = PNRQ_CAN;
X                            break;
X                        case P1_MF_SETPCL:
X                            pnrq_cmd = PNRQ_SET;
X                            break;
X                        case P1_MF_EXIT:
X                            done(0);
X                            break;
X                        }
X                        break;
X                    }
X                }
X                seen_iac = 0;
X            } else if (*cp == P1_IAC)
X                seen_iac++;
X            else {
X                if (seen_meta) {
X                    seen_meta = 0;
X                    *cq = *cp | META;
X                } else
X                    *cq = *cp;
X                if (curwin.in) {
X                    if (++cq >= obuf+sizeof obuf) {
X                        (void)write(curwin.in->w_datafd,
X                                obuf, cq-obuf);
X                        cq = obuf;
X                    }
X                }
X            }
X        }
X    }
X    if (cq > obuf)
X        (void)write(curwin.in->w_datafd, obuf, cq-obuf);
X}
X
Xstatic
Xvoid
Xp1_askpcl(mfd)
Xfildes_t mfd;
X{
X    static char cmdbuf[2] = { P1_IAC,P1_DIR_HTOM|P1_FN_MAINT|P1_MF_ASKPCL };
X
X    (void)write(mfd, cmdbuf, sizeof cmdbuf);
X}
X
Xstatic
Xvoid
Xp1_canpcl(mfd, pname)
Xfildes_t mfd;
Xchar pname;
X{
X    static char cmdbuf[3] = { P1_IAC,P1_DIR_HTOM|P1_FN_MAINT|P1_MF_CANPCL };
X
X    cmdbuf[2] = pname;
X    (void)write(mfd, cmdbuf, sizeof cmdbuf);
X}
X
Xstatic
Xvoid
Xp1_setpcl(mfd, pname)
Xfildes_t mfd;
Xchar pname;
X{
X    static char cmdbuf[3] = { P1_IAC,P1_DIR_HTOM|P1_FN_MAINT|P1_MF_SETPCL };
X
X    cmdbuf[2] = pname;
X    (void)write(mfd, cmdbuf, sizeof cmdbuf);
X}
X
Xstatic
Xvoid
Xp1_renew(mfd)
Xfildes_t mfd;
X{
X    register struct window *w;
X    static char cmdbuf[2] = { P1_IAC };
X
X    /*
X     * Re-init (re-NEW) an existing connection.  Send a NEWW command
X     * for each existing window.  This function is invoked when the
X     * Macintosh sends an ENTRY maintenance command.
X     */
X    for (w=window; w < window+protocol->p_maxwin; w++) {
X        if (w->w_alloc) {
X            win_renew(w, 0);
X            cmdbuf[1] = P1_DIR_HTOM|P1_FN_NEWW|WIN_NUM(w);
X            (void)write(mfd, cmdbuf, sizeof cmdbuf);
X        }
X    }
X}
X
Xstatic
Xvoid
Xp2_renew(mfd)
Xfildes_t mfd;
X{
X    register struct window *w;
X    static char cmdbuf[3] = { P2_IAC };
X
X    /*
X     * Re-init (re-NEW) an existing connection.  Send a NEWW command
X     * for each existing window.  This function is invoked when the
X     * Macintosh sends an ENTRY maintenance command.
X     */
X    for (w=window; w < window+protocol->p_maxwin; w++) {
X        if (w->w_alloc) {
X            win_renew(w, 1);
X            cmdbuf[1] = P2_DIR_HTOM|P2_FN_NEWW|WIN_NUM(w);
X            cmdbuf[2] = w->w_type + ' ';
X            (void)write(mfd, cmdbuf, sizeof cmdbuf);
X        }
X    }
X}
X
Xstatic
Xstruct window *
Xp2_neww(mfd, wclass, wtype, wnum, wid, datafd, ctlfd)
Xfildes_t mfd;
Xwclass_t wclass;
Xwtype_t wtype;
Xnwin_t wnum;
Xlong wid;
Xfildes_t datafd;
Xfildes_t ctlfd;
X{
X    register struct window *w;
X    static char cmdbuf[3] = { P2_IAC };
X
X    /*
X     * Create a new window as requested by the host.  This routine is not
X     * called when the Macintosh creates a window.
X     */
X    w = win_neww(wclass, wtype, wnum, protocol->p_maxwin, wid,
X        datafd, ctlfd, (struct woptdefn *)0);
X    if (w) {
X        cmdbuf[1] = P2_DIR_HTOM|P2_FN_NEWW|WIN_NUM(w);
X        cmdbuf[2] = ' ' + wtype;
X        (void)write(mfd, cmdbuf, sizeof cmdbuf);
X    }
X    return(w);
X}
X
Xstatic
Xvoid
Xp2_chkopt(mfd)
Xfildes_t mfd;
X{
X    register struct window *w;
X    nwin_t maxwin;
X
X    /*
X     * Ideally, this routine would call a routine in the window
X     * module (perhaps win_chkopt()), passing the maximum window
X     * number as one argument.  The "for" loop would be in that
X     * routine.  However, I'm not willing to accept the overhead
X     * for that conceptual nicety.
X     */
X    maxwin = protocol->p_maxwin;
X    for (w=window; w < window+maxwin; w++)
X        if (w->w_alloc)
X            opt_scan((caddr_t)w, &w->w_optdefn, p2_sendopt, mfd,
X                P2_FN_WOPT|WIN_NUM(w));
X}
X
Xstatic
Xvoid
Xp2_sendopt(mfd, fn, buf, len)
Xfildes_t mfd;
Xint fn;
Xregister char *buf;
Xregister int len;
X{
X    register char *cp;
X    register int i;
X    char outbuf[512];
X
X    /*
X     * Encode and transmit the option string contained in "buf".  The
X     * initial command (which will be P2_FN_WOPT|WIN_NUM(w)) is
X     * contained in "fn".
X     *
X     * The caller is responsible for handing us a correctly-formed
X     * option string.  This routine merely performs the protocol encoding
X     * which is required for control and meta characters.
X     */
X    curwin.out = NULL;
X    outbuf[0] = P2_IAC;
X    outbuf[1] = fn|P2_DIR_HTOM;
X    for (cp=outbuf+2; len > 0; buf++,len--) {
X        if (cp > outbuf+sizeof outbuf - 4) {
X            (void)write(mfd, outbuf, cp-outbuf);
X            cp = outbuf;
X        }
X        if (*buf & META) {
X            *cp++ = P2_IAC;
X            *cp++ = P2_DIR_HTOM|P2_FN_META;
X            *buf &= ~META;
X        }
X        i = -1;
X        if (*buf == RUB || *buf < ' ') {
X            i = protocol->p_szctlch - 1;
X            while (i >= 0 && protocol->p_ctlch[i] != *buf)
X                i--;
X        }
X        if (i >= 0) {
X            *cp++ = P2_IAC;
X            *cp++ = P2_DIR_HTOM|P2_FN_CTLCH|(i&7);
X        } else
X            *cp++ = *buf;
X    }
X    if (cp > outbuf)
X        (void)write(mfd, outbuf, cp-outbuf);
X}
X
Xstatic
Xvoid
Xp2_recv(mfd, cbuf, clen)
Xfildes_t mfd;
Xchar *cbuf;
Xint clen;
X{
X    register int len;
X    register char *buf, *cp, *cq;
X    register struct window *w;
X    register char c;
X    nwin_t wnum;
X    auto int nready;
X    char ibuf[512], obuf[512];
X    static int seen_iac, seen_meta, is_option;
X    static pnreq_t pnrq_cmd;
X    static nwin_t neww;
X    static char cmdbuf[2] = { P2_IAC };
X
X    /*
X     * The received bytestream is examined.  Non-command bytes are
X     * written to the file descriptor corresponding to the current
X     * "input" window (relative to the Macintosh -- the window the
X     * user types input to).
X     *
X     * If "clen" is nonzero, then the contents of the buffer "cbuf"
X     * are processed before any input is read.
X     */
X    if (ioctl(mfd, (int)FIONREAD, (char *)&nready) < 0) {
X        perror("FIONREAD");
X        return;
X    }
X    nready += clen;
X
X    for (cq = obuf; nready > 0; nready -= len) {
X        if (clen > 0) {
X            len = clen;
X            buf = cbuf;
X            clen = 0;
X        } else {
X            if (nready > sizeof ibuf)
X                len = read(mfd, ibuf, sizeof ibuf);
X            else
X                len = read(mfd, ibuf, nready);
X            if (len <= 0) {
X                perror("read");
X                return;
X            }
X            buf = ibuf;
X        }
X        for (cp=buf; cp < buf+len; cp++) {
X            if (pnrq_cmd) {
X                pcl_haggle(mfd, pnrq_cmd|*cp);
X                pnrq_cmd = 0;
X                /* pcl_haggle may have changed the protocol */
X                if (protocol != pcl_table) {
X                    if (protocol->p_recv)
X                        (*protocol->p_recv)(mfd,
X                            cp+1, buf+len-cp-1);
X                    return;
X                }
X            } else if (neww) {
X                w = WIN_PTR(neww);
X                if (!w->w_alloc &&
X                    !win_neww(WC_INTERNAL, (wtype_t)(*cp-' '),
X                    neww, protocol->p_maxwin, 0L,
X                    (fildes_t)-1, (fildes_t)-1,
X                    (struct woptdefn *)0)) {
X                    cmdbuf[1] = P2_DIR_HTOM|
X                        P2_FN_KILLW|neww;
X                    (void)write(mfd, cmdbuf,
X                        sizeof cmdbuf);
X                }
X                neww = 0;
X            } else if (seen_iac) {
X                if ((*cp&P2_DIR) == P2_DIR_MTOH) {
X                    c = *cp & P2_FN;
X                    if (is_option &&
X                        c!=P2_FN_META && c!=P2_FN_CTLCH) {
X                        opt_iflush();
X                        is_option = 0;
X                    }
X                    if (cq > obuf) {
X                        (void)write(curwin.in->w_datafd,
X                                obuf, cq-obuf);
X                        cq = obuf;
X                    }
X                    switch (*cp & P2_FN) {
X                    case P2_FN_NEWW:
X                        neww = *cp & P2_WINDOW;
X                        break;
X                    case P2_FN_WOPT:
X                        wnum = *cp & P2_WINDOW;
X                        if (!wnum)
X                            break;
X                        w = WIN_PTR(wnum);
X                        if (!w->w_alloc) {
X                            curwin.in = NULL;
X                            break;
X                        }
X                        is_option = 1;
X                        opt_istart((caddr_t)w, &w->w_optdefn);
X                        break;
X                    case P2_FN_KILLW:
X                        wnum = *cp & P2_WINDOW;
X                        if (!wnum)
X                            break;
X                        win_killw(WIN_PTR(wnum));
X                        break;
X                    case P2_FN_ISELW:
X                        wnum = *cp & P2_WINDOW;
X                        if (!wnum)
X                            break;
X                        w = WIN_PTR(wnum);
X                        if (w->w_alloc)
X                            curwin.in = w;
X                        else
X                            curwin.in = NULL;
X                        break;
X                    case P2_FN_META:
X                        seen_meta = 1;
X                        if ((*cp&P2_CC) == 0)
X                            break;
X                        /* no break */
X                    case P2_FN_CTLCH:
X                        c=protocol->p_ctlch[*cp&P2_CC];
X                        if (seen_meta) {
X                            seen_meta = 0;
X                            c |= META;
X                        }
X                        if (is_option)
X                            is_option=opt_input(c);
X                        else
X                            if (curwin.in)
X                                *cq++ = c;
X                        break;
X                    case P2_FN_MAINT:
X                        switch (*cp & P2_MF) {
X                        case P2_MF_ENTRY:
X                            (*protocol->p_setpcl)(mfd, protocol->p_name);
X                            (*protocol->p_renew)(mfd);
X                            break;
X                        case P2_MF_ASKPCL:
X                            pcl_haggle(mfd,PNRQ_ASK);
X                            break;
X                        case P2_MF_CANPCL:
X                            pnrq_cmd = PNRQ_CAN;
X                            break;
X                        case P2_MF_SETPCL:
X                            pnrq_cmd = PNRQ_SET;
X                            break;
X                        case P2_MF_EXIT:
X                            done(0);
X                            break;
X                        }
X                        break;
X                    }
X                }
X                seen_iac = 0;
X            } else if (*cp == P2_IAC)
X                seen_iac++;
X            else {
X                if (seen_meta) {
X                    c = *cp | META;
X                    seen_meta = 0;
X                } else
X                    c = *cp;
X                if (is_option)
X                    is_option = opt_input(c);
X                else
X                    if (curwin.in)
X                        *cq++ = c;
X                if (cq >= obuf+sizeof obuf) {
X                    (void)write(curwin.in->w_datafd,
X                            obuf, cq-obuf);
X                    cq = obuf;
X                }
X            }
X        }
X    }
X    if (cq > obuf)
X        (void)write(curwin.in->w_datafd, obuf, cq-obuf);
X}
!EOF!server/uw_pcl.c!
echo x - server/uw_tty.c
sed -e 's/^X//' > server/uw_tty.c << '!EOF!server/uw_tty.c!'
X/*
X *    uw_tty - terminal support for UW
X *
X * Copyright 1985,1986 by John D. Bruner.  All rights reserved.  Permission to
X * copy this program is given provided that the copy is not sold and that
X * this copyright notice is included.
X */
X
X#include <sys/types.h>
X#include <sys/file.h>
X#include <sys/ioctl.h>
X#include <sys/stat.h>
X
X#include "uw_param.h"
X#include "uw_win.h"
X#include "uw_opt.h"
X
X#define    XON    021    /* ASCII XON (ASR-33 paper-tape reader on) */
X#define    XOFF    023    /* ASCII XOFF (ASR-33 paper-tape reader off) */
X
Xstatic char *envinfo[][3] = {
X    {
X        "TERM=adm31",
X        "TERMCAP=adm31:cr=^M:do=^J:nl=^J:al=\\EE:am:le=^H:bs:ce=\\ET:cm=\\E=%+ %+ :cl=^Z:cd=\\EY:co#80:dc=\\EW:dl=\\ER:ei=\\Er:ho=^^:im=\\Eq:li#24:mi:nd=^L:up=^K:MT:km:so=\\EG1:se=\\EG0:",
X        (char *)0
X    },
X    {
X        "TERM=vt52",
X        (char *)0
X    },
X    {
X        "TERM=ansi",
X        (char *)0
X    },
X    {
X        "TERM=tek4010",
X        (char *)0
X    }
X};
X
X/* private (emulation-specific) data */
Xstruct tty {
X    struct {
X        unsigned short    h,v;
X    }        t_size;
X    unsigned    t_fontsz;
X    unsigned    t_clipb;
X    unsigned    t_bell;
X    unsigned    t_curs;
X    unsigned    t_chgsz;
X};
X
X#define    WOTTY_SIZE    8        /* terminal size in (row, col) */
X#define    WOTTY_FONTSZ    9        /* font size index (0=7pt, 1=9pt) */
X#define    WOTTY_CLIPB    10        /* 0=clipboard, 1=encode mouse clicks */
X#define    WOTTY_BELL    11        /* bell: bit 0=visible, bit 1=audible */
X#define    WOTTY_CURSOR    12        /* cursor type: 0=block, 1=underscore */
X#define    WOTTY_CHGSZ    13        /* change actual size (not view size) */
X
Xstatic woptarg_t size_xdr[] = { WOA_UDATA(12), WOA_UDATA(12), WOA_END };
Xstatic woptarg_t fontsz_xdr[] = { WOA_UDATA(6), WOA_END };
Xstatic woptarg_t clipb_xdr[] = { WOA_UDATA(1), WOA_END };
Xstatic woptarg_t bell_xdr[] = { WOA_UDATA(2), WOA_END };
Xstatic woptarg_t curs_xdr[] = { WOA_UDATA(1), WOA_END };
Xstatic woptarg_t chgsz_xdr[] = { WOA_UDATA(1), WOA_END };
X
X/* TIOCSWINSZ is in 4.3BSD, TIOCSSIZE is in Sun UNIX */
X#if defined(TIOCSWINSZ) || defined(TIOCSSIZE)
X#define    RPTWINSZ    (1<<WOTTY_SIZE)
X#else
X#define    RPTWINSZ    0
X#endif
X
X#define    TTY_WOPT    {                    \
X    0, 0, 0, 0,                        \
X    RPTWINSZ|(1<<WOTTY_FONTSZ)|(1<<WOTTY_CLIPB)|        \
X     (1<<WOTTY_BELL)|(1<<WOTTY_CURSOR)|(1<<WOTTY_CHGSZ),    \
X    {                            \
X        { NULL, NULL, NULL },                \
X        { NULL, NULL, NULL },                \
X        { NULL, NULL, NULL },                \
X        { NULL, NULL, NULL },                \
X        { NULL, NULL, NULL },                \
X        { NULL, NULL, NULL },                \
X        { NULL, NULL, NULL },                \
X        { NULL, NULL, NULL },                \
X        { size_xdr, tty_getopt, tty_setopt },        \
X        { fontsz_xdr, tty_getopt, tty_setopt },        \
X        { clipb_xdr, tty_getopt, tty_setopt },        \
X        { bell_xdr, tty_getopt, tty_setopt },        \
X        { curs_xdr, tty_getopt, tty_setopt },        \
X        { chgsz_xdr, tty_getopt, tty_setopt }        \
X    }                            \
X}
Xextern int tty_start();
Xextern void tty_stop(), tty_setopt(), tty_setext();
Xextern char *tty_getopt();
X
Xstruct emulation adm31_emul = { TTY_WOPT, tty_start, tty_stop, tty_setext };
Xstruct emulation vt52_emul = { TTY_WOPT, tty_start, tty_stop, tty_setext };
Xstruct emulation ansi_emul = { TTY_WOPT, tty_start, tty_stop, tty_setext };
Xstruct emulation tek_emul = { { 0, 0, 0, 0, 0 }, tty_start, tty_stop };
X
Xtty_mode(f)
Xint f;
X{
X    static struct sgttyb ostty, nstty;
X    static struct tchars otchars, ntchars;
X    static struct ltchars oltchars, nltchars;
X    static int olmode, nlmode;
X    static int operm;
X    static saved;
X    static int inout = FREAD|FWRITE;
X    struct stat st;
X
X    /*
X     * This routine either saves the current terminal modes and then
X     * sets up the terminal line or resets the terminal modes (depending
X     * upon the value of "f").  The terminal line is used in "cbreak"
X     * mode with all special characters except XON/XOFF disabled.  The
X     * hated (by me) LDECCTQ mode is required for the Macintosh to
X     * handle flow control properly.
X     */
X    if (f == 1) {
X        if (fstat(0, &st) == 0)
X            operm = st.st_mode & 06777;
X        else
X            operm = -1;
X        if (ioctl(0, (int)TIOCGETP, (char *)&ostty) < 0) {
X            perror("ioctl((int)TIOCGETP)");
X            done(1);
X        }
X        if (ioctl(0, (int)TIOCGETC, (char *)&otchars) < 0) {
X            perror("ioctl((int)TIOCGETC)");
X            done(1);
X        }
X        if (ioctl(0, (int)TIOCGLTC, (char *)&oltchars) < 0) {
X            perror("ioctl((int)TIOCGLTC)");
X            done(1);
X        }
X        if (ioctl(0, (int)TIOCLGET, (char *)&olmode) < 0) {
X            perror("ioctl((int)TIOCLGET)");
X            done(1);
X        }
X        nstty = ostty;
X        nstty.sg_erase = nstty.sg_kill = -1;
X        nstty.sg_flags |= CBREAK;
X        nstty.sg_flags &= ~(RAW|CRMOD|ECHO|LCASE|XTABS|ALLDELAY);
X        ntchars.t_intrc = ntchars.t_quitc = -1;
X        ntchars.t_eofc = ntchars.t_brkc = -1;
X        ntchars.t_startc = XON;
X        ntchars.t_stopc = XOFF;
X        nltchars.t_suspc = nltchars.t_dsuspc = -1;
X        nltchars.t_rprntc = nltchars.t_flushc = -1;
X        nltchars.t_werasc = nltchars.t_lnextc = -1;
X        nlmode = olmode | LDECCTQ;
X        if (operm != -1 && fchmod(0, S_IREAD|S_IWRITE) < 0)
X            operm = -1;
X        if (ioctl(0, (int)TIOCSETN, (char *)&nstty) < 0) {
X            perror("ioctl((int)TIOCSETN)");
X            done(1);
X        }
X        if (ioctl(0, (int)TIOCSETC, (char *)&ntchars) < 0) {
X            perror("ioctl((int)TIOCSETC");
X            done(1);
X        }
X        if (ioctl(0, (int)TIOCSLTC, (char *)&nltchars) < 0) {
X            perror("ioctl((int)TIOCSLTC");
X            done(1);
X        }
X        if (ioctl(0, (int)TIOCLSET, (char *)&nlmode) < 0) {
X            perror("ioctl((int)TIOCLSET)");
X            done(1);
X        }
X        saved = 1;
X    } else if (saved) {
X        (void)ioctl(0, (int)TIOCFLUSH, (char *)&inout);
X        (void)ioctl(0, (int)TIOCSETP, (char *)&ostty);
X        (void)ioctl(0, (int)TIOCSETC, (char *)&otchars);
X        (void)ioctl(0, (int)TIOCSLTC, (char *)&oltchars);
X        (void)ioctl(0, (int)TIOCLSET, (char *)&olmode);
X        if (operm != -1)
X            (void)fchmod(0, operm);
X    }
X}
X
Xstatic
Xtty_start(w)
Xregister struct window *w;
X{
X    register struct tty *t;
X    extern char *malloc();
X
X    /*
X     * Start up a terminal emulation.  Establish reasonable defaults
X     * for the terminal-specific window options.
X     */
X    if (w->w_type != WT_TEK4010) {
X        if ((w->w_private = malloc(sizeof(struct tty))) != NULL) {
X            t = (struct tty *)w->w_private;
X            t->t_size.h = 80;
X            t->t_size.v = 24;
X            t->t_fontsz = 0;
X            t->t_clipb = 0;
X            t->t_bell = 3;
X            t->t_curs = 0;
X            t->t_chgsz = 0;
X            return(1);
X        } else
X            return(0);
X    } else {
X        w->w_private = (char *)0;
X        return(1);
X    }
X}
X
Xstatic
Xvoid
Xtty_stop(w)
Xregister struct window *w;
X{
X    /*
X     * Shut down (stop) a terminal emulation.
X     */
X    free(w->w_private);
X    w->w_private = (char *)0;
X}
X
Xstatic
Xvoid
Xtty_setext(wod)
Xregister struct woptdefn *wod;
X{
X    /*
X     * This routine makes adjustments to the window option definitions
X     * for external windows.  Basically, we turn off reporting for
X     * WOTTY_SIZE.  (If the external process wants to handle this, it
X     * can turn it back on.)
X     */
X    WOPT_CLR(wod->wod_do, WOTTY_SIZE);
X    WOPT_CLR(wod->wod_askrpt, WOTTY_SIZE);
X}
X
Xtty_envinit(wtype)
Xregister wtype_t wtype;
X{
X    /*
X     * Set up environment variables corresponding to the window type
X     * "wtype".
X     */
X    env_set(envinfo[wtype]);
X}
X
Xstatic
Xchar *
Xtty_getopt(win, num)
Xcaddr_t win;
Xwoption_t num;
X{
X    register struct tty *t;
X    static union optvalue ov;
X    struct window *w;
X
X    if ((w=(struct window *)win) != NULL && w->w_alloc &&
X        (t=(struct tty *)w->w_private) != NULL) {
X        switch (num) {
X        case WOTTY_SIZE:
X            ov.ov_point.h = t->t_size.h;
X            ov.ov_point.v = t->t_size.v;
X            break;
X        case WOTTY_FONTSZ:
X            ov.ov_udata6 = t->t_fontsz;
X            break;
X        case WOTTY_CLIPB:
X            ov.ov_udata1 = t->t_clipb;
X            break;
X        case WOTTY_BELL:
X            ov.ov_udata2 = t->t_bell;
X            break;
X        case WOTTY_CURSOR:
X            ov.ov_udata1 = t->t_curs;
X            break;
X        case WOTTY_CHGSZ:
X            ov.ov_udata1 = t->t_chgsz;
X            break;
X        }
X    }
X    return((char *)&ov);
X}
X
Xstatic
Xvoid
Xtty_setopt(win, num, value)
Xcaddr_t win;
Xwoption_t num;
Xchar *value;
X{
X    register struct tty *t;
X    register union optvalue *ovp;
X    register struct window *w;
X
X    if ((w=(struct window *)win) != NULL && w->w_alloc &&
X        (t=(struct tty *)w->w_private) != NULL &&
X        (ovp = (union optvalue *)value) != NULL) {
X        switch (num) {
X        case WOTTY_SIZE:
X            t->t_size.h = ovp->ov_point.h;
X            t->t_size.v = ovp->ov_point.v;
X#ifdef TIOCSWINSZ
X            if (w->w_class == WC_INTERNAL) {
X                /* set window size on pty (4.3BSD) */
X                struct winsize ws;
X                ws.ws_row = t->t_size.v;
X                ws.ws_col = t->t_size.h;
X                ws.ws_xpixel = w->w_size.h;
X                ws.ws_ypixel = w->w_size.v;
X                (void)ioctl(w->w_datafd, (int)TIOCSWINSZ,
X                    (char *)&ws);
X            }
X#else
X#ifdef TIOCSSIZE
X            if (w->w_class == WC_INTERNAL) {
X                /* set window size on pty (Sun) */
X                struct ttysize ts;
X                ts.ts_lines = t->t_size.v;
X                ts.ts_cols = t->t_size.h;
X                (void)ioctl(w->w_datafd, (int)TIOCSSIZE,
X                    (char *)&ts);
X            }
X#endif
X#endif
X            break;
X        case WOTTY_FONTSZ:
X            t->t_fontsz = ovp->ov_udata6;
X            break;
X        case WOTTY_CLIPB:
X            t->t_clipb = ovp->ov_udata1;
X            break;
X        case WOTTY_BELL:
X            t->t_bell = ovp->ov_udata2;
X            break;
X        case WOTTY_CURSOR:
X            t->t_curs = ovp->ov_udata1;
X            break;
X        case WOTTY_CHGSZ:
X            t->t_chgsz = ovp->ov_udata1;
X            break;
X        }
X    }
X}
!EOF!server/uw_tty.c!
exit 0
: end of shell archive