Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume42/ecu/part08

Internet Message Format | 1994-05-23 | 64.5 KB

From: [e-mail] (Warren Tucker)
Newsgroups: comp.sources.misc
Subject: v42i106:  ecu - ECU Asynchronous Communications v3.30, Part08/37
Date: 23 May 1994 14:22:39 -0500
Organization: Sterling Software
Sender: [e-mail]
Approved: [e-mail]
Message-ID: <2rqvpv$[e-mail]>
X-Md4-Signature: f5fe7d980b50fd39c9b672a7a41112cf

Submitted-by: [e-mail] (Warren Tucker)
Posting-number: Volume 42, Issue 106
Archive-name: ecu/part08
Environment: SCO,SCOXENIX,MOTOROLA,HP-UX,LINUX,NetBSD,SUNOS,SYSVR4,SOLARIS2
Supersedes: ecu: Volume 32, Issue 36-75

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# Contents:  ecu330/ecurcvr.c ecu330/ecusighdl.c
# Wrapped by kent@sparky on Mon May 23 13:40:48 1994
PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
echo If this archive is complete, you will see the following message:
echo '          "shar: End of archive 8 (of 37)."'
if test -f 'ecu330/ecurcvr.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'ecu330/ecurcvr.c'\"
else
  echo shar: Extracting \"'ecu330/ecurcvr.c'\" \(42110 characters\)
  sed "s/^X//" >'ecu330/ecurcvr.c' <<'END_OF_FILE'
