URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk
Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [mw/] [src/] [demos/] [nanox/] [nxterm.c] - Blame information for rev 673

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * nxterm - terminal emulator for Nano-X
 *
 * (C) 1994,95,96 by Torsten Scherer (TeSche)
 * itschere@techfak.uni-bielefeld.de
 *
 * - quite some changes for W1R1
 * - yet more changes for W1R2
 *
 * TeSche 01/96:
 * - supports W_ICON & W_CLOSE
 * - supports /etc/utmp logging for SunOS4 and Linux
 * - supports catching of console output for SunOS4
 * Phx 02-06/96:
 * - supports NetBSD-Amiga
 * Eero 11/97:
 * - unsetenv(DISPLAY), setenv(LINES, COLUMNS).
 * - Add new text modes (you need to use terminfo...).
 * Eero 2/98:
 * - Implemented fg/bgcolor setting.  With monochrome server it changes
 *   bgmode variable, which tells in which mode to draw to screen
 *   (M_CLEAR/M_DRAW) and affects F_REVERSE settings.
 * - Added a couple of checks.
 *
 * TODO:
 * - Allocate and set sensible window palette for fg/bg color setting.
 * - add scroll-region ('cs') command. Fairly many programs
 *   can take advantage of that.
 * - Add xterm like mouse event to terminfo key event conversion... :)
 * - check if current NetBSD really needs ifdefs below with
 *   current W server/library.
 */
#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <utmp.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <pwd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define MWINCLUDECOLORS
#include "nano-X.h"
#include "nxterm.h"
 
#define TITLE   "nxterm"
 
#define SMALLBUFFER 80
#define LARGEBUFFER 1024
 
/*
 * some pty helper functions
 */
#ifdef linux
#define NSIG _NSIG
#endif
 
#ifdef __FreeBSD__
#include <libutil.h>
#endif
 
 
/*
 * some global variables
 */
 
static GR_WINDOW_ID     w1;     /* id for window */
static GR_GC_ID         gc1;    /* graphics context */
static GR_FONT_ID       regFont;
/*static GR_FONT_ID       boldFont;*/
 
static GR_SCREEN_INFO   si;     /* screen info */
static GR_FONT_INFO     fi;     /* Font Info */
static GR_WINDOW_INFO   wi;
static GR_GC_INFO       gi;
static GR_BOOL          havefocus = GR_FALSE;
 
static short winw, winh, pid, console;
static int pipeh;
static short cblink = 0, visualbell = 0, debug = 0;
#ifdef __FreeBSD__
static char pty[SMALLBUFFER];
static struct winsize winsz;
#endif
 
#define fonh fi.height
#define fonw fi.maxwidth
 
int term_init();
 
/****************************************************************************/
 
/*
 *
 */
 
/* static int isIconified; */
static int isMaximized=0;
 
void maximize(void)
{
    static short x0, y0, w, h, w_max,h_max;
 
    if (!isMaximized)
    {
 
        w_max=si.cols-wi.bordersize;
        h_max=si.rows-wi.bordersize;
        GrMoveWindow(w1,0,0);
        GrResizeWindow(w1,w_max, h_max);
        isMaximized=1;
    }
    else
    {
        GrResizeWindow(w1, w, h);
        GrMoveWindow(w1, x0, y0);
        isMaximized=0;
    }
}
 
 
/****************************************************************************/
 
 
/*
 * some common tool functions
 */
 
void sigpipe(int sig)
{
  /* this one musn't close the window */
/*  _write_utmp(pty, "", "", 0);  */
  kill(-pid, SIGHUP);
  _exit(sig);
}
 
 
void sigchld(int sig)
{
/*  _write_utmp(pty, "", "", 0);  */
  _exit(sig);
}
 
 
void sigquit(int sig)
{
  signal(sig, SIG_IGN);
  kill(-pid, SIGHUP);
}
 
 
/*
 * this is the wterm terminal code, almost like VT52
 */
 
