Subversion Repositories openrisc

/*
 * 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