X/* #define DEFENSIVE */
X /* #define ANSI_DEBUG *//* debug ansi */
X /* #define ANSI_DEBUG_2 *//* debug ansi intensive output */
X /* #define ANSI_DEBUG_3 *//* debug ansi selected output */
X /* #define ANSI_DEBUG_NOBUF *//* unbufferred logging */
X/* #define ANSI_DEBUG_LOGFILE    "/dev/tty2h" */
X/* #define CURSOR_DEBUG */
X
X#ifndef LIMIT_BELL
X#define LIMIT_BELL
X#endif
X
X#if defined(WHT) && defined(WHT_CONFUSED)
X#define ANSI_DEBUG
X#define ANSI_DEBUG_2
X#define ANSI_DEBUG_3
X#define ANSI_DEBUG_NOBUF
X#define ANSI_DEBUG_LOGFILE    "./ansi.log"
X#endif
X
X/*+-------------------------------------------------------------------------
X    ecurcvr.c - rcvr process + ANSI filter + non-ANSI<->ANSI hoop jumping
X    [e-mail]
X
X  Defined functions:
X    accumulate_ansi_sequence(rchar)
X    ansi_CNL()
X    ansi_CPL()
X    ansi_CUB()
X    ansi_CUD()
X    ansi_CUF()
X    ansi_CUP()
X    ansi_CUU()
X    ansi_DCH()
X    ansi_DL()
X    ansi_DSR()
X    ansi_ECH()
X    ansi_ED()
X    ansi_EL()
X    ansi_HPA()
X    ansi_ICH()
X    ansi_IL()
X    ansi_SD()
X    ansi_SGR()
X    ansi_SU()
X    ansi_VPA()
X    is_ansi_terminator(rchar)
X    lgetc_rcvr()
X    process_ansi_sequence()
X    process_rcvd_char(rchar)
X    rcvd_ESC()
X    rcvr()
X    rcvr_log_open()
X    rcvrdisp(buf,buflen)
X    rcvrdisp_actual()
X    rcvrdisp_actual2()
X    redisplay_rcvr_screen()
X    saved_cursor_restore_cursor()
X    saved_cursor_save_cursor()
X    spaces(buf,buflen)
X    spaces_trap(code,buf,buflen)
X
X    Any perceptible delay will eventually get on your nerves. --Bob Hyers
X
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:05-04-1994-04:39-wht@n4hgf-ECU release 3.30 */
X/*:10-03-1993-20:09-wht@n4hgf-document read errors w/fd on screen */
X/*:08-18-1993-05:49-wht@n4hgf-rcvr seems ready for release */
X/*:08-07-1993-20:38-wht@n4hgf-add xmtr_wfp_debug_hack */
X/*:07-23-1993-15:42-wht@n4hgf-detect/ignore ESC = or ESC > VT100 keypad */
X/*:07-17-1993-12:36-wht@n4hgf-no more rcvrdisp_actual2_xmtr_buffer junk */
X/*:12-31-1992-15:34-wht@n4hgf-handle VT100 save/restore cursor */
X/*:12-03-1992-14:24-wht@n4hgf-differentiate between type 5 and other DSR */
X/*:09-10-1992-13:58-wht@n4hgf-ECU release 3.20 */
X/*:09-06-1992-13:29-wht@n4hgf-add receiver process buffered screen write */
X/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
X/*:05-29-1992-13:28-wht@n4hgf-no banner - phone numbers are security risk */
X/*:11-11-1991-14:25-wht@n4hgf-lzero_length_read_detected code */
X/*:11-11-1991-12:45-wht@n4hgf-add LIMIT_BELL code */
X/*:08-26-1991-16:39-wht@n4hgf2-SD was still hopelessly manic */
X/*:07-25-1991-12:56-wht@n4hgf-ECU release 3.10 */
X/*:07-05-1991-06:13-wht@n4hgf-SD was in baaaaadd shape */
X/*:01-09-1991-22:31-wht@n4hgf-ISC port */
X/*:12-26-1990-14:32-wht@n4hgf-use memset in spaces() */
X/*:12-21-1990-21:06-wht@n4hgf-CUF and CUB set non-ansi cursor incorrectly */
X/*:12-20-1990-16:27-wht@n4hgf-had SU and SD swapped */
X/*:11-30-1990-18:39-wht@n4hgf-non-ansi console rcvr appears to be working */
X/*:11-28-1990-14:13-wht@n4hgf-start non-ansi console support */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#include "ecu.h"
X#include "ecukey.h"
X
X#ifdef CFG_SemWithShm
X#include <sys/ipc.h>
X#include <sys/sem.h>
X#endif /* CVRDISP_PV */
X
Xextern int errno;
Xextern char rcvr_log_file[]; /* if rcvr_log!= 0,log filename */
Xextern int rcvr_log;         /* rcvr log active if != 0 */
Xextern FILE *rcvr_log_fp;     /* rcvr log file */
Xextern int rcvr_log_raw;     /* if true, log all, else filter ctl chrs */
Xextern int rcvr_log_append;     /* if true, append, else scratch */
Xextern int rcvr_log_flusheach;    /* if true, flush log on each char */
Xextern int rcvr_log_gen_title;
X
Xextern uint tcap_LINES;         /* terminal line quantity - see ecutcap.c */
Xextern uint tcap_COLS;         /* terminal column quantity - see ecutcap.c */
Xextern uint LINESxCOLS;
X
Xstatic char esc = ESC;
X
X#define MAX_ANSI_LEN    30     /* generous */
Xchar ansibuf[MAX_ANSI_LEN];
Xchar *ansi;
Xint ansilen = 0;
Xint in_ansi_accumulation = 0;
X
Xint saved_cursor_y;
Xint saved_cursor_x;
X
X#define RCVR_RDQUAN        250
Xchar lgetc_buf[RCVR_RDQUAN];
Xchar *lgetc_ptr;
Xextern int lgetc_count;
X
Xuchar autorz_frame[] =
X{SUB, 'B', '0', '0'};
X
X#ifdef ANSI_DEBUG
XFILE *wfp = (FILE *) 0;
X
X#endif
X
Xuchar non_multiscreen_hi_map[128] =
X{
X    /* 80 */ 'c', 'u', 'e', 'a', 'a', 'a', 'a', 'c',    /* the main purpose of
X                                                         * this ... */
X    /* 88 */ 'e', 'e', 'e', 'i', 'i', 'i', 'a', 'a',    /* ... is to map ruling
X                                                         * ... */
X    /* 90 */ 'e', 'e', 'a', 'a', 'a', 'o', 'u', 'u',    /* ... characters, but
X                                                         * as ... */
X    /* 98 */ 'y', 'o', 'u', 'X', '#', 'Y', 'P', 'f',    /* ... a side effect,
X                                                         * also map ... */
X    /* A0 */ 'a', 'i', 'o', 'u', 'n', 'n', 'a', 'o',    /* ... others to
X                                                         * reasonable, ... */
X    /* A8 */ '?', '-', '-', '%', '%', '|', '<', '>',    /* ... near, amusing, or
X                                                         * random ... */
X    /* B0 */ '#', '#', '#', '|', '+', '+', '+', '.',    /* ... printing
X                                                         * characters as well */
X    /* B8 */ '.', '+', '|', '.', '\'', '\'', '\'', '.',
X    /* C0 */ '`', '+', '+', '+', '-', '+', '+', '+',
X    /* C8 */ '`', '.', '+', '+', '+', '=', '+', '+',
X    /* D0 */ '+', '+', '+', '`', '`', '.', '.', '+',
X    /* D8 */ '+', '\'', '.', '#', '_', '|', '|', '-',
X    /* E0 */ 'a', 'b', 'F', 'T', 'E', 'o', 'u', 't',
X    /* E8 */ 'I', '0', 'O', 'o', 'o', 'o', 'e', 'n',
X    /* F0 */ '=', '+', '>', '<', 'f', 'j', '%', '=',
X    /* F8 */ 'o', '.', '.', 'V', 'n', '2', '*', ' '
X};
X
X/*+-------------------------------------------------------------------------
X    rcvrdisp_p() - lock rcvrdisp mechanism
X--------------------------------------------------------------------------*/
X#ifdef CFG_SemWithShm
Xvoid
Xrcvrdisp_p()
X{
X    register int retn;
X    struct sembuf sembuf;
X
X    sembuf.sem_num = 0;
X    sembuf.sem_op = -1;
X    sembuf.sem_flg = 0;
X
X    while (1)
X    {
X        if (((retn = semop(shm->rcvrdisp_semid, &sembuf, 1)) >= 0) ||
X            (errno != EINTR))
X        {
X            break;
X        }
X    }
X
X    if ((retn < 0) && (errno != EINVAL))
X    {
X        strcpy(lopen_err_str, "rcvrdisp_p failed: SysV IPC error");
X        termecu(TERMECU_IPC_ERROR);
X    }
X
X}                             /* end of rcvrdisp_p */
X#endif /* CFG_SemWithShm */
X
X/*+-------------------------------------------------------------------------
X    rcvrdisp_v() - unlock rcvrdisp mechanism
X--------------------------------------------------------------------------*/
X#ifdef CFG_SemWithShm
Xvoid
Xrcvrdisp_v()
X{
X    register int retn;
X    struct sembuf sembuf;
X
X    sembuf.sem_num = 0;
X    sembuf.sem_op = 1;
X    sembuf.sem_flg = 0;
X
X    while (1)
X    {
X        if (((retn = semop(shm->rcvrdisp_semid, &sembuf, 1)) >= 0) ||
X            (errno != EINTR))
X        {
X            break;
X        }
X    }
X
X    if ((retn < 0) && (errno != EINVAL))
X    {
X        strcpy(lopen_err_str, "rcvrdisp_v failed: SysV IPC error");
X        termecu(TERMECU_IPC_ERROR);
X    }
X}                             /* end of rcvrdisp_v */
X#endif /* CFG_SemWithShm */
X
X/*+-------------------------------------------------------------------------
X    rcvrdisp_actual() - actual write to screen
X--------------------------------------------------------------------------*/
Xvoid
Xrcvrdisp_actual()
X{
X#ifdef CFG_SemWithShm
X    rcvrdisp_p();
X#endif /* CFG_SemWithShm */
X    if (shm->rcvrdisp_count)
X        write(TTYOUT, shm->rcvrdisp_buffer, shm->rcvrdisp_count);
X    shm->rcvrdisp_ptr = shm->rcvrdisp_buffer;
X    shm->rcvrdisp_count = 0;
X#ifdef CFG_SemWithShm
X    rcvrdisp_v();
X#endif /* CFG_SemWithShm */
X
X}                             /* end of rcvrdisp_actual */
X
X/*+-------------------------------------------------------------------------
X    rcvrdisp_actual2() - for tcap, flush only if not receiver
X--------------------------------------------------------------------------*/
Xvoid
Xrcvrdisp_actual2()
X{
X    if (getpid() == rcvr_pid)
X        return;
X#ifdef CFG_SemWithShm
X    rcvrdisp_p();
X#endif /* CFG_SemWithShm */
X    if (shm->rcvrdisp_count)
X        write(TTYOUT, shm->rcvrdisp_buffer, shm->rcvrdisp_count);
X    shm->rcvrdisp_ptr = shm->rcvrdisp_buffer;
X    shm->rcvrdisp_count = 0;
X#ifdef CFG_SemWithShm
X    rcvrdisp_v();
X#endif /* CFG_SemWithShm */
X
X}                             /* end of rcvrdisp_actual2 */
X
X/*+-------------------------------------------------------------------------
X    rcvrdisp(buf,buflen) - logical write to screen
X--------------------------------------------------------------------------*/
Xvoid
Xrcvrdisp(buf, buflen)
Xchar *buf;
Xint buflen;
X{
X
X    if ((buflen + shm->rcvrdisp_count) > sizeof(shm->rcvrdisp_buffer))
X        rcvrdisp_actual();
X    if ((buflen + shm->rcvrdisp_count) > sizeof(shm->rcvrdisp_buffer))
X    {
X        write(TTYOUT, buf, buflen);
X        return;
X    }
X#ifdef CFG_SemWithShm
X    rcvrdisp_p();
X#endif /* CFG_SemWithShm */
X    memcpy(shm->rcvrdisp_ptr, buf, buflen);
X    shm->rcvrdisp_ptr += buflen;
X    shm->rcvrdisp_count += buflen;
X#ifdef CFG_SemWithShm
X    rcvrdisp_v();
X#endif /* CFG_SemWithShm */
X
X}                             /* end of rcvrdisp */
X
X/*+-------------------------------------------------------------------------
X    redisplay_rcvr_screen() - redisplay logical receiver screen
XAs of writing, this function is called only by the XMTR process
X--------------------------------------------------------------------------*/
Xvoid
Xredisplay_rcvr_screen()
X{
X    register uint y;
X    extern int tty_not_char_special;
X
X    if (tty_not_char_special)
X        return;
X
X    setcolor(colors_current);
X    tcap_stand_end();
X    for (y = 0; y < tcap_LINES; y++)
X    {
X        tcap_cursor(y, 0);
X        fwrite(&shm->screen[y][0],
X            ((y != tcap_LINES - 1) ? tcap_COLS : tcap_COLS - 1), 1, se);
X    }
X    tcap_eeol();
X    tcap_cursor(shm->cursor_y, shm->cursor_x);
X
X}                             /* end of redisplay_rcvr_screen */
X
X/*+-------------------------------------------------------------------------
X    spaces_trap(code,buf,buflen)
X--------------------------------------------------------------------------*/
X#ifdef DEBUG_CURSOR
Xvoid
Xspaces_trap(code, buf, buflen)
Xint code;
Xregister uchar *buf;
Xregister uint buflen;
X{
X    char *xyz = (char *)0x90000000;
X
X    ff(se, "rcvr 'spaces trap' code %d: cursor x,y=%d,%d\r\n",
X        code, shm->cursor_y, shm->cursor_x);
X    ff(se, "buf=%08lx len=%08lx offs=%08lx\r\n", buf, buflen,
X        (ulong) buf - (ulong) shm->screen);
X    *xyz = 0;
X    abort();
X}                             /* end of spaces_trap */
X#endif
X
X/*+-------------------------------------------------------------------------
X    spaces(buf,buflen) - fill with spaces
X--------------------------------------------------------------------------*/
Xvoid
Xspaces(buf, buflen)
Xregister uchar *buf;
Xuint buflen;
X{
X#ifdef DEBUG_CURSOR
X    if ((ulong) buf > (((ulong) shm->screen) + LINESxCOLS))
X        spaces_trap(1, buf, buflen);
X    if ((ulong) buf < (ulong) shm->screen)
X        spaces_trap(2, buf, buflen);
X    if ((ulong) (buf + buflen) > (((ulong) shm->screen) + LINESxCOLS))
X        spaces_trap(3, buf, buflen);
X    if ((ulong) (buf + buflen) < (ulong) shm->screen)
X        spaces_trap(4, buf, buflen);
X#endif
X
X    if (!buflen)
X        return;
X
X#ifdef DEFENSIVE
X    if ((ulong) buf < (ulong) shm->screen)
X        return;
X    if ((ulong) (buf + buflen) > (((ulong) shm->screen) + LINESxCOLS))
X        return;
X#endif
X
X    memset(buf, SPACE, buflen);
X
X}                             /* end of spaces */
X
X/*+-------------------------------------------------------------------------
X    lgetc_rcvr() - rcvr version of get char from line
X--------------------------------------------------------------------------*/
Xint
Xlgetc_rcvr()
X{
X    extern int errno;
X
X    if (!lgetc_count)
X    {
X        rcvrdisp_actual();
X        while (lgetc_count <= 0)
X        {
X            errno = 0;
X            if ((lgetc_count =
X                    read(shm->Liofd, lgetc_buf, RCVR_RDQUAN)) < 0)
X            {
X                if (errno == EINTR)    /* if signal interrupted, ... */
X                    continue;/* ... read again */
X                ff(se, "lgetc read error fd=%d\r\n", shm->Liofd);
X                termecu(TERMECU_LINE_READ_ERROR);
X            }
X            if (!lgetc_count)
X            {
X                lzero_length_read_detected();    /* maybe terminate program
X                                                 * ... */
X                continue;     /* ... but if not, read again */
X            }
X        }
X        shm->rcvd_chars += lgetc_count;
X        shm->rcvd_chars_this_connect += lgetc_count;
X        lgetc_ptr = lgetc_buf;
X    }
X
X    lgetc_count--;
X
X    if (shm->Lparity)
X        return (*lgetc_ptr++ & 0x7F);
X    else
X        return (*lgetc_ptr++);
X
X}                             /* end of lgetc_rcvr */
X
X/*+-------------------------------------------------------------------------
X    ansi_SGR() - Set Graphics Rendition
X
XThe DOS ANSI world expects to be able to be able to chain 0,1 and
X3x,4x params together with semicolons.
X
X  Supported modifiers for non-ansi terminals
X  0       normal
X  1       bold
X  4       underscore
X  5       blink
X  7       reverse video
X--------------------------------------------------------------------------*/
Xvoid
Xansi_SGR()
X{
X    register itmp;
X    register char *cptr;
X    char SGRstr[MAX_ANSI_LEN];
X    char *token;
X    char *str_token();
X
X    if (!tty_is_multiscreen)
X    {
X        ansibuf[ansilen - 1] = 0;    /* get rid of 'm' */
X        cptr = ansibuf + 1;     /* get rid of '[' */
X        if (!strlen(cptr))
X            goto SGR_0;
X        while (token = str_token(cptr, ";"))
X        {
X            cptr = (char *)0;/* further calls to str_token need NULL */
X            switch (atoi(token))
X            {
X                default:
X                case 0:     /* normal */
X                  SGR_0:
X                    tcap_stand_end();
X                    tcap_blink_off();
X                    tcap_underscore_off();
X                    tcap_bold_off();
X                    break;
X                case 1:     /* bold */
X                    tcap_bold_on();
X                    break;
X                case 4:     /* underscore */
X                    tcap_underscore_on();
X                    break;
X                case 5:     /* blink */
X                    tcap_blink_on();
X                    break;
X                case 7:     /* reverse video */
X                    tcap_stand_out();
X                    break;
X            }
X        }
X        return;
X    }
X
X    if (ansilen <= 3)         /* 'ESC[<0-9>m' and 'ESC[m' - quickly handled */
X    {
X        rcvrdisp(&esc, 1);
X        rcvrdisp(ansibuf, ansilen);
X        return;
X    }
X
X/* check XENIX 'ESC[<2,3,7>m' extensions */
X    switch (itmp = atoi(ansibuf + 1))
X    {
X        case 7:             /* XENIX 'ESC[7;<0-15>;<0-15>m' set
X                              * fore/background color */
X            itmp = atoi(ansibuf + 3);    /* second parameter */
X            if (itmp > 15)     /* not XENIX extension */
X                break;
X            /* fall through */
X        case 2:             /* XENIX 'ESC[2;<0-15>;<0-15>m' set
X                              * fore/background color */
X        case 3:             /* XENIX 'ESC[3;<0-1>m' color only set/clear
X                              * blink */
X            rcvrdisp(&esc, 1);
X            rcvrdisp(ansibuf, ansilen);
X            return;
X        default:
X            break;
X    }
X
X/* not XENIX extension */
X    ansibuf[ansilen - 1] = 0;/* get rid of 'm' */
X    cptr = ansibuf + 1;         /* get rid of '[' */
X
X    while (token = str_token(cptr, ";"))
X    {
X        cptr = (char *)0;     /* further calls to str_token need NULL */
X        sprintf(SGRstr, "\033[%sm", token);
X        rcvrdisp(SGRstr, strlen(SGRstr));
X    }
X
X}                             /* end of ansi_SGR */
X
X/*+-------------------------------------------------------------------------
X    ansi_CUP() - cursor position (also HVP horiz/vertical position)
X--------------------------------------------------------------------------*/
Xvoid
Xansi_CUP()
X{
X    register uint param_count = 0;
X    char ansicopy[MAX_ANSI_LEN];
X    register char *cptr = ansicopy;
X    register char *token;
X    char *str_token();
X
X    strcpy(cptr, ansibuf + 1);
X    *(cptr + ansilen - 2) = 0;
X
X    while (token = str_token(cptr, ";"))
X    {
X        cptr = (char *)0;     /* further calls to str_token need NULL */
X        switch (++param_count)
X        {
X            case 1:
X                shm->cursor_y = atoi(token) - 1;
X                break;
X            case 2:
X                shm->cursor_x = atoi(token) - 1;
X                break;
X        }
X    }
X    switch (param_count)
X    {
X        case 0:
X            shm->cursor_y = 0;
X        case 1:
X            shm->cursor_x = 0;
X    }
X    if (shm->cursor_x >= tcap_COLS)
X        shm->cursor_x = tcap_COLS - 1;
X    if (shm->cursor_y >= tcap_LINES)
X        shm->cursor_y = tcap_LINES - 1;
X
X    if (!tty_is_multiscreen)
X        tcap_cursor(shm->cursor_y, shm->cursor_x);
X
X}                             /* end of ansi_CUP */
X
X/*+-------------------------------------------------------------------------
X    ansi_CUU() - cursor up
X--------------------------------------------------------------------------*/
Xvoid
Xansi_CUU()
X{
X    register uint count;
X    register uint y;
X
X    if (ansilen == 2)         /* no param */
X        count = 1;
X    else
X        count = atoi(ansibuf + 1);
X
X    y = shm->cursor_y - count;
X    if (y >= tcap_LINES)     /* unsigned comparison */
X        y = 0;
X
X    if (y != shm->cursor_y)
X    {
X        shm->cursor_y = y;
X        if (!tty_is_multiscreen)
X            tcap_cursor(shm->cursor_y, shm->cursor_x);
X    }
X
X}                             /* end of ansi_CUU */
X
X/*+-------------------------------------------------------------------------
X    ansi_CUD() - cursor down (also VPR vertical position relative)
X--------------------------------------------------------------------------*/
Xvoid
Xansi_CUD()
X{
X    register uint count;
X    register uint y;
X
X    if (ansilen == 2)         /* no param */
X        count = 1;
X    else
X        count = atoi(ansibuf + 1);
X
X    y = shm->cursor_y + count;
X    if (y >= tcap_LINES)
X        y = tcap_LINES - 1;
X
X    if (y != shm->cursor_y)
X    {
X        shm->cursor_y = y;
X        if (!tty_is_multiscreen)
X            tcap_cursor(shm->cursor_y, shm->cursor_x);
X    }
X
X}                             /* end of ansi_CUD */
X
X/*+-------------------------------------------------------------------------
X    ansi_CUF() - cursor forward (also HPR horizontal position relative)
X--------------------------------------------------------------------------*/
Xvoid
Xansi_CUF()
X{
X    register uint count;
X    register uint x;
X
X    if (ansilen == 2)         /* no param */
X        count = 1;
X    else
X        count = atoi(ansibuf + 1);
X
X    x = shm->cursor_x + count;
X    if (x >= tcap_COLS)
X        x = tcap_COLS - 1;
X
X    if (x != shm->cursor_x)
X    {
X        shm->cursor_x = x;
X        if (!tty_is_multiscreen)
X            tcap_cursor(shm->cursor_y, shm->cursor_x);
X    }
X
X}                             /* end of ansi_CUF */
X
X/*+-------------------------------------------------------------------------
X    ansi_CUB() - cursor forward
X--------------------------------------------------------------------------*/
Xvoid
Xansi_CUB()
X{
X    register uint count;
X    register uint x;
X
X    if (ansilen == 2)         /* no param */
X        count = 1;
X    else
X        count = atoi(ansibuf + 1);
X
X    x = shm->cursor_x - count;
X    if (x >= tcap_COLS)         /* unsigned comparison */
X        x = 0;
X
X    if (x != shm->cursor_x)
X    {
X        shm->cursor_x = x;
X        if (!tty_is_multiscreen)
X            tcap_cursor(shm->cursor_y, shm->cursor_x);
X    }
X
X}                             /* end of ansi_CUB */
X
X/*+-------------------------------------------------------------------------
X    ansi_DSR() - device status report
X
X  ESC [ Ps n  - Device Status Report (DSR)           ECU Response
X        Ps = 5 -> Status Report                      ESC [ 0 n
X        Ps = 6 -> Report Cursor Position (CPR)       ESC [ r ; c R
X
X--------------------------------------------------------------------------*/
Xvoid
Xansi_DSR()
X{
X    register uint param;
X    char response_buf[MAX_ANSI_LEN];
X    char *response = 0;
X
X    if (ansilen < 2)         /* no param */
X        param = 0;
X    else
X        param = atoi(ansibuf + 1);
X
X#ifdef ANSI_DEBUG_3
X    if (wfp)
X    {
X        ff(wfp, "DSR: param=%u y,x=%d,%d", param,
X            shm->cursor_y, shm->cursor_x);
X        if (!param && (ansilen == 3))
X            ff(wfp, ": ignoring \"ESC 0 ] n\"");
X        ff(wfp, "\n");
X    }
X#endif
X
X    switch (param)
X    {
X        case 0:             /* sanity */
X        case 5:             /* sanity */
X            response = "\033[0n";
X            break;
X
X        case 6:             /* report cursor position */
X            sprintf(response_buf, "\033[%d;%dR",
X                shm->cursor_y + 1, shm->cursor_x + 1);
X            response = response_buf;
X            break;
X    }
X
X    if (response)
X    {
X        Nap(300L);
X        write(shm->Liofd, response, strlen(response));
X    }
X
X#ifdef ANSI_DEBUG_3
X    if (response)
X    {
X        char s80[80];
X
X        sprintf(s80, "strlen(DSR response) = %d", strlen(response));
X        hex_dump_fp(wfp, response, strlen(response), s80, 0);
X    }
X#endif
X
X}                             /* end of ansi_DSR */
X
X/*+-------------------------------------------------------------------------
X    ansi_ED() - erase in display
X--------------------------------------------------------------------------*/
Xvoid
Xansi_ED()
X{
X    register uint param;
X    int y;
X
X    if (ansilen == 2)         /* no param */
X        param = 0;
X    else
X        param = atoi(ansibuf + 1);
X
X    switch (param)
X    {
X        case 0:             /* erase to end of display */
X            spaces(&shm->screen[shm->cursor_y][shm->cursor_x],
X                LINESxCOLS - ((shm->cursor_y * tcap_COLS) + shm->cursor_x));
X            if (!tty_is_multiscreen)
X                tcap_eeod();
X            break;
X        case 1:             /* erase from beginning of display */
X            spaces((char *)shm->screen, (shm->cursor_y * tcap_COLS) +
X                shm->cursor_x);
X            if (!tty_is_multiscreen)
X            {
X                for (y = 0; y < shm->cursor_y - 1; y++)
X                {
X                    tcap_cursor(y, 0);
X                    tcap_eeol();
X                }
X                if (shm->cursor_x)
X                {
X                    tcap_cursor(shm->cursor_y, 0);
X                    tcap_clear_area_char(shm->cursor_x, ' ');
X                }
X                else
X                    tcap_cursor(shm->cursor_y, shm->cursor_x);
X            }
X            break;
X        case 2:             /* clear display */
X            shm->cursor_y = 0;
X            shm->cursor_x = 0;
X            spaces((char *)shm->screen, LINESxCOLS);
X            if (!tty_is_multiscreen)
X            {
X                tcap_clear_screen();
X                tcap_cursor(shm->cursor_y, shm->cursor_x);
X            }
X            break;
X    }
X
X}                             /* end of ansi_ED */
X
X/*+-------------------------------------------------------------------------
X    ansi_EL() - erase in line
X--------------------------------------------------------------------------*/
Xvoid
Xansi_EL()
X{
X    register uint param;
X    char cr = CRET;
X
X    if (ansilen == 2)         /* no param */
X        param = 0;
X    else
X        param = atoi(ansibuf + 1);
X
X    switch (param)
X    {
X        case 2:             /* clear line */
X            shm->cursor_x = 0;
X            if (!tty_is_multiscreen)
X                rcvrdisp(&cr, 1);
X            /* fall thru */
X        case 0:             /* erase to end of line */
X            spaces(&shm->screen[shm->cursor_y][shm->cursor_x],
X                tcap_COLS - shm->cursor_x);
X            if (!tty_is_multiscreen)
X                tcap_eeol();
X            break;
X        case 1:             /* erase from beginning of line */
X            spaces(&shm->screen[shm->cursor_y][0], shm->cursor_x);
X            if (!tty_is_multiscreen && shm->cursor_x)
X            {
X                rcvrdisp(&cr, 1);
X                tcap_clear_area_char(shm->cursor_x, ' ');
X            }
X            break;
X    }
X
X}                             /* end of ansi_EL */
X
X/*+-------------------------------------------------------------------------
X    ansi_ECH() - erase characters
X--------------------------------------------------------------------------*/
Xvoid
Xansi_ECH()
X{
X    register uint param;
X    register uint screen_pos;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if ((shm->cursor_x + param) >= tcap_COLS)
X        return;
X
X    screen_pos = (shm->cursor_y * tcap_COLS) + shm->cursor_x;
X    mem_cpy((char *)shm->screen + screen_pos,
X        (char *)shm->screen + screen_pos + param, param);
X    spaces((char *)shm->screen + ((shm->cursor_y + 1) * tcap_COLS) -
X        param, param);
X
X    if (!tty_is_multiscreen)
X        tcap_delete_chars(param);
X
X}                             /* end of ansi_ECH */
X
X/*+-------------------------------------------------------------------------
X    ansi_SU() - scroll up (new blank lines at the bottom)
X--------------------------------------------------------------------------*/
Xvoid
Xansi_SU()
X{
X    register uint param;
X    register uint count;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if (param > tcap_LINES)
X        param = tcap_LINES;
X    if (!param)
X        return;
X
X#ifdef ANSI_DEBUG_3
X    if (wfp)
X        fprintf(wfp, "SU: param=%u y,x=%d,%d\n", param,
X            shm->cursor_y, shm->cursor_x);
X#endif
X
X    count = tcap_COLS * param;
X    mem_cpy((char *)shm->screen, (char *)shm->screen + count,
X        LINESxCOLS - count);
X    spaces((char *)shm->screen + LINESxCOLS - count, count);
X
X    if (!tty_is_multiscreen)
X    {
X        tcap_cursor(tcap_LINES - 1, 0);
X        while (param--)
X            ff(se, "\r\n");
X        tcap_cursor(shm->cursor_y, shm->cursor_x);
X    }
X
X}                             /* end of ansi_SU */
X
X/*+-------------------------------------------------------------------------
X    ansi_SD() - scroll down (new blank lines at the top)
X--------------------------------------------------------------------------*/
Xvoid
Xansi_SD()
X{
X    register uint param;
X    register uint count;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if (param > tcap_LINES)
X        param = tcap_LINES;
X    if (!param)
X        return;
X
X#ifdef ANSI_DEBUG_3
X    if (wfp)
X        fprintf(wfp, "SD: param=%u y,x=%d,%d\n", param,
X            shm->cursor_y, shm->cursor_x);
X#endif
X
X    count = tcap_COLS * param;
X    mem_cpy((char *)shm->screen, (char *)shm->screen + count,
X        LINESxCOLS - count);
X    spaces((char *)shm->screen + LINESxCOLS - count, count);
X
X    if (!tty_is_multiscreen)
X    {
X        tcap_cursor(0, 0);
X        tcap_insert_lines(param);
X        tcap_cursor(shm->cursor_y, shm->cursor_x);
X    }
X
X}                             /* end of ansi_SD */
X
X/*+-------------------------------------------------------------------------
X    ansi_HPA() - horizontal position absolute
X--------------------------------------------------------------------------*/
Xvoid
Xansi_HPA()
X{
X    register uint param;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if (param >= tcap_LINES)
X        return;
X
X    if ((unsigned)(shm->cursor_x = param) >= (unsigned)tcap_COLS)
X        shm->cursor_x = tcap_COLS - 1;
X
X    if (!tty_is_multiscreen)
X        tcap_cursor(shm->cursor_y, shm->cursor_x);
X
X}                             /* end of ansi_HPA */
X
X/*+-------------------------------------------------------------------------
X    ansi_VPA() - vertical position absolute
X--------------------------------------------------------------------------*/
Xvoid
Xansi_VPA()
X{
X    register uint param;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if (param >= tcap_COLS)
X        return;
X
X    if ((unsigned)(shm->cursor_y = param) >= (unsigned)tcap_LINES)
X        shm->cursor_y = tcap_LINES - 1;
X
X    if (!tty_is_multiscreen)
X        tcap_cursor(shm->cursor_y, shm->cursor_x);
X
X}                             /* end of ansi_VPA */
X
X/*+-------------------------------------------------------------------------
X    ansi_IL() - insert lines
X--------------------------------------------------------------------------*/
Xvoid
Xansi_IL()
X{
X    register uint param;
X    register uint count;
X    register uint screen_pos;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if ((shm->cursor_y + param) >= tcap_LINES)
X        return;
X
X    count = tcap_COLS * param;
X    screen_pos = shm->cursor_y * tcap_COLS;
X    mem_cpy((char *)shm->screen + screen_pos + count,
X        (char *)shm->screen + screen_pos,
X        LINESxCOLS - screen_pos - count);
X    spaces((char *)shm->screen + screen_pos, count);
X
X    if (!tty_is_multiscreen)
X        tcap_insert_lines(param);
X
X}                             /* end of ansi_IL */
X
X/*+-------------------------------------------------------------------------
X    ansi_ICH() - insert characters
X--------------------------------------------------------------------------*/
Xvoid
Xansi_ICH()
X{
X    register uint param;
X    register uint count;
X    register uint screen_pos;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if (param > tcap_COLS - shm->cursor_x)
X        param = tcap_COLS - shm->cursor_x;
X
X    if (!param)
X        return;
X
X    screen_pos = (shm->cursor_y * tcap_COLS) + shm->cursor_x;
X    count = tcap_COLS - shm->cursor_x - param;
X    mem_cpy((char *)shm->screen + screen_pos + param,
X        (char *)shm->screen + screen_pos, count);
X    spaces((char *)shm->screen + screen_pos, param);
X
X    if (!tty_is_multiscreen)
X        tcap_insert_chars(param);
X
X}                             /* end of ansi_ICH */
X
X/*+-------------------------------------------------------------------------
X    ansi_DL() - delete lines
X--------------------------------------------------------------------------*/
Xvoid
Xansi_DL()
X{
X    register uint param;
X    register uint count;
X    register uint screen_pos;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if (param > (tcap_LINES - shm->cursor_y))
X        param = tcap_LINES - shm->cursor_y;
X
X    if (!param)
X        return;
X
X    count = tcap_COLS * param;
X    screen_pos = shm->cursor_y * tcap_COLS;
X    mem_cpy((char *)shm->screen + screen_pos,
X        (char *)shm->screen + screen_pos + count,
X        LINESxCOLS - screen_pos - count);
X    spaces((char *)shm->screen + LINESxCOLS - count, count);
X
X    if (!tty_is_multiscreen)
X        tcap_delete_lines(param);
X
X}                             /* end of ansi_DL */
X
X/*+-------------------------------------------------------------------------
X    ansi_DCH() - delete characters
X--------------------------------------------------------------------------*/
Xvoid
Xansi_DCH()
X{
X    register uint param;
X    register uint count;
X    register uint screen_pos;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if (param > tcap_COLS - shm->cursor_x)
X        param = tcap_COLS - shm->cursor_x;
X
X    if (!param)
X        return;
X
X    screen_pos = (shm->cursor_y * tcap_COLS) + shm->cursor_x;
X    count = tcap_COLS - shm->cursor_x - param;
X    mem_cpy((char *)shm->screen + screen_pos,
X        (char *)shm->screen + screen_pos + param, count);
X    screen_pos = ((shm->cursor_y + 1) * tcap_COLS) - param;
X    spaces((char *)shm->screen + screen_pos, param);
X
X    if (!tty_is_multiscreen)
X        tcap_delete_chars(param);
X
X}                             /* end of ansi_DCH */
X
X/*+-------------------------------------------------------------------------
X    ansi_CPL() - cursor to previous line
X--------------------------------------------------------------------------*/
Xvoid
Xansi_CPL()
X{
X    register uint param;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if ((shm->cursor_y -= param) >= tcap_LINES)    /* unsigned comparison */
X        shm->cursor_y = 0;
X    shm->cursor_x = 0;
X
X    if (!tty_is_multiscreen)
X        tcap_cursor(shm->cursor_y, shm->cursor_x);
X
X}                             /* end of ansi_CPL */
X
X/*+-------------------------------------------------------------------------
X    ansi_CNL() - cursor to next line
X--------------------------------------------------------------------------*/
Xvoid
Xansi_CNL()
X{
X    register uint param;
X
X    if (ansilen == 2)         /* no param */
X        param = 1;
X    else
X        param = atoi(ansibuf + 1);
X
X    if ((shm->cursor_y += param) >= tcap_LINES)
X        shm->cursor_y = tcap_LINES - 1;
X    shm->cursor_x = 0;
X
X    if (!tty_is_multiscreen)
X        tcap_cursor(shm->cursor_y, shm->cursor_x);
X
X}                             /* end of ansi_CNL */
X
X/*+-------------------------------------------------------------------------
X    saved_cursor_save_cursor() - nice but unfortunate IBM extension
X
XI can't find this used anywhere but in the DOS world.  Supporting this
Xpair of sequences is what started this whole complex mess.
X--------------------------------------------------------------------------*/
Xvoid
Xsaved_cursor_save_cursor()
X{
X    saved_cursor_y = shm->cursor_y;
X    saved_cursor_x = shm->cursor_x;
X}                             /* end of saved_cursor_save_cursor */
X
X/*+-------------------------------------------------------------------------
X    saved_cursor_restore_cursor() - nice but unfortunate IBM extension
X
XI can't find this used anywhere but in the DOS world.  Supporting this
Xpair of sequences is what started this whole complex mess.
X--------------------------------------------------------------------------*/
Xvoid
Xsaved_cursor_restore_cursor()
X{
X    shm->cursor_y = saved_cursor_y;
X    shm->cursor_x = saved_cursor_x;
X    tcap_cursor(shm->cursor_y, shm->cursor_x);
X}                             /* end of saved_cursor_restore_cursor */
X
X/*+-------------------------------------------------------------------------
X    rcvd_ESC() - ESC seen-prepare to accumulate ansi sequence
X--------------------------------------------------------------------------*/
Xvoid
Xrcvd_ESC()
X{
X#ifdef ANSI_DEBUG
X    if (wfp)
X        fprintf(wfp, "ESC ");
X#endif
X
X    ansi = ansibuf;
X    ansilen = 0;
X    in_ansi_accumulation = 1;
X
X}                             /* end of rcvd_ESC */
X
X/*+-------------------------------------------------------------------------
X    is_ansi_terminator(rchar) - is character terminator for ansi sequence?
X--------------------------------------------------------------------------*/
Xint
Xis_ansi_terminator(rchar)
Xregister uint rchar;
X{
X    return (isalpha(rchar) || strchr("@>=", rchar));
X}                             /* end of is_ansi_terminator */
X
X/*+-------------------------------------------------------------------------
X    accumulate_ansi_sequence(rchar)
X--------------------------------------------------------------------------*/
Xvoid
Xaccumulate_ansi_sequence(rchar)
Xuint rchar;
X{
X    if (ansilen == (MAX_ANSI_LEN - 2))
X    {
X        in_ansi_accumulation = 0;
X        return;
X    }
X
X#ifdef ANSI_DEBUG_2
X    if (wfp)
X    {
X        fprintf(wfp, "\naas: %02x %c ansilen=%d",
X            rchar, (rchar & 0x7F < SPACE) ? '.' : (rchar & 0x7F), ansilen);
X    }
X#endif
X
X    *ansi++ = (uchar) rchar;
X    *ansi = 0;
X    ansilen++;
X
X}                             /* end of accumulate_ansi_sequence */
X
X/*+-------------------------------------------------------------------------
X    process_ansi_sequence() - a full ansi sequence is to be decoded
X--------------------------------------------------------------------------*/
Xvoid
Xprocess_ansi_sequence()
X{
X    register itmp;
X
X#ifdef ANSI_DEBUG
X    if (wfp)
X    {
X        fprintf(wfp, "\npas: inansi=%d len=%d '%s' y,x=%d,%d\n",
X            in_ansi_accumulation, ansilen, ansibuf,
X            shm->cursor_y, shm->cursor_x);
X    }
X#endif
X
X    if (!in_ansi_accumulation)
X        return;
X    in_ansi_accumulation = 0;
X
X    itmp = 1;                 /* assume write needed */
X    if ((ansilen > 1) && (ansibuf[1] == '='))
X        ;
X    else
X        switch (ansibuf[ansilen - 1])
X        {
X            case '@':
X                ansi_ICH();
X                break;
X            case '=':
X                break;         /* VT-100 application keypad */
X            case '>':
X                break;         /* VT-100 numeric keypad */
X            case 'A':
X                ansi_CUU();
X                break;
X            case 'B':
X                ansi_CUD();
X                break;
X            case 'C':
X                ansi_CUF();
X                break;
X            case 'D':
X                ansi_CUB();
X                break;
X            case 'E':
X                ansi_CNL();
X                break;
X            case 'F':
X                ansi_CPL();
X                break;
X            case 'H':
X                ansi_CUP();
X                break;
X            case 'J':
X                ansi_ED();
X                break;
X            case 'K':
X                ansi_EL();
X                break;
X            case 'L':
X                ansi_IL();
X                break;
X            case 'M':
X                ansi_DL();
X                break;
X            case 'P':
X                ansi_DCH();
X                break;
X            case 'S':
X                ansi_SU();
X                break;
X            case 'T':
X                ansi_SD();
X                break;
X            case 'X':
X                ansi_ECH();
X                break;
X            case '`':
X                ansi_HPA();
X                break;
X            case 'a':
X                ansi_CUF();
X                break;         /* HPR */
X            case 'd':
X                ansi_VPA();
X                break;
X            case 'e':
X                ansi_CUD();
X                break;         /* VPR */
X            case 'f':
X                ansi_CUP();
X                break;         /* HVP */
X            case 'm':
X                ansi_SGR();
X                itmp = 0;
X                break;
X            case 'n':
X                ansi_DSR();
X                itmp = 0;
X                break;
X            case 's':
X                saved_cursor_save_cursor();
X                itmp = 0;
X                break;
X            case 'u':
X                saved_cursor_restore_cursor();
X                itmp = 0;
X                break;
X#ifdef FUTURES
X            case 'h':
X                ansi_SM();
X                break;         /* Set Mode: SCO: lock keyboard MSDOS: host
X                              * of shit */
X            case 'i':
X                ansi_MC();
X                break;         /* Media Copy: send screen to line */
X            case 'l':
X                ansi_RM();
X                break;         /* Reset Mode: SCO: unlock keyboard MSDOS:
X                              * host of shit */
X#endif /* FUTURES */
X            default:
X                break;
X        }
X
X/* if proper ansi console and indicated, write the buffer to the screen */
X    if (tty_is_multiscreen && itmp)
X    {
X        rcvrdisp(&esc, 1);
X        rcvrdisp(ansibuf, ansilen);
X    }
X
X#ifdef ANSI_DEBUG
X    if (wfp)
X        fprintf(wfp, "pas: new cursor y,x=%d,%d\n", shm->cursor_y, shm->cursor_x);
X#endif
X}                             /* end of process_ansi_sequence */
X
X/*+-------------------------------------------------------------------------
X    rcvr_log_open()
X--------------------------------------------------------------------------*/
Xvoid
Xrcvr_log_open()
X{
X
X    if (rcvr_log)             /* if xmtr set us up for logging */
X    {
X        rcvr_log_fp = fopen(rcvr_log_file, rcvr_log_append ? "a" : "w");
X        rcvr_log_append = 1; /* until next %log -s */
X        if (!rcvr_log_fp)
X        {
X            ff(se, "ecu RCVR: Could not open log file: %s\r\n", rcvr_log_file);
X            ff(se, "recording aborted.\r\n");
X            rcvr_log = 0;
X        }
X        else if (!rcvr_log_raw && rcvr_log_gen_title)
X        {
X#if 0                         /* decommitted - security risk */
X            char tstr[80];
X
X            get_tod(2, tstr);
X            fprintf(rcvr_log_fp, "\n====> %s (%s, %s, %s) %s\n\n",
X                shm->Lrname, shm->Llogical,
X                shm->Ldescr, (shm->Ltelno[0]) ? shm->Ltelno : "NONE", tstr);
X#endif
X        }
X        rcvr_log_gen_title = 0;
X    }
X}                             /* end of rcvr_log_open */
X
X/*+-------------------------------------------------------------------------
X    process_rcvd_char(rchar) - process a received character
X
XReturn 0 if char should be written to console, 1 otherwise
X--------------------------------------------------------------------------*/
Xint
Xprocess_rcvd_char(rchar)
Xregister uint rchar;
X{
X    register itmp;
X
X#ifdef LIMIT_BELL
X    long now;
X    static long last_bell_time = -1L;
X
X#endif
X
X    /*
X     * automatic ZMODEM frame detection (expensive CPU burners for lazy
X     * folks)
X     */
X    if (shm->autorz)
X    {
X        if ((uchar) rchar == autorz_frame[shm->autorz_pos])
X        {
X            itmp = shm->autorz_pos;    /* copy to register trying to be quick */
X            if (++itmp == sizeof(autorz_frame))
X            {
X                if (lgetc_count)
X                {
X                    rcvrdisp(lgetc_ptr, lgetc_count);
X                    lgetc_count = 0;
X                }
X                shmr_notify_zmodem_frame();
X                pause();     /* wait for death */
X                itmp = 0;     /* in case something starts us up */
X            }
X            shm->autorz_pos = itmp;
X            return (!itmp);     /* don't try to print ^X */
X        }
X        else
X            shm->autorz_pos = 0;
X    }
X
X    /*
X     * BEL and alarm-on-incoming-data processing
X     */
X    if (shm->bell_notify_state == 2)
X    {
X        shm->bell_notify_state = 1;
X        bell_notify(XBELL_3T);
X    }
X    else if (rchar == BEL)
X    {
X#ifdef LIMIT_BELL
X        time(&now);
X        if ((now - last_bell_time) < 2L)
X            return (1);
X        last_bell_time = now;
X#endif
X        bell_notify(XBELL_ATTENTION);
X        return (0);
X    }
X
X#if !defined(NO_ANSI_EMULATION)
X
X    /*
X     * video control sequences
X     */
X    if (rchar == ESC)
X    {
X        rcvd_ESC();
X        return (1);
X    }
X    else if (in_ansi_accumulation)
X    {
X
X        /*
X         * we handle some VT-100 two character sequences (ESC + one
X         * character)
X         */
X        int consumed = 0;
X
X        if (!ansilen)
X        {
X            switch (rchar & 0x7F)
X            {
X                case '7':     /* VT100 save cursor position */
X                    consumed = 1;
X                    saved_cursor_save_cursor();
X                    break;
X                case '8':     /* VT100 save cursor position */
X                    consumed = 1;
X                    saved_cursor_restore_cursor();
X                    break;
X            }
X            if (consumed)
X            {
X#ifdef ANSI_DEBUG
X                if (wfp)
X                    fprintf(wfp, "single: '%c'\n", rchar);
X#endif
X                in_ansi_accumulation = 0;
X                return (1);
X            }
X        }
X
X        /*
X         * other sequences go through the ANSI decode path
X         */
X        accumulate_ansi_sequence(rchar);
X        if (is_ansi_terminator(rchar))
X            process_ansi_sequence();
X        return (1);
X    }
X#endif /* !NO_ANSI_EMULATION */
X
X    /*
X     * the bread and butter of the receiver: print printable characters
X     * and obey formatting characters
X     */
X    if (rchar < SPACE)
X    {
X        switch (rchar)
X        {
X            case CTL_L:
X                spaces((char *)shm->screen, LINESxCOLS);
X                shm->cursor_y = 0;
X                shm->cursor_x = 0;
X                break;
X
X            case BS:
X                if (shm->cursor_x)
X                    shm->cursor_x--;
X                break;
X
X            case NL:
X                if (shm->cursor_y != tcap_LINES - 1)
X                    shm->cursor_y++;
X                else
X                {
X                    mem_cpy((char *)shm->screen, (char *)shm->screen + tcap_COLS,
X                        LINESxCOLS - tcap_COLS);
X                    spaces(&shm->screen[shm->cursor_y][0], tcap_COLS);
X                }
X                break;
X
X            case CRET:
X                shm->cursor_x = 0;
X                break;
X
X            case TAB:
X                itmp = 8 - (shm->cursor_x % 8);
X                shm->cursor_x += itmp;
X                if (shm->cursor_x >= tcap_COLS)
X                {
X                    shm->cursor_x = 0;
X                    if (++shm->cursor_y >= tcap_LINES)
X                        shm->cursor_y = tcap_LINES - 1;
X                }
X                spaces(&shm->screen[shm->cursor_y][shm->cursor_x], itmp);
X                break;
X
X#ifdef TANDEM_ENQ_ACK         /* for my friend John Dashner at Tandem */
X            case ENQ:
X                lputc(ACK);
X                return (0);
X#endif
X
X        }
X    }
X    else
X    {
X        shm->screen[shm->cursor_y][shm->cursor_x++] = (uchar) rchar;
X        if (shm->cursor_x >= tcap_COLS)
X        {
X            shm->cursor_x = 0;
X            if (shm->cursor_y != tcap_LINES - 1)
X                shm->cursor_y++;
X            else
X            {
X                mem_cpy((char *)shm->screen, (char *)shm->screen + tcap_COLS,
X                    LINESxCOLS - tcap_COLS);
X                spaces(&shm->screen[shm->cursor_y][shm->cursor_x], tcap_COLS);
X            }
X        }
X    }
X
X#ifdef ANSI_DEBUG_2
X    if (wfp)
X    {
X        if ((rchar & 0x7F) == NL)
X            fputs("\n", wfp);
X        else
X            fputc(((rchar & 0x7F) < SPACE) ? '.' : (rchar & 0x7F), wfp);
X    }
X#endif
X
X    /*
X     * receiver logging
X     */
X    if (rcvr_log && rcvr_log_fp)
X    {
X        /* if raw mode or character not excluded from "cooked" logging */
X        if (rcvr_log_raw || ((rchar >= SPACE) && (rchar <= '~')) ||
X            (rchar == NL) || (rchar == TAB))
X        {
X            LOGPUTC(rchar, rcvr_log_fp);
X        }
X        /* back if log file if not raw and char is backspace */
X        else if (!rcvr_log_raw && (rchar == BS))
X        {
X            long logpos = 0;
X
X            if (logpos = ftell(rcvr_log_fp))
X                fseek(rcvr_log_fp, logpos - 1, 0);
X        }
X
X        if (rcvr_log_flusheach)
X            fflush(rcvr_log_fp);
X    }
X    return (0);
X
X}                             /* end of process_rcvd_char */
X
X/*+-----------------------------------------------------------------------
X    rcvr() - copy characters from remote line to screen
X------------------------------------------------------------------------*/
Xvoid
Xrcvr()
X{
X    uchar rchar;
X    uchar nlchar = NL;
X
X#if defined(ANSI_DEBUG) || defined(RCVR_DEBUG)
X    char s80[80];
X
X#endif /* ANSI_DEBUG */
X
X#ifdef ANSI_DEBUG
X    wfp = fopen(ANSI_DEBUG_LOGFILE, "a");
X    if (ulindex(ANSI_DEBUG_LOGFILE, "/dev/tty") != -1)
X    {
X        sprintf(s80, "stty opost ocrnl < %s", ANSI_DEBUG_LOGFILE);
X        system(s80);
X    }
X#ifdef ANSI_DEBUG_NOBUF
X    setbuf(wfp, NULL);
X#endif /* ANSI_DEBUG_NOBUF */
X    fprintf(wfp, "***************\n");
X#endif /* ANSI_DEBUG */
X
X    rcvr_pid = getpid();
X    shm->autorz_pos = 0;
X    lgetc_count = 0;
X    in_ansi_accumulation = 0;
X    ansi = ansibuf;
X    ansilen = 0;
X    shm->rcvrdisp_ptr = shm->rcvrdisp_buffer;
X    shm->rcvrdisp_count = 0;
X
X#ifdef RCVR_DEBUG
X    sprintf(s80, "RSANE01 shm=%x", shm);
X    ecu_log_event(getppid(), s80);
X#endif /* RCVR_DEBUG */
X
X    /*
X     * yetch - magic number gretching for lines and columns
X     */
X    if (!tcap_LINES || !tcap_COLS)
X    {
X        tcap_LINES = 25;
X        tcap_COLS = 80;
X    }
X    if (tcap_LINES > SCREEN_LINES_MAX)
X        tcap_LINES = SCREEN_LINES_MAX;
X    if (tcap_COLS > SCREEN_COLS_MAX)
X        tcap_COLS = SCREEN_COLS_MAX;
X    LINESxCOLS = tcap_LINES * tcap_COLS;
X
X    rcvr_signals();
X    rcvr_log_open();
X
X    saved_cursor_y = shm->cursor_y;
X    saved_cursor_x = shm->cursor_x;
X
X    /*
X     * receive loop - keep tight as possible!
X     */
X
X#ifdef RCVR_DEBUG
X    sprintf(s80, "RSANE02 tty_is_multiscreen=%d", tty_is_multiscreen);
X    ecu_log_event(getppid(), s80);
X#endif /* RCVR_DEBUG */
X
X    if (tty_is_multiscreen)
X    {
X        while (1)
X        {
X            rchar = lgetc_rcvr();
X
X            if (process_rcvd_char(rchar))
X                continue;
X
X            rcvrdisp((char *)&rchar, 1);
X
X            if (shm->Ladd_nl_incoming && (rchar == CRET))
X                rcvrdisp((char *)&nlchar, 1);
X        }
X    }
X    else
X    {
X        while (1)
X        {
X            rchar = lgetc_rcvr();
X
X            if (rchar >= 0x80)
X                rchar = non_multiscreen_hi_map[rchar - 0x80];
X
X            if (process_rcvd_char(rchar))
X                continue;
X
X            rcvrdisp((char *)&rchar, 1);
X
X            if (shm->Ladd_nl_incoming && (rchar == CRET))
X                rcvrdisp((char *)&nlchar, 1);
X        }
X    }
X
X    /* NOTREACHED */
X
X}                             /* end of rcvr */
X
X/*+-------------------------------------------------------------------------
X    xmtr_wfp_debug_hack() - keep xmtr use of rcvr code from bombing
X
XThis function is called once by xmtr() before it does much else.
XThis is a horrible hack only necessary when the chips are down.
XIf ANSI_DEBUG has wfp open in rcvr, this opens it in the xmtr too.
XThe function has scope in the production binary only so ecu.c
Xhas no need to know the ANSI debug status.  This is the kind of
Xhack you never find out about in binary programs you buy :->.
X
X--------------------------------------------------------------------------*/
Xvoid
Xxmtr_wfp_debug_hack()
X{
X#ifdef ANSI_DEBUG
X    wfp = fopen("/dev/null", "w");
X#endif
X}                             /* end of xmtr_wfp_debug_hack */
X
X/* end of ecurcvr.c */
X/* vi: set tabstop=4 shiftwidth=4: */
END_OF_FILE
  if test 42110 -ne `wc -c <'ecu330/ecurcvr.c'`; then
    echo shar: \"'ecu330/ecurcvr.c'\" unpacked with wrong size!
  fi
  # end of 'ecu330/ecurcvr.c'