short   bgmode, escstate, curx, cury, curon, curvis;
short   savx, savy, wrap, style;
short   col, row, colmask = 0x7f, rowmask = 0x7f;
 
/*
 * something to buffer plain text output
 */
 
short   sbufcnt = 0;
short   sbufx, sbufy;
char    lineBuffer[SMALLBUFFER+1];
char    *sbuf=lineBuffer;
 
void sflush(void)
{
    if (sbufcnt)
    {
        GrText(w1,gc1, sbufx*fonw, sbufy*fonh, sbuf, sbufcnt, GR_TFTOP);
        sbufcnt = 0;
    }
}
 
 
void lineRedraw(void)
{
    GrSetGCForeground(gc1,gi.background);
    GrFillRect(w1, gc1, curx*fonw, cury*fonh, (col-curx)*fonw, fonh);
    GrSetGCForeground(gc1,gi.foreground);
 
    if (sbufcnt)
    {
        sbuf[sbufcnt] = 0;
        GrText(w1,gc1, sbufx*fonw, sbufy*fonh, sbuf, sbufcnt, GR_TFTOP);
    }
}
 
void sadd (char c)
{
    if (sbufcnt == SMALLBUFFER)
    {
        sflush ();
    }
 
    if (!sbufcnt)
    {
        sbufx = curx;
        sbufy = cury;
    }
 
    sbuf[sbufcnt++] = c;
}
 
void show_cursor (void)
{
        GrSetGCMode(gc1,GR_MODE_XOR);
        GrSetGCForeground(gc1, WHITE);
        GrFillRect(w1, gc1, curx*fonw, cury*fonh+1, fonw, fonh-1);
        GrSetGCForeground(gc1, gi.foreground);
        GrSetGCMode(gc1,GR_MODE_COPY);
}
 
 
void draw_cursor (void)
{
    if (!curvis)
    {
        curvis = 1;
        show_cursor();
    }
}
void hide_cursor (void)
{
    if (curvis)
    {
        curvis = 0;
        show_cursor();
    }
}
 
 
void vscroll(int lines)
{
    hide_cursor();
    GrCopyArea(w1,gc1,0, 0, winw, winh-(lines*fonh),
               w1, 0, (lines*fonh), MWROP_SRCCOPY);
 
    GrSetGCForeground(gc1,gi.background);
    GrFillRect(w1, gc1, 0, winh-(lines*fonh),
               winw, (lines*fonh));
    GrSetGCForeground(gc1,gi.foreground);
}
 
void esc5(unsigned char c)      /* setting background color */
{
 
    GrSetGCBackground(gc1, c);
    GrGetGCInfo(gc1,&gi);
    escstate = 0;
}
 
void esc4(unsigned char c)      /* setting foreground color */
{
    GrSetGCForeground(gc1,c);
    GrGetGCInfo(gc1,&gi);
    escstate = 0;
}
 
void esc3(unsigned char c)      /* cursor position x axis */
{
    curx = (c - 32) & colmask;
    if (curx >= col)
        curx = col - 1;
    else if (curx < 0)
        curx = 0;
    escstate = 0;
}
 
 
void esc2(unsigned char c)      /* cursor position y axis */
{
  cury = (c - 32) & rowmask;
  if (cury >= row)
    cury = row - 1;
  else if (cury < 0)
    cury = 0;
  escstate = 3;
}
 
 
void esc1(unsigned char c)      /* various control codes */
{
    static int ReverseMode=0;
    escstate = 0;
 
    switch(c)
    {
    case 'A':/* cursor up */
        hide_cursor();
        if ((cury -= 1) < 0)
            cury = 0;
        break;
 
    case 'B':/* cursor down */
        hide_cursor();
        if ((cury += 1) >= row)
            cury = row - 1;
        break;
 
    case 'C':/* cursor right */
        hide_cursor();
        if ((curx += 1) >= col)
            curx = col - 1;
        break;
 
    case 'D':/* cursor left */
        hide_cursor();
        if ((curx -= 1) < 0)
            curx = 0;
        break;
 
    case 'E':/* clear screen & home */
        GrClearWindow(w1, 0);
        curx = 0;
        cury = 0;
        break;
 
    case 'H':/* cursor home */
        curx = 0;
        cury = 0;
        break;
 
    case 'I':/* reverse index */
        if ((cury -= 1) < 0)
        {
            cury = 0;
            vscroll(1);
        }
        break;
 
    case 'J':/* erase to end of page */
 
        if (cury < row-1)
        {
            GrSetGCForeground(gc1,gi.background);
            GrFillRect(w1,gc1, 0,(cury+1)*fonh, winw, (row-1-cury)*fonh);
            GrSetGCForeground(gc1,gi.foreground);
        }
        GrSetGCForeground(gc1,gi.background);
        GrFillRect(w1, gc1, curx*fonw, cury*fonh, (col-curx)*fonw, fonh);
        GrSetGCForeground(gc1,gi.foreground);
        break;
 
    case 'K':/* erase to end of line */
        GrSetGCForeground(gc1,gi.background);
        GrFillRect(w1, gc1, curx*fonw, cury*fonh, (col-curx)*fonw, fonh);
        GrSetGCForeground(gc1,gi.foreground);
        break;
 
    case 'L':/* insert line */
        if (cury < row-1)
        {
            vscroll(1);
        }
        curx = 0;
        break;
 
    case 'M':/* delete line */
        if (cury < row-1)
        {
            vscroll(1);
        }
        curx = 0;
        break;
 
    case 'Y':/* position cursor */
        escstate = 2;
        break;
 
    case 'b':/* set foreground color */
        escstate = 4;
        break;
 
    case 'c':/* set background color */
        escstate = 5;
        break;
 
    case 'd':/* erase beginning of display */
/*      w_setmode(win, bgmode); */
        if (cury > 0)
        {
            GrSetGCForeground(gc1,gi.background);
            GrFillRect(w1,gc1, 0, 0, winw, cury*fonh);
            GrSetGCForeground(gc1,gi.foreground);
        }
        if (curx > 0)
        {
            GrSetGCForeground(gc1,gi.background);
            GrFillRect(w1,gc1, 0, cury*fonh, curx*fonw, fonh);
            GrSetGCForeground(gc1,gi.foreground);
        }
        break;
 
    case 'e':/* enable cursor */
        curon = 1;
        break;
 
    case 'f':/* disable cursor */
        curon = 0;
        break;
 
    case 'j':/* save cursor position */
        savx = curx;
        savy = cury;
        break;
 
    case 'k':/* restore cursor position */
        curx = savx;
        cury = savy;
        break;
 
    case 'l':/* erase entire line */
        GrSetGCForeground(gc1,gi.background);
        GrRect(w1,gc1, 0, cury*fonh, winw, fonh);
        GrSetGCForeground(gc1,gi.foreground);
        curx = 0;
        break;
 
    case 'o':/* erase beginning of line */
        if (curx > 0)
        {
            GrSetGCForeground(gc1,gi.background);
            GrRect(w1,gc1,0, cury*fonh, curx*fonw, fonh);
            GrSetGCForeground(gc1,gi.foreground);
        }
        break;
 
    case 'p':/* enter reverse video mode */
    {
        if(!ReverseMode)
        {
            GrSetGCForeground(gc1,gi.background);
            GrSetGCBackground(gc1,gi.foreground);
            ReverseMode=1;
        }
    }
        break;
 
    case 'q':/* exit reverse video mode */
    {
        if(ReverseMode)
        {
            GrSetGCForeground(gc1,gi.foreground);
            GrSetGCBackground(gc1,gi.background);
            ReverseMode=0;
        }
    }
        break;
 
    case 'v':/* enable wrap at end of line */
        wrap = 1;
        break;
 
    case 'w':/* disable wrap at end of line */
        wrap = 0;
        break;
 
/* and these are the extentions not in VT52 */
 
    case 'G': /* clear all attributes */
        break;
 
    case 'g': /* enter bold mode */
/*      GrSetGCFont(gc1, boldFont); */
        break;
 
    case 'h': /* exit bold mode */
/*      GrSetGCFont(gc1, regFont); */
        break;
 
    case 'i': /* enter underline mode */
        break;
 
        /* j, k and l are already used */
 
    case 'm': /* exit underline mode */
        break;
 
/* these ones aren't yet on the termcap entries */
 
    case 'n': /* enter italic mode */
        break;
        /* o, p and q are already used */
 
    case 'r': /* exit italic mode */
        break;
 
    case 's': /* enter light mode */
        break;
 
    case 't': /* exit ligth mode */
        break;
 
    default: /* unknown escape sequence */
        break;
    }
}
 