fi
if test -f 'ecu330/ecusighdl.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'ecu330/ecusighdl.c'\"
else
  echo shar: Extracting \"'ecu330/ecusighdl.c'\" \(19004 characters\)
  sed "s/^X//" >'ecu330/ecusighdl.c' <<'END_OF_FILE'
X/* #define TRICKY_SEGV */
X/*+-----------------------------------------------------------------------
X    ecusighdl.c - xmtr/rcvr individual process signal handlers
X    [e-mail]
X
X  Defined functions:
X    _start_rcvr_process(notify_flag)
X    _start_rcvr_process(notify_flag,fname,fline)
X    child_signals()
X    kill_rcvr_process(sig)
X    rcvr_SIGUSR2_handler()
X    rcvr_common_signal_handler()
X    rcvr_death_handler(sig)
X    rcvr_signals()
X    termecu(code)
X    termecu_code_text(code)
X    xmtr_SIGCLD_handler()
X    xmtr_SIGHUP_handler(sig)
X    xmtr_SIGINT_handler()
X    xmtr_SIGTERM_handler(sig)
X    xmtr_SIGUSR2_handler()
X    xmtr_death_handler(sig)
X    xmtr_signals()
X
X------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:05-04-1994-04:39-wht@n4hgf-ECU release 3.30 */
X/*:11-25-1993-14:47-wht@n4hgf-call shm_done AFTER restore_initial_colors */
X/*:10-04-1993-03:57-wht@n4hgf-simplify rcvr signal service + better reporting */
X/*:10-04-1993-01:58-wht@n4hgf-spice up term diags + report sigs for 1st time */
X/*:08-30-1993-12:39-wht@n4hgf-revert WHT to catch SEGV */
X/*:08-07-1993-20:25-wht@n4hgf-if WHT, do not catch SEGV, etc. */
X/*:06-26-1993-16:33-wht@n4hgf-check for rcvr active in rcvr death test */
X/*:10-18-1992-14:11-wht@n4hgf-FAS 2.10 users getting SIGUSR1 on xmtr */
X/*:09-16-1992-13:29-wht@n4hgf-add TERMECU_UNRECOVERABLE text */
X/*:09-10-1992-13:59-wht@n4hgf-ECU release 3.20 */
X/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
X/*:08-17-1992-04:55-wht@n4hgf-keep rcvr pid in shm for friend code */
X/*:08-16-1992-03:08-wht@n4hgf-head off another POSIX plot */
X/*:08-16-1992-01:54-wht@n4hgf-job control signals get SIG_IGN */
X/*:04-29-1992-19:04-wht@n4hgf-make a pass at handling job control signals */
X/*:04-29-1992-13:46-wht@n4hgf-ignore SIGQUIT */
X/*:04-23-1992-16:20-wht@n4hgf-disable mysterious rcvr SIGCLD events */
X/*:02-16-1992-01:42-wht@n4hgf-turn off xterm_title + add _terminate.ep */
X/*:08-25-1991-23:56-wht@n4hgf2-handle xmtr core dump gracefully */
X/*:07-25-1991-12:56-wht@n4hgf-ECU release 3.10 */
X/*:07-17-1991-07:04-wht@n4hgf-avoid SCO UNIX nap bug */
X/*:06-29-1991-15:42-wht@n4hgf-if WHT and xterm, play with title bar */
X/*:01-29-1991-12:57-wht@n4hgf-on exit, restore setcolor colors if possible */
X/*:12-18-1990-20:02-wht@n4hgf-add rcvr_death_handler */
X/*:09-19-1990-19:36-wht@n4hgf-ecu_log_event now gets pid for log from caller */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#include "ecu.h"
X#include "ecufork.h"
X
Xextern int windows_active;
Xextern int current_ttymode;
Xextern int ttymode_termecu_on_sigint;
Xextern int rcvr_log;
Xextern FILE *rcvr_log_fp;
Xextern char rcvr_log_file[]; /* if rcvr_log!= 0,log filename */
Xextern int rcvr_log_append;
X
Xint sigint = 0;                 /* interrupt indicator */
Xint proc_interrupt = 0;         /* procedure interrupt indicator */
Xint last_child_wait_status;
Xint last_child_wait_pid;
Xint xmtr_killed_rcvr;
X
Xchar *signal_name_text();
X
Xvoid xmtr_signals();
Xvoid rcvr_signals();
Xvoid child_signals();
X
XSIGTYPE kill_rcvr_process();
X
XSIGTYPE rcvr_SIGUSR2_handler();
XSIGTYPE xmtr_SIGINT_handler();
XSIGTYPE xmtr_SIGHUP_handler();
XSIGTYPE xmtr_SIGTERM_handler();
XSIGTYPE xmtr_SIGCLD_handler();
XSIGTYPE xmtr_death_handler();
XSIGTYPE rcvr_common_signal_handler();
XSIGTYPE rcvr_death_handler();
X
X/*
X * macros for wait() status ... in case they aren't defined
X */
X#undef WIFEXITED             /* in case they were */
X#undef WEXITSTATUS
X#undef WIFSIGNALED
X#undef WTERMSIG
X#undef WIFSTOPPED
X#undef WSTOPSIG
X
X#define WIFEXITED(status)    ((status & 0xFF) == 0)
X#define WEXITSTATUS(status)    ((status >> 8) & 0xFF)
X#define WIFSIGNALED(status)    ((status) && ((status & 0x00FF) == 0xFF))
X#define WTERMSIG(status)    (status & 0x7F)
X#define WIFSTOPPED(status)    ((status & 0xFF) == 0xFF)
X#define WSTOPSIG(status)    ((status >> 8) & 0xFF)
X
X/*+-------------------------------------------------------------------------
X    termecu_code_text(code)
X--------------------------------------------------------------------------*/
Xchar *
Xtermecu_code_text(code)
Xint code;
X{
X    static char errant[16];
X    char *signal_name_text();
X
X    if ((code >= TERMECU_SIG1) && (code <= TERMECU_SIGN))
X        return (signal_name_text(code));
X
X    switch (code)
X    {
X        case TERMECU_BSD4_IOCTL:
X            return ("BSD4 ioctl error");
X        case TERMECU_CONFIG_ERROR:
X            return ("configuration error");
X        case TERMECU_CURSES_ERROR:
X            return ("error in curses use");
X        case TERMECU_GEOMETRY:
X            return ("unsupported screen geometry");
X        case TERMECU_INIT_PROC_ERROR:
X            return ("error during initial procedure");
X        case TERMECU_IPC_ERROR:
X            return ("IPC (shm/sem) init failed");
X        case TERMECU_LINE_OPEN_ERROR:
X            return ("line open error");
X        case TERMECU_LINE_READ_ERROR:
X            return ("line read error");
X        case TERMECU_LOGIC_ERROR:
X            return ("internal logic error");
X        case TERMECU_MALLOC:
X            return ("critical memory allocation failure");
X        case TERMECU_NO_FORK_FOR_RCVR:
X            return ("can't fork for RCVR");
X        case TERMECU_PWENT_ERROR:
X            return ("password entry error");
X        case TERMECU_RCVR_FATAL_ERROR:
X            return ("detected RCVR FATAL ERROR");
X        case TERMECU_SHM_ABL:
X            return ("SHM ABL error");
X        case TERMECU_SHM_RTL:
X            return ("SHM RTL error");
X        case TERMECU_SVC_NOT_AVAIL:
X            return ("service not available");
X        case TERMECU_TTYIN_READ_ERROR:
X            return ("keyboard read error");
X        case TERMECU_UNRECOVERABLE:
X            return ("unrecoverable error");
X        case TERMECU_USAGE:
X            return ("usage");
X        case TERMECU_XMTR_FATAL_ERROR:
X            return ("detected XMTR FATAL ERROR");
X        default:
X            sprintf(errant, "code %u?", code);
X            return (errant);
X    }
X
X}                             /* end of termecu_code_text */
X
X/*+-----------------------------------------------------------------------
X    termecu(code) -- terminate program (with cleanup)
X
X  see termecu.h for a list of codes
X
X  Separate processing for rcvr and xmtr processes;  rcvr entry
X  is only upon some kind of serious error and it more less just dies,
X  causing xmtr process to wake up with SIGCLD and come in here.
X
X  Upon entry by xmtr process:
X    close comm line
X    run any _terminate.ep procedure
X    return any ungetty'd line
X    return user's console to normal status
X    remove shm segment
X    terminate program
X
X------------------------------------------------------------------------*/
XSIGTYPE
Xtermecu(code)
Xint code;
X{
X    static int already_in_termecu = 0;    /* one per fork */
X    int isig;
X    int save_errno = errno;
X    char s256[256];
X    extern char initial_procedure[];
X    char *signal_name_text();
X
X    if (already_in_termecu)
X    {
X        pprintf("\n\n\n%s REENTERED TERMECU ... CANNOT RECOVER\n",
X            (getpid() == xmtr_pid) ? "XMTR" : "RCVR");
X        exit(255);
X    }
X    already_in_termecu = 1;
X
X    if (shm)                 /* tell friends goodbye */
X        shm->terminating = 1;
X
X    if (xmtr_pid == getpid())/* if we are xmtr */
X    {
X        for (isig = 1; isig < NSIG; isig++)
X            signal(isig, SIG_IGN);
X        kill_rcvr_process(SIGUSR1);
X        if (windows_active)
X            windows_end_signal();
X        tcap_curbotleft();
X        tcap_eeod();
X        if (shm && shm->Lconnected)
X            DCE_hangup();
X        if (find_procedure("_terminate"))
X        {
X            char code_str[16];
X            char *_doproc_args[2];
X
X            _doproc_args[0] = "_terminate";    /* _terminate.ep */
X            sprintf(code_str, "%d", code);
X            _doproc_args[1] = code_str;
X            (void)do_proc(2, _doproc_args);
X        }
X
X        if (shm && (shm->Liofd != -1))
X            lclose();
X
X        /*
X         * make SURE we release any line(s) acquired from getty
X         */
X        ungetty_return_line((char *)0, "terminating");
X
X        ttymode(0);             /* normal tty status */
X        if (!code)
X            ;
X        else if (code <= TERMECU_SIGN)
X        {
X            pprintf("## XMTR caught signal %d (%s)\n",
X                code, signal_name_text(code));
X        }
X        else
X        {
X            setcolor(colors_error);
X            if (code == TERMECU_INIT_PROC_ERROR)
X                pprintf("initial procedure '%s' failed\n", initial_procedure);
X            else if ((code > TERMECU_INIT_PROC_ERROR) &&
X                (code <= TERMECU_INIT_PROC_ERROR + 32))
X            {
X                pprintf("procedure command: exit %d\n",
X                    code - TERMECU_INIT_PROC_ERROR);
X            }
X            else
X            {
X                sprintf(s256, "## XMTR %s, errno = %d", termecu_code_text(code),
X                    save_errno);
X                pputs(s256);
X                pputs("\n");
X                if (lopen_err_str[0])
X                {
X                    pputs(lopen_err_str);
X                    pputs("\n");
X                }
X                ecu_log_event(getpid(), s256);
X                errno = save_errno;
X                if (errno)
X                    pperror("errno may not apply, but");
X            }
X        }
X        restore_initial_colors();
X        shm_done();
X    }
X    else
X        /* we are rcvr */
X    {
X        if (code <= TERMECU_SIGN)
X        {
X            pprintf("## RCVR caught signal %d (%s)\n",
X                code, signal_name_text(code));
X        }
X        else
X        {
X            sprintf(s256, "## RCVR %s, errno = %d", termecu_code_text(code),
X                save_errno);
X            setcolor(colors_error);
X            pputs(s256);
X            pputs("\n");
X            ecu_log_event(getpid(), s256);
X            errno = save_errno;
X            if (errno)
X                pperror("errno may not apply, but");
X        }
X        restore_initial_colors();
X        kill(xmtr_pid, SIGHUP);
X    }
X    exit(code);
X    /* NOTREACHED */
X
X}                             /* end of termecu */
X
X/*+-----------------------------------------------------------------------
X    start_rcvr_process(notify_flag) - start RCVR process if not extant
X------------------------------------------------------------------------*/
Xvoid
Xstart_rcvr_process(notify_flag)
Xint notify_flag;
X{
X    extern ulong colors_current;
X    ulong colors_at_entry = colors_current;
X
X#if defined(FORK_DEBUG)
X    char s128[128];
X
X#endif
X
X    fflush(so);
X    fflush(se);
X
X    if (rcvr_pid > 0)         /* if process already active,just ... */
X        return;
X
X    if (rcvr_log && rcvr_log_file[0] && rcvr_log_fp)
X    {
X        fclose(rcvr_log_fp);
X        rcvr_log_fp = (FILE *) 0;
X    }
X
X    xmtr_killed_rcvr = 0;
X    shm->rcvr_pid = rcvr_pid = smart_fork();
X    if (rcvr_pid == 0)         /* if we are the (spawned) rcvr process */
X    {
X        if (notify_flag)
X        {
X            setcolor(colors_notify);
X            fputs("[interactive mode]", se);
X            setcolor(colors_at_entry);
X            fputs("\r\n", se);
X        }
X
X#if defined(FORK_DEBUG)
X        sprintf(s128, "RCVR-START pid %d", getpid());
X        ecu_log_event(getppid(), s128);    /* rcvr */
X#endif
X        rcvr();                 /* run until killed */
X        /* NOTREACHED */
X    }
X    else if (rcvr_pid > 0)     /* we are the father (xmtr) process */
X    {
X#if defined(FORK_DEBUG)
X        sleep(2);
X#endif
X        if (rcvr_log)
X            rcvr_log_append = 1;    /* until next %log -s */
X        xmtr_signals();
X        return;
X    }
X
X    shm->rcvr_pid = rcvr_pid = -1;    /* no receiver active */
X
X    pprintf("\n\nECU could not fork for receive process\n");
X    termecu(TERMECU_NO_FORK_FOR_RCVR);
X    /* NOTREACHED */
X
X}                             /* end of _start_rcvr_process */
X
X/*+-----------------------------------------------------------------------
X    kill_rcvr_process(sig) -- kill rcvr process with signal 'sig'
X------------------------------------------------------------------------*/
XSIGTYPE
Xkill_rcvr_process(sig)
Xint sig;
X{
X    int wait_count = 70;
X
X    if (rcvr_pid > 0)         /* if we have forked a rcvr process */
X    {
X        xmtr_killed_rcvr = 1;
X        rcvr_log_fp = (FILE *) 0;
X        xmtr_signals();
X        kill(rcvr_pid, sig);
X        if (sig != SIGUSR2)     /* rcvr does not die on SIGUSR2 */
X        {
X            errno = 0;
X            while (wait_count)
X            {
X                if (kill(rcvr_pid, 0) && (errno == ESRCH))
X                    break;
X                errno = 0;
X                Nap(40L);
X                wait_count--;
X            }
X            if (!wait_count)
X            {
X                while (!kill(rcvr_pid, SIGKILL))
X                {
X                    wait((int *)0);
X                    Nap(40L);
X                }
X            }
X            shm->rcvr_pid = rcvr_pid = -1;    /* no receiver active */
X            if (rcvr_log && rcvr_log_file[0])
X                rcvr_log_fp = fopen(rcvr_log_file, "a");
X
X            rcvrdisp_actual();    /* write any buffered screen data */
X        }
X    }
X
X}                             /* end of kill_rcvr_process */
X
X/*+-------------------------------------------------------------------------
X    rcvr_common_signal_handler(sig)
X--------------------------------------------------------------------------*/
XSIGTYPE
Xrcvr_common_signal_handler(sig)
Xint sig;
X{
X    extern int rcvr_log;
X    extern int rcvr_log_raw;
X    extern FILE *rcvr_log_fp;
X
X    if (rcvr_log)
X    {
X        if (!rcvr_log_raw)
X            fputs("\n", rcvr_log_fp);
X        fclose(rcvr_log_fp);
X    }
X
X    if (sig == SIGUSR1)
X        _exit(0);
X
X    termecu(sig);
X
X}                             /* end of rcvr_common_signal_handler */
X
X/*+-------------------------------------------------------------------------
X    rcvr_SIGUSR2_handler(sig)
X--------------------------------------------------------------------------*/
XSIGTYPE
Xrcvr_SIGUSR2_handler(sig)
Xint sig;
X{
X    signal(SIGUSR2, rcvr_SIGUSR2_handler);
X    shmr_process_rcvr_SIGUSR2(sig);
X}                             /* end of rcvr_SIGUSR2_handler */
X
X/*+-------------------------------------------------------------------------
X    rcvr_death_handler(sig) - unexpected signal; try to dump core
X--------------------------------------------------------------------------*/
XSIGTYPE
Xrcvr_death_handler(sig)
Xint sig;
X{
X    int itmp;
X
X#ifdef TRICKY_SEGV             /* SCO/i386 */
X    int *open_elevator_shaft = (int *)0xb0000000;
X
X#endif
X
X    ttymode(0);
X    pprintf("\nreceiver process caught signal %d (%s)\n",
X        sig, signal_name_text(sig));
X    pprintf("screen cursor (y,x) = (%u,%u)\n", shm->cursor_y, shm->cursor_x);
X    for (itmp = 1; itmp < NSIG; itmp++)
X        signal(itmp, SIG_DFL);
X#ifdef TRICKY_SEGV
X    signal(SIGSEGV, SIG_DFL);
X    printf("Roes=%08lx\n", open_elevator_shaft);
X    *open_elevator_shaft = itmp;
X#else
X    rcvr_common_signal_handler(sig);
X#endif
X    _exit(-1);
X
X}                             /* end of rcvr_death_handler */
X
X/*+-------------------------------------------------------------------------
X    xmtr_SIGINT_handler()
X--------------------------------------------------------------------------*/
XSIGTYPE
Xxmtr_SIGINT_handler()
X{
X    if (ttymode_termecu_on_sigint)
X        termecu(SIGINT);
X
X    signal(SIGINT, xmtr_SIGINT_handler);
X    sigint = 1;
X    proc_interrupt = 1;
X}                             /* end of xmtr_SIGINT_handler */
X
X/*+-------------------------------------------------------------------------
X    xmtr_SIGHUP_handler(sig)
X--------------------------------------------------------------------------*/
XSIGTYPE
Xxmtr_SIGHUP_handler(sig)
Xint sig;
X{
X    termecu(sig);
X}                             /* end of xmtr_SIGHUP_handler */
X
X/*+-------------------------------------------------------------------------
X    xmtr_SIGTERM_handler(sig)
X--------------------------------------------------------------------------*/
XSIGTYPE
Xxmtr_SIGTERM_handler(sig)
Xint sig;
X{
X    termecu(sig);
X}                             /* end of xmtr_SIGTERM_handler */
X
X/*+-------------------------------------------------------------------------
X    xmtr_SIGUSR2_handler()
X--------------------------------------------------------------------------*/
XSIGTYPE
Xxmtr_SIGUSR2_handler(sig)
Xint sig;
X{
X    SIGTYPE xmtr_SIGUSR2_handler();
X
X    signal(sig, xmtr_SIGUSR2_handler);
X    shmx_process_xmtr_SIGUSR2();
X
X}                             /* end of xmtr_SIGUSR2_handler */
X
X/*+-------------------------------------------------------------------------
X    xmtr_death_handler(sig) - unexpected signal; try to dump core
X--------------------------------------------------------------------------*/
XSIGTYPE
Xxmtr_death_handler(sig)
Xint sig;
X{
X    int itmp;
X
X#ifdef TRICKY_SEGV
X    int *open_elevator_shaft = (int *)0xb0000000;
X
X#endif
X
X    ttymode(0);
X    pprintf("\ntransmitter process caught signal %d (%s)\n",
X        sig, signal_name_text(sig));
X    kill_rcvr_process(SIGUSR1);
X    for (itmp = 1; itmp < NSIG; itmp++)
X        signal(itmp, SIG_DFL);
X#ifdef TRICKY_SEGV
X    signal(SIGSEGV, SIG_DFL);
X    printf("Xoes=%08lx\n", open_elevator_shaft);
X    fflush(stdout);
X    *open_elevator_shaft = itmp;
X#else
X    kill((PID_T) getpid(), SIGIOT);
X#endif
X    termecu(sig);
X}                             /* end of xmtr_death_handler */
X
X/*+-------------------------------------------------------------------------
X    xmtr_SIGCLD_handler()
X--------------------------------------------------------------------------*/
XSIGTYPE
Xxmtr_SIGCLD_handler()
X{
X    int itmp;
X
X#if defined(FORK_DEBUG)
X    char s512[512];
X
X#endif
X
X  WAIT:
X    errno = 0;
X    if ((last_child_wait_pid = wait(&last_child_wait_status)) < 0)
X    {
X        if (errno == EINTR)
X            goto WAIT;
X    }
X
X#if defined(FORK_DEBUG)
X    sprintf(s512, "XMTR SIGCLD pid %d (%s) s=%04x ",
X        last_child_wait_pid,
X        (last_child_wait_pid == rcvr_pid) ? "RCVR!" : "AUXOP",
X        last_child_wait_status);
X    if (WIFEXITED(last_child_wait_status))
X    {
X        sprintf(s512 + strlen(s512), "exit status=%d ",
X            WEXITSTATUS(last_child_wait_status));
X    }
X    if (WIFSIGNALED(last_child_wait_status))
X    {
X        sprintf(s512 + strlen(s512), "signal=%d ",
X            WTERMSIG(last_child_wait_status));
X    }
X    ecu_log_event(getpid(), s512);    /* xmtr_SIGCLD_handler() */
X#endif
X
X    if ((last_child_wait_pid == rcvr_pid) && (rcvr_pid > 0) &&
X        !xmtr_killed_rcvr)
X    {
X        pprintf("\nECU receiver (pid %d died) unexpectedly: s=0x%04x\n",
X            last_child_wait_pid, last_child_wait_status);
X        itmp = 0;
X        if (WIFEXITED(last_child_wait_status))
X        {
X            itmp = 1;
X            pprintf("exit status=%d ", WEXITSTATUS(last_child_wait_status));
X        }
X        if (WIFSIGNALED(last_child_wait_status))
X        {
X            itmp = 1;
X            pprintf("signal=%d ", WTERMSIG(last_child_wait_status));
X        }
X        if (itmp)
X            pputs("\n");
X        termecu(TERMECU_RCVR_FATAL_ERROR);
X    }
X    signal(SIGCLD, xmtr_SIGCLD_handler);
X
X}                             /* end of xmtr_SIGCLD_handler */
X
X/*+-------------------------------------------------------------------------
X    child_signals() - signal() calls for children processes
X--------------------------------------------------------------------------*/
Xvoid
Xchild_signals()
X{
X    int isig;
X
X    for (isig = 0; isig < NSIG; isig++)
X        signal(isig, SIG_DFL);
X
X}                             /* end of child_signals */
X
X/*+-------------------------------------------------------------------------
X    xmtr_signals()
X--------------------------------------------------------------------------*/
Xvoid
Xxmtr_signals()
X{
X    int sig;
X
X    for (sig = 1; sig < NSIG; sig++)
X    {
X        switch (sig)
X        {
X
X            case SIGHUP:
X                signal(sig, xmtr_SIGHUP_handler);
X                break;
X
X#if    defined(SIGSTOP)
X
X                /*
X                 * call Roto-Rooter on POSIX plots
X                 */
X            case SIGSTOP:
X            case SIGTSTP:
X            case SIGCONT:
X            case SIGTTIN:
X            case SIGTTOU:
X                signal(sig, SIG_IGN);
X                break;
X#endif
X
X#ifdef SIGWINCH
X            case SIGWINCH:
X                signal(sig, SIG_DFL);
X                break;
X#endif
X            case SIGQUIT:
X                signal(sig, SIG_IGN);
X                break;
X            case SIGINT:
X                signal(sig, xmtr_SIGINT_handler);
X                break;
X            case SIGTERM:
X                signal(sig, xmtr_SIGTERM_handler);
X                break;
X            case SIGCLD:
X                signal(sig, xmtr_SIGCLD_handler);
X                break;
X            case SIGUSR1:
X                signal(sig, SIG_IGN);
X                break;
X            case SIGUSR2:
X                signal(sig, xmtr_SIGUSR2_handler);
X                break;
X            default:
X#ifndef WHT                     /* I want the bloody crash */
X                signal(sig, xmtr_death_handler);
X#endif
X                break;
X        }
X    }
X
X}                             /* end of xmtr_signals */
X
X/*+-------------------------------------------------------------------------
X    rcvr_signals()
X--------------------------------------------------------------------------*/
Xvoid
Xrcvr_signals()
X{
X    int sig;
X
X    for (sig = 1; sig < NSIG; sig++)
X    {
X        switch (sig)
X        {
X
X#if    defined(SIGSTOP)
X            case SIGSTOP:
X            case SIGTSTP:
X            case SIGCONT:
X            case SIGTTIN:
X            case SIGTTOU:
X                signal(sig, SIG_IGN);
X                break;
X#endif
X
X#ifdef SIGWINCH
X            case SIGWINCH:
X#endif
X            case SIGCLD:
X                signal(sig, SIG_DFL);
X                break;
X            case SIGQUIT:
X                signal(sig, SIG_IGN);
X                break;
X            case SIGHUP:
X            case SIGINT:
X            case SIGTERM:
X            case SIGUSR1:
X                signal(sig, rcvr_common_signal_handler);
X                break;
X            case SIGUSR2:
X                signal(sig, rcvr_SIGUSR2_handler);
X                break;
X            default:
X#ifndef WHT                     /* I want the bloody crash */
X                signal(sig, rcvr_death_handler);
X#endif
X                break;
X        }
X    }
X}                             /* end of rcvr_signals */
X
X/* vi: set tabstop=4 shiftwidth=4: */
END_OF_FILE
  if test 19004 -ne `wc -c <'ecu330/ecusighdl.c'`; then
    echo shar: \"'ecu330/ecusighdl.c'\" unpacked with wrong size!
  fi
  # end of 'ecu330/ecusighdl.c'
fi
echo shar: End of archive 8 \(of 37\).
cp /dev/null ark8isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 37 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still must unpack the following archives:
    echo "        " ${MISSING}
fi
exit 0
exit 0 # Just in case...