/*
 * un-escaped character print routine
 */
 
void esc0 (unsigned char c)
{
    switch (c)
    {
    case 0:
        /*
         * printing \000 on a terminal means "do nothing".
         * But since we use \000 as string terminator none
         * of the characters that follow were printed.
         *
         * perl -e 'printf("a%ca", 0);'
         *
         * said 'a' in a wterm, but should say 'aa'. This
         * bug screwed up most ncurses programs.
         *
         * kay.
         */
        break;
 
    case 7: /* bell */
        if (visualbell)
        {
/*          w_setmode(win, M_INVERS); */
/*          w_pbox(win, 0, 0, winw, winh); */
/*          w_test(win, 0, 0); */
/*          w_pbox(win, 0, 0, winw, winh); */
            ;
        }
        else
        {
            ;
            GrBell();
        }
        break;
 
    case 8: /* backspace */
        lineRedraw();
        if (--curx < 0)
        {
            curx = 0;
        }
        break;
 
    case 9: /* tab */
    {
        int borg,i;
 
        borg=(((curx >> 3) + 1) << 3);
        if(borg >= col)
        {
            borg=col-1;
        }
        borg=borg-curx;
        for(i=0; i < borg; ++i){sadd(' ');}
        if ((curx = ((curx >> 3) + 1) << 3) >= col)
        {
            curx = col - 1;
        }
    }
        break;
 
    case 10: /* line feed */
        sflush();
        if (++cury >= row)
        {
            vscroll(1);
            cury = row-1;
        }
        break;
 
    case 13: /* carriage return */
        sflush();
        curx = 0;
        break;
 
    case 27: /* escape */
        sflush();
        escstate = 1;
        break;
 
    case 127: /* delete */
        break;
 
    default: /* any printable char */
        sadd(c);
        if (++curx >= col)
        {
            sflush();
            if (!wrap)
            {
                curx = col-1;
            }
            else
            {
                curx = 0;
                if (++cury >= row)
                {
                    vscroll(1);
                }
            }
        }
        break;
    }
}
 
 
void printc(unsigned char c)
{
    switch(escstate)
    {
    case 0:
        esc0(c);
        break;
 
    case 1:
        sflush();
        esc1(c);
        break;
 
    case 2:
        sflush();
        esc2(c);
        break;
 
    case 3:
        sflush();
        esc3(c);
        break;
 
    case 4:
        sflush();
        esc4(c);
        break;
 
    case 5:
        sflush();
        esc5(c);
        break;
 
    default:
        escstate = 0;
        break;
    }
}
 
 
void init()
{
    curx = savx = 0;
    cury = savy = 0;
    wrap = 1;
    curon = 1;
    curvis = 0;
    escstate = 0;
}
 
 
/*
 * general code...
 */
 
void
term(void)
{
        long            in, l;
        GR_EVENT        wevent;
        GR_EVENT_KEYSTROKE *kp;
        unsigned char   buf[LARGEBUFFER];
 
        GrRegisterInput(pipeh);
        while (42) {
                if (havefocus)
                        draw_cursor();
                GrGetNextEvent(&wevent);
 
                switch(wevent.type) {
                case GR_EVENT_TYPE_CLOSE_REQ:
                        GrClose();
                        exit(0);
                        break;
 
                case GR_EVENT_TYPE_KEY_DOWN:
                        kp=(GR_EVENT_KEYSTROKE *)&wevent;
                        /* toss all special keys*/
                        if (kp->ch & MWKEY_NONASCII_MASK)
                                break;
                        *buf = kp->ch & 0xff;
                        write(pipeh, buf,1);
                        break;
 
                case GR_EVENT_TYPE_FOCUS_IN:
                        havefocus = GR_TRUE;
                        break;
 
                case GR_EVENT_TYPE_FOCUS_OUT:
                        havefocus = GR_FALSE;
                        hide_cursor();
                        break;
 
                case GR_EVENT_TYPE_UPDATE:
                        /*
                         * if we get temporarily unmapped (moved),
                         * set cursor state off.
                         */
                        if (wevent.update.utype == GR_UPDATE_UNMAPTEMP)
                                curvis = 0;
                        break;
 
                case GR_EVENT_TYPE_FDINPUT:
                        hide_cursor();
                        while ((in = read(pipeh, buf, sizeof(buf))) > 0) {
                                for (l=0; l<in; l++) {
                                        printc(buf[l]);
                                        if (buf[l] == '\n')
                                                printc('\r');
                                }
                                sflush();
                        }
                        break;
                }
        }
}
 
 
void usage(char *s)
{
    if (s)
        fprintf(stderr, "error: %s\n", s);
    printf("usage: nxterm [-b] [-d] [-f <font family>] [-s <font size>]\n");
    printf("       [-g <geometry>] [-v] [-c] [-h] [program {args}]\n");
    exit(0);
}
 
 
void *mysignal(int signum, void *handler)
{
  struct sigaction sa, so;
 
  sa.sa_handler = handler;
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = SA_RESTART;
  sigaction(signum, &sa, &so);
 
  return so.sa_handler;
}
 
/*
 * guess what... :)
 */
 
int main(int argc, char **argv)
{
    GR_BITMAP   bitmap1fg[7];   /* mouse cursor */
    GR_BITMAP   bitmap1bg[7];
    GR_WM_PROPERTIES props;
 
    short xp, yp, fsize;
    char *family, *shell = NULL, *cptr, *geometry = NULL;
    struct passwd *pw;
    char buf[80];
    short uid;
    char thesh[128];
#ifdef __FreeBSD__
    char *ptr;
#endif
 
#ifdef SIGTTOU
    /* just in case we're started in the background */
    signal(SIGTTOU, SIG_IGN);
#endif
 
    /* who am I? */
    if (!(pw = getpwuid((uid = getuid()))))
    {
        fprintf(stderr, "error: wterm can't determine determine your login name\n");
        exit(-1);
    }
 
 
    if (GrOpen() < 0)
    {
        fprintf(stderr, "cannot open graphics\n");
        exit(1);
    }
 
    GrGetScreenInfo(&si);
    /*
     * scan arguments...
     */
 
    console = 0;
    argv++;
    while (*argv && **argv=='-')
        switch (*(*argv+1))
        {
        case 'b':
            cblink = 1;
            argv++;
            break;
 
        case 'c':
            console = 1;
            argv++;
            break;
 
        case 'd':
            debug = 1;
            argv++;
            break;
 
        case 'f':
            if (*++argv) {
                family = *argv++;
            } else {
                usage("-f option requires an argument");
            }
            break;
 
        case 's':
            if (*++argv) {
                fsize = atoi(*argv++);
            } else {
                usage("-s option requires an argument");
            }
            break;
 
        case 'g':
            if (*++argv) {
                geometry = *argv++;
            } else {
                usage("-g option requires an argument");
            }
            break;
 
        case 'h':
            /* this will never return */
            usage("");
 
        case 'v':
            visualbell = 1;
            argv++;
            break;
 
        default:
            usage("unknown option");
        }
 
    /*
     * now *argv either points to a program to start or is zero
     */
 
    if (*argv) {
        shell = *argv;
    }
    if (!shell) {
        shell = getenv("SHELL=");
    }
    if (!shell) {
        shell = pw->pw_shell;
    }
    if (!shell) {
        shell = "/bin/sh";
    }
 
    if (!*argv) {
        /*
         * the '-' makes the shell think it is a login shell,
         * we leave argv[0] alone if it isn`t a shell (ie.
         * the user specified the program to run as an argument
         * to wterm.
         */
        cptr = strrchr(shell, '/');
        sprintf (thesh, "-%s", cptr ? cptr + 1 : shell);
        *--argv = thesh;
    }
 
    col = 80;
    row = 25;
    xp = 0;
    yp = 0;
    if (geometry)
    {
        if (col < 1)
        {
            col = 80;
        }
        if (row < 1)
        {
            row = 25;
        }
        if (col > 0x7f)
            colmask = 0xffff;
        if (row > 0x7f)
            rowmask = 0xffff;
    }
 
    regFont=GrCreateFont(GR_FONT_SYSTEM_FIXED, 0, NULL);
    /*regFont=GrCreateFont(GR_FONT_OEM_FIXED, 0, NULL);*/
    /*boldFont=GrCreateFont(GR_FONT_SYSTEM_FIXED, 0, NULL);*/
    GrGetFontInfo(regFont, &fi);
 
    winw=col*fi.maxwidth;
    winh=row*fi.height;
    w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 10,10,winw, winh,0,BLACK,LTBLUE);
    props.flags = GR_WM_FLAGS_TITLE;
    props.title = TITLE;
    GrSetWMProperties(w1, &props);
 
    GrSelectEvents(w1, GR_EVENT_MASK_BUTTON_DOWN |
                   GR_EVENT_MASK_KEY_DOWN |
                   GR_EVENT_MASK_FOCUS_IN | GR_EVENT_MASK_FOCUS_OUT |
                   GR_EVENT_MASK_UPDATE | GR_EVENT_MASK_CLOSE_REQ);
 
    GrMapWindow(w1);
 
    gc1 = GrNewGC();
    GrSetGCFont(gc1, regFont);
 
#define _       ((unsigned) 0)          /* off bits */
#define X       ((unsigned) 1)          /* on bits */
#define MASK(a,b,c,d,e,f,g) \
        (((((((((((((a * 2) + b) * 2) + c) * 2) + d) * 2) \
        + e) * 2) + f) * 2) + g) << 9)
        bitmap1fg[0] = MASK(_,_,X,_,X,_,_);
        bitmap1fg[1] = MASK(_,_,_,X,_,_,_);
        bitmap1fg[2] = MASK(_,_,_,X,_,_,_);
        bitmap1fg[3] = MASK(_,_,_,X,_,_,_);
        bitmap1fg[4] = MASK(_,_,_,X,_,_,_);
        bitmap1fg[5] = MASK(_,_,_,X,_,_,_);
        bitmap1fg[6] = MASK(_,_,X,_,X,_,_);
 
        bitmap1bg[0] = MASK(_,X,X,X,X,X,_);
        bitmap1bg[1] = MASK(_,_,X,X,X,_,_);
        bitmap1bg[2] = MASK(_,_,X,X,X,_,_);
        bitmap1bg[3] = MASK(_,_,X,X,X,_,_);
        bitmap1bg[4] = MASK(_,_,X,X,X,_,_);
        bitmap1bg[5] = MASK(_,_,X,X,X,_,_);
        bitmap1bg[6] = MASK(_,X,X,X,X,X,_);
    GrSetCursor(w1, 7, 7, 3, 3, GREEN, BLACK, bitmap1fg, bitmap1bg);
    GrSetGCForeground(gc1, GREEN);
    GrSetGCBackground(gc1, BLACK);
    GrGetWindowInfo(w1,&wi);
    GrGetGCInfo(gc1,&gi);
 
    sprintf(buf, "wterm: %s", shell);
 
    /*
     * what kind of terminal do we want to emulate?
     */
#ifdef __FreeBSD__
    putenv ("TERM=wterm");
#else
    putenv ("TERM=vt52");
#endif
 
    /*
     * this one should enable us to get rid of an /etc/termcap entry for
     * both curses and ncurses, hopefully...
     */
 
    if (termcap_string)
    {
        sprintf (termcap_string + strlen (termcap_string), "li#%d:co#%d:",
                 row, col);
        putenv (termcap_string);
    }
    /* in case program absolutely needs terminfo entry, these 'should'
     * transmit the screen size of correctly (at least xterm sets these
     * and everything seems to work correctly...). Unlike putenv(),
     * setenv() allocates also the given string not just a pointer.
     */
    sprintf (buf, "%d", col);
    setenv ("COLUMNS", buf, 1);
    sprintf (buf, "%d", row);
    setenv ("LINES", buf, 1);
 
    init();
 
    /*
     * create a pty
     */
#ifdef __FreeBSD__
    winsz.ws_col = col;
    winsz.ws_row = row;
    if ((pid = forkpty(&pipeh, pty, NULL, &winsz)) < 0)
    {
        fprintf(stderr,"wterm: can't create pty\r\n");
        perror("wterm");
        sleep(2);
        GrKillWindow(w1);
        exit(-1);
    }
 
    if ((ptr = rindex(pty, '/')))
    {
        strcpy(pty, ptr + 1);
    }
 
    if (!pid)
    {
        int i;
        for (i = getdtablesize(); --i >= 3; )
            close (i);
        /*
         * SIG_IGN are not reset on exec()
         */
        for (i = NSIG; --i >= 0; )
            signal (i, SIG_DFL);
 
        /* caution: start shell with correct user id! */
        seteuid(getuid());
        setegid(getgid());
 
        /* this shall not return */
        execvp(shell, argv);
 
        /* oops? */
        fprintf(stderr,"wterm: can't start shell\r\n");
        sleep(3);
        GrKillWindow(w1);
        _exit(-1);
    }
#else
    pipeh = term_init();
#endif
 
/*    _write_utmp(pty, pw->pw_name, "", time(0)); */
 
#if 0
    /* catch some signals */
    mysignal(SIGTERM, sigquit);
    mysignal(SIGHUP, sigquit);
    mysignal(SIGINT, SIG_IGN);
    mysignal(SIGQUIT, sigquit);
    mysignal(SIGPIPE, sigpipe);
    mysignal(SIGCHLD, sigchld);
#endif
 
    /* prepare to catch console output */
    if (console)
    {
        /* for any OS chr$(7) might cause endless loops if
         * catched from console
         */
        visualbell = 1;
        console = 0;       /* data will come to normal pipe handle */
        ioctl(pipeh, TIOCCONS, 0);
    }
 
    term();
    return 0;
}
 
#if ELKS
char * nargv[2] = {"/bin/sash", NULL};
#else
#if DOS_DJGPP
char * nargv[2] = {"bash", NULL};
#else
char * nargv[2] = {"/bin/sh", NULL};
#endif
#endif
 
void sigchild(int signo)
{
        GrClose();
        exit(0);
}
 
int term_init()
{
        int tfd;
        int n = 0;
        pid_t pid;
        char pty_name[12];
 
again:
        sprintf(pty_name, "/dev/ptyp%d", n);
        if ((tfd = open(pty_name, O_RDWR | O_NONBLOCK)) < 0) {
                if ((errno == EBUSY || errno == EIO) && n < 10) {
                        n++;
                        goto again;
                }
                fprintf(stderr, "Can't create pty %s\n", pty_name);
                return -1;
        }
        signal(SIGCHLD, sigchild);
        signal(SIGINT, sigchild);
        if ((pid = fork()) == -1) {
                fprintf(stderr, "No processes\n");
                return -1;
        }
        if (!pid) {
                close(STDIN_FILENO);
                close(STDOUT_FILENO);
                close(tfd);
 
                setsid();
                pty_name[5] = 't';
                if ((tfd = open(pty_name, O_RDWR)) < 0) {
                        fprintf(stderr, "Child: Can't open pty %s\n", pty_name);
                        exit(1);
                }
                close(STDERR_FILENO);
                dup2(tfd, STDIN_FILENO);
                dup2(tfd, STDOUT_FILENO);
                dup2(tfd, STDERR_FILENO);
                execv(nargv[0], nargv);
                exit(1);
        }
        return tfd;
}
 
#if 0
void _write_utmp(char *line, char *user, char *host, int time)
{
    int fh, offset, isEmpty, isLine;
    struct utmp ut;
 
    if ((fh = open("/etc/utmp", O_RDWR)) < 0) {
        return;
    }
 
    /* first of all try to find an entry with the same line */
 
    offset = 0;
    isEmpty = -1;
    isLine = -1;
 
    while ((isLine < 0) && (read(fh, &ut, sizeof(ut)) == sizeof(ut))) {
        if (!ut.ut_line[0])
        {
            if (isEmpty < 0)
            {
                isEmpty = offset;
            }
        }
        else
        {
            if (!strncmp(ut.ut_line, line, sizeof(ut.ut_line))) {
                isLine = offset;
            }
        }
        offset += sizeof(ut);
    }
 
    if (isLine != -1) {
        /* we've found a match */
        lseek(fh, isLine, SEEK_SET);
    } else if (isEmpty != -1) {
        /* no match found, but at least an empty entry */
        lseek(fh, isLine, SEEK_SET);
    } else {
        /* not even an empty entry found, assume we can append to the file */
    }
 
    if (time)
    {
        strncpy(ut.ut_line, line, sizeof(ut.ut_line));
        strncpy(ut.ut_name, user, sizeof(ut.ut_name));
        strncpy(ut.ut_host, host, sizeof(ut.ut_host));
        ut.ut_time = time;
    }
    else
    {
        memset(&ut, 0, sizeof(ut));
    }
    write(fh, &ut, sizeof(ut));
    close(fh);
}
#endif
Browse

Tools

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [mw/] [src/] [demos/] [nanox/] [nxterm.c] - Blame information for rev 673

Line No.	Rev	Author	Line
1	673	markom	`/*`
2			`* nxterm - terminal emulator for Nano-X`
3			`*`
4			`* (C) 1994,95,96 by Torsten Scherer (TeSche)`
5			`* itschere@techfak.uni-bielefeld.de`
6			`*`
7			`* - quite some changes for W1R1`
8			`* - yet more changes for W1R2`
9			`*`
10			`* TeSche 01/96:`
11			`* - supports W_ICON & W_CLOSE`
12			`* - supports /etc/utmp logging for SunOS4 and Linux`
13			`* - supports catching of console output for SunOS4`
14			`* Phx 02-06/96:`
15			`* - supports NetBSD-Amiga`
16			`* Eero 11/97:`
17			`* - unsetenv(DISPLAY), setenv(LINES, COLUMNS).`
18			`* - Add new text modes (you need to use terminfo...).`
19			`* Eero 2/98:`
20			`* - Implemented fg/bgcolor setting. With monochrome server it changes`
21			`* bgmode variable, which tells in which mode to draw to screen`
22			`* (M_CLEAR/M_DRAW) and affects F_REVERSE settings.`
23			`* - Added a couple of checks.`
24			`*`
25			`* TODO:`
26			`* - Allocate and set sensible window palette for fg/bg color setting.`
27			`* - add scroll-region ('cs') command. Fairly many programs`
28			`* can take advantage of that.`
29			`* - Add xterm like mouse event to terminfo key event conversion... :)`
30			`* - check if current NetBSD really needs ifdefs below with`
31			`* current W server/library.`
32			`*/`
33			`#include <stdio.h>`
34			`#include <signal.h>`
35			`#include <sys/time.h>`
36			`#include <utmp.h>`
37			`#include <unistd.h>`
38			`#include <errno.h>`
39			`#include <stdlib.h>`
40			`#include <pwd.h>`