/*
*    LOOK.C
*    User interface code for NCSA Telnet
****************************************************************************
*                                                                          *
*      NCSA Telnet for the PC                                              *
*      by Tim Krauskopf, VT100 by Gaige Paulsen, Tek by Aaron Contorer     *
*                                                                          *
*      National Center for Supercomputing Applications                     *
*      152 Computing Applications Building                                 *
*      605 E. Springfield Ave.                                             *
*      Champaign, IL  61820                                                *
*                                                                          *
*      This program is in the public domain.                               *
*                                                                          *
****************************************************************************
*   Revisions:
*   10/1/87  Initial source release, Tim Krauskopf
*   7/5/88   Version 2.2 Tim Krauskopf
*   5/8/89   Version 2.3 Heeren Pathak & Quincey Koziol
*   1/21/91  Version 2.3 Chris Wilson & Quincey Koziol
*   6/19/91  Version 2.3 - Linemode reworked - Jeff Wiedemeier
*/

//#define UM
#define WINMASTER
#define REALTIME

#ifndef NOTEK
#define USETEK
#endif
/* #define USERAS */
#define HTELNET 23
/*#define DEBUG*/


#ifndef USETEK
#define leavetek() 0
#endif

#ifdef MSC
#define mousecl mousecml
#endif

#ifdef __TURBOC__
#include "turboc.h"
#endif
#ifdef MOUSE
#include "mouse.h"
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <direct.h>
#include <time.h>
#include <conio.h>
#include <process.h>
#include <stdarg.h>
#include <bios.h>
#ifdef MSC
#include <malloc.h>
#endif
#ifdef CHECKNULL
#include <dos.h>
#endif

#include "whatami.h"
#include "nkeys.h"
#include "windat.h"
#include "hostform.h"
#include "protocol.h"
#include "data.h"
#include "confile.h"
#include "telopts.h"
#include "vidinfo.h"
#include "version.h"
#include "externs.h"

#include "map_out.h"

FILE *tekfp;
#ifdef MAL_DEBUG
FILE *mem_file;
#endif
FILE *console_fp;       /* file pointer for the console output when active */

//extern int default_mapoutput; /* Apparantly no longer used. */
extern int beep_notify;
extern int bypass_passwd;  /* flag to bypass the password check for ftp'ing back to our own machine */

long size,            /* size of buffer */
  cstart,             /* starting location of VS copy buffer */
  cend,               /* ending location of VS copy buffer */
  cdist,              /* distance to base point */
	temp;

int stand=0,          /* whether telnet is operating in 'standalone' mode (remains active when all sessions are closed) */
    sound_on=0,
    basetype=VTTYPE,
    ftpact=0,					/* ftp transfer is active */
    rcpact=0,					/* rcp transfer is active */
    viewmode=0,       /* What are we looking at? */
    prevmode=0,       /* What were we looking at? (before the help screen) */
    ftpok=1,					/* is file transfer enabled? */
    ftpwok=1,         /* incoming ftp */
    rcpok=1,					/* remote copying enabled? */
    scroll,           /* which way do we scrool */
    cflag=0,					/* are we copying ? */
    cbuf=0,						/* do we have things in the buffer? */
    mcflag,						/* mouse button flag */
    ginon=0,					/* the tektronics Graphics INput (GIN) mode flag */
    vsrow=0,					/* VS row */
    mighty,						/* mouse present? */
    temptek,					/* where drawings go by default */
    indev,outdev,     /* for copying tek images */
    rgdevice=0,       /* tektronix device to draw on */
    vton=1,
    capon=0,					/* overall capture on or not */
    foundbreak=0,     /* trap Ctrl-C */
    machparm=255,     /* the argument on the command line where the first machine is located */
    use_mouse=0,      /* use mouse for scrolling toggle */
    console_file_wanted=0,      /* should console be written to file ? */
    lpt_port=0;       /* port 0 == lpt1 (currently a hardwire) Also check out vsem.c */

int save_screen = TRUE;

unsigned char s[550],
    parsedat[256],
	path_name[_MAX_DRIVE+_MAX_DIR],		/* character storage for the path name */
    colors[NCOLORS]={4,2,0x70,0},       /* base colors */
	myipnum[4],
#ifdef CHECKNULL
    null_done=0,                /* flag to indicate that the null area has been snapshotted */
    nullbuf[1024],              /* buffer for debugging NULL overwrites */
#endif
    *copybuf=NULL,
    *lineend={"\r\n"},
    *blankline={"                                                                                       "};

unsigned int time_check=0;      /* variable to try to minimize the time spent checking the time */
time_t oldtime;					/* the last time the clock was updated */

long int lastt;

extern struct config def;		/* Default settings obtained from host file */

struct machinfo *mp=NULL;		/* Pointer to a machine information structure */

void CDECL (*attrptr)(int );    /* pointer to the routine to change the attribute of a character on the screen */

#define PSDUMP 128

#ifdef IP_ENHANCEMENTS					/* UNFINISHED message screen enhancements */
char *source_ip_num;					/* for error messages */
int port_num;               /* for error messages */
#endif

#define  USAGE   printf("\n\nUsage: telnet [-s] [-n] [-t] [-c color] [-h hostfile] [machinename] ...\n")

main(int argc,char *argv[])
{
    char temp_str[128];
    int i,j;
	char *config;

extern char keyboard_type;

    /* Check for CONFIG.TEL environment variable */
	config=(getenv("CONFIG.TEL"));
	if(config)
		Shostfile(config);

  /* work on parms */
  examineCommandLine(argc,argv);

  /* Initialize the video configuration, and retrieve it */
  initvideo();
  getvconfig(&tel_vid_info);
  getvstate(&tel_vid_state);

  if(save_screen)     /* save the screen if we are supposed to */
    init_text();

#ifdef __TURBOC__
	fnsplit(argv[0],path_name,s,temp_str,parsedat);		/* split the full path name of telbin.exe into it's components */
#else
	_splitpath(argv[0],path_name,s,temp_str,parsedat);	/* split the full path name of telbin.exe into it's components */
#endif
	strcat(path_name,s);	/* append the real path name to the drive specifier */

	install_keyboard();		/* determine what kind of keyboard this is */

  save_break();           /* preserve the status of the DOS BREAK setting */

  install_break((int *)&foundbreak);      /* install our BREAK handler */

  time(&oldtime);
#ifndef MOUSE
	mighty=initmouse();
#else
	mighty=nm_initmouse();
#endif
  n_clear();              /* do you know where your BP is? */
	n_cur(0,0);
  n_window(0,0,numline,79);   /* vt100 size */
	n_color(2);
  printf("%s, reading configuration file . . .\n",TEL_VERSION);

/*
* initialize the default keyboard settings
*/
#ifdef OLD_WAY /* Keyboard inits  rmg 931100 */
    if((j=initkbfile())<0) {    /* check for correct keyboard initialization */
        puts("Error reading default settings from keymap file.");
		getch();
    } /* end if */
#else
  memset(key_map_flags,0,1024);   /* initialize all the keyboard mapped flags to zero (not mapped) */
  memset(key_special_flags,0,1024); /* initialize all the keyboard special flags to zero (not special) */
#endif

  initoutputfile();   /* initialize the output mapping (to no mapping) */

/*
* initialize network stuff
*/
    if(j=Snetinit()) {  /* Read in the config.tel file and fire up the network */
		errhandle();
        printf("Error initializing network or getting configuration file\r\n");
		switch (j) {
			case -1:
                puts("Cannot initialize board.");
				break;

			case -5:
                puts("Error in config.tel file.");
				break;

			case -2:
                puts("RARP failed!!");
				break;

			case -3:
                puts("BOOTP failed!!");
				break;

			case -4:
                puts("X25 Initialization Failed!!");
				break;

			default:
                printf("Error from Snetinit()=%d\n",j);
				break;
          } /* end switch */
		if(j<-1)	/* network initialized, special case */
			netshut();
        remove_break();             /* restore the previous ctrl-c interupt handler */
        exit(1);
    }   /* end if */

#ifdef CHECKNULL
    /* Note: we snapshot the NULL area here, because some ethernet drivers modify the interrupt table when initialized */
    memcpy(nullbuf,MK_FP(0x0,0x0),1024);    /* make a copy of the NULL area */
    null_done=1;            /* set the flag for the NULL area */
#endif

    netgetip(myipnum);      /* what is my ip number? */
    Sgetconfig(&def);       /* get information provided in hosts file */

    ftpok=def.ftp;          /* what types of files transfers are allowed? */
    rcpok=def.rcp;
    ftpwok=def.ftpw;        /* Allow FTP writes? */
    for(i=0;i<3;i++)        /* set console colors to what's in config.tel */
      colors[i]=def.color[i];

    /* Check to see if we need to enter 43 or 50 line mode */
    if(def.ega43==1) {
		numline=41;
        ega43();
      } /* end if */
    else if(def.ega43==2) {
		numline=48;
        vga50();
      } /* end if */
	else {
		numline=23;				/***** NEED TO ADD SUPPORT FOR MODE CURRENT */
#ifndef AUX
    ega24();
#endif
	}

    n_window(0,0,numline,79);   /* vt100 size */

    if(def.cursortop!=-1 && def.cursorbottom!=-1)
		install_cursor((unsigned int)((def.cursortop<<8) | def.cursorbottom));

	if(Scmode())
		attrptr=n_attr;
	else
		attrptr=n_biosattr;

    n_clear();  /* clear the screen */

    for(i=0; i<NPORTS; i++)
		wins[i]=NULL;					/* we are using no window yet */

/*
* create console window for errors, informative messages, etc.
*/
    if(0>VSinit(NUM_WINDOWS))  {             /* initialize GPs virtual screens */
		n_puts("Virtual screen initialization failed.");
		exit(1);
    } /* end if */
    if(NULL==(console=creatwindow())) {
		n_puts("Console memory allocation failed");
		exit(1);
    }
    VSsetrgn(console->vs,0,0,79,numline);
    strcpy(console->mname,"Console");
/*
* introductions on the console window
*/
    i=console->vs;
    RSvis(-1);
    /* swapped around  rmg 931100 */
    //tprintf(i,"NCSA Telnet\r\n");
    vhead(i);
    tprintf(i,"\n\nConsole messages:\r\n");

#ifdef USETEK
/*
*  install tektronix
*/
	if(Stmode())
		tekinit(def.video);
#endif
#ifdef USERAS
	if(!VRinit())
        tprintf(i,"Error initializing raster support\r\n");
#endif
/*
*  Display my Ethernet (or Appletalk) and IP address for the curious people
*/
	pcgetaddr(&s[200],def.address,def.ioaddr);
    tprintf(console->vs,"My Ethernet address: %x:%x:%x:%x:%x:%x\r\n",s[200],s[201],s[202],s[203],s[204],s[205]);
    tprintf(console->vs,"My IP address: %d.%d.%d.%d\n\r\n",myipnum[0],myipnum[1],myipnum[2],myipnum[3]);

    Stask();                    /* any packets for me? (return ARPs) */
/*
*   With the parameters left on the command line, open a connection
*   to each machine named.  Start up all of the configuration on open
*   connections. 
*/
    for(i=machparm; i<argc; i++)
		addsess(argv[i]);

    if(current==NULL) {         /* special viewmode for server mode */
		current=console;		/* special enter sequence avoids flicker */
		viewmode=6;
      } /* end if */

    atexit(endall);             /* set the function to call when exitting */
    wrest(current);             /* paint the first session's screen */
    while(EXIT_TELNET!=dosessions());  /* serve all sessions, events */

    exit(0);
}   /* end main() */

void examineCommandLine(int argc, char *argv[])
{
    int i,j,size=0;

    for(i=1; i<argc; i++) {         /* look at each parm */
		if(*argv[i]=='-') {
			switch(*(argv[i]+1)) {
                case 'c':   /* set foreground color */
					i++;
					for(j=0; j<NCOLORS && *(argv[i]+j*2); j++)
						colors[j]=(unsigned char)hexbyte(argv[i]+j*2);
					break;

                case 'd':
					console_file_wanted=1;
                    console_fp=fopen("console.dmp","wb+");
#ifdef OLD_WAY
                    setbuf(console_fp,NULL);    /* unbuffer the console output */
#else
                    setvbuf(console_fp,NULL,_IONBF,0);
#endif
					break;

                case 'e':
                    if(commandLineOveride) {
                      size=strlen(commandLineOveride);
#ifdef AUX /* RMG */
fprintf(stdaux," commandLineOverride is on ");
#endif
                    }
                    commandLineOveride=(char *)realloc(commandLineOveride,strlen(commandLineOveride)+strlen(argv[++i])+3);
                    *(commandLineOveride+size)=(char)NULL;
                    strcat(commandLineOveride,argv[i]);
                    *(commandLineOveride+strlen(commandLineOveride)+1)=(char)NULL;
                    *(commandLineOveride+strlen(commandLineOveride))=';';
                    break;

                case 'n':   /* disable screen restore */
                    save_screen = FALSE;
                    break;

                case 's':   /* set standalone/server flag */
					stand=1;
					break;

                case 't':   /*  Disable direct writes to screen  */
					Scwritemode(0);
					break;

                case 'h':   /* set new name for host file */
                    Shostfile(argv[++i]);   
					break;

                case '?':   /* help screen */
				default:
					USAGE;
                    printf("\n\n -c 172471    sets the basic color scheme for console screen\n");
                    printf(" -h file      full path specification of host information file\n");
                    printf(" -s           standalone (server) mode for rcp and ftp\n");
                    printf(" -t           disable direct writes to screen\n");
                    printf(" -n           disable screen restore\n");
                    exit(1);
              } /* end switch() */
          } /* end if */
		else {
            machparm=i;         /* where first machine name is */
            break;
          } /* end else */
      } /* end for */
}   /* end examineCommandLine() */

/************************************************************************/
/* vhead
*  place the header for new sessions in.
*/
void vhead(int v)
{
    tprintf(v,"\r\nNational Center for Supercomputing Applications\r\n");
    tprintf(v,"%s for the PC\r\n",TEL_VERSION);
    tprintf(v,"\nAlt-H presents a summary of special keys \n\r\n");
}   /* end vhead() */

/************************************************************************/
/*  dosessions
*   dosessions is an infinite loop serving three sources of external
*   input in order of precedence:
*   - changes to the video display properties
*   - keyboard strokes
*   - network events
*
*   What the user sees is top priority followed by servicing the keyboard
*   and when there is time left over, looks for network events.
*
*   viewmode is a state variable which can determine if the screen should
*   be re-drawn, etc.
*/
int dosessions(void)
{
    static int scroll_row,scroll_col;   /* the row and column saved while in scroll back */
	time_t newtime;					/* variable to hold the new time for the clock */
	int clock_row,clock_col,		/* the row and column saved while updating the clock */
        i=0,j,ch,
        c,                          /* the color saved */
		cl,dat,cvs;
#ifdef BEFORE_GIN_FIX
    int m1,m2,m3,m4;        /* mouse variables */
#else
    int m1,m2,m3,m4,m3a,m4a;        /* mouse variables */
#endif
    int x1,x2,y1,y2;        /* temp variables for VSgetrgn test when exiting scrlback mode */
  unsigned int sw;
#ifdef BEFORE_GIN_FIX
  char gindata[5];    /* variable to store gin data in when returning fron VGgindata */
#else
  char gindata[6];    /* variable to store gin data in when returning fron VGgindata */
#endif
	struct twin *t1;
	static char lch=-1;
    char *p=NULL;
#ifdef CHECKNULL
    static unsigned int null_check=0;        /* don't try to check NULL every time */

/* If we are running in NULL debugging mode, check that */
    if(++null_check%8==0)
        check_null_area();
#endif

#ifdef USETEK
    if(ginon && current->termstate==TEKTYPE) { /* check for GIN mode for tektronics */
#ifdef BEFORE_GIN_FIX
      ch=n_chkchar();
      m1=3;
      m2=0;
      m3=0;
      m4=0;        /* mouse variables */
      mousecl(&m1,&m2,&m3,&m4);
      if((ch!=(-1)) || (m2&1)) {
        if((ch!='\r') && (ch!='\n') && (ch>0))
          lch=(char)ch;
        if((lch!=(-1)) && (m2&1)) {
          VGgindata(current->vs,m3,m4,lch,gindata);

#else /* this is gin_fix stuff */
      do {
        ch=kbhit();
        m1=3;
        m2=0;
        m3=0;
        m4=0;        /* mouse variables */
        mousecl(&m1,&m2,&m3,&m4);
      } while ((ch == 0) && (m2 == 0));  /* loop until mouse button or key pressed */

      if(ch==0)
        lch=(char)' ';  /* Mouse button pressed - return space */
      else
        lch=(char)getch();

    /* RMG ??? 940103 */
      if(ch==0)
        do {
          m1=3;
          m2=0;
          m3a=0;
          m4a=0;
          mousecl(&m1,&m2,&m3a,&m4a);
        } while (m2 != 0);  /*hold until mouse button released */

      VGgindata(current->vs,m3,m4,lch,gindata);       /* send the mouse cursor */
                                                      /* position to be translated */
                                                      /* by VGgindata with the */
                                                      /* information returned */
                                                      /* in gindata */
      gindata[5]='\r';                                /* add new-line char */
#endif /* before_gin_fix */

      RSsendstring(current->vs,gindata,6);    /* return GIN data across network */
      vt100key(0);

      lch=-1;                 /* clear last char buffer */
      resetgin();               /* reset GIN mode */
#ifdef BEFORE_GIN_FIX
              } /* end if */
          } /* end if */
#endif
    } /* end if */
#endif /* usetek */

	switch(viewmode) {
		case 0:					/* no special mode, just check scroll lock */
		default:
			if(n_scrlck()) {	/* scroll lock prevents text from printing */
				viewmode=1;
				vsrow=0;
				cstart=0;
				cend=0;
				cflag=0;
				cbuf=0;
				mcflag=0;
				scroll_row=n_row();
				scroll_col=n_col();
				c=n_color(current->colors[1]);
				n_cur(numline+1,61);
				n_draw("Scrl",4);	/* status in lower left */
				n_color(c);
				n_cur(scroll_row,scroll_col);
              } /* end if */
/*
*  This gives precedence to the keyboard over the network.
*/
            if((ginon) && (current->termstate==TEKTYPE))
                break;
            while(0<=(c=newkey(current)))   /* do all key translations */
				if(c==EXIT_TELNET)
          return(EXIT_TELNET);
			break;			/* no special viewing characterisitics */

		case 1:						/* scrollock is active */
			if(!n_scrlck()) {
				VSgetrgn(current->vs,&x1,&y1,&x2,&y2);
        if(y1!=0)
          VSsetrgn(current->vs,0,0,79,numline);
				viewmode=0;			/* set back if appropriate */
        if(y1==0)
          wrest(current);
				scroll=0;
				statline();
				n_cur(scroll_row,scroll_col);
      } /* end if */
/* 
*  In scroll lock mode, take keys only for the scrollback, 
*  The scrollback routine will never block, so we keep servicing events.
*/
      scrollback(current);
			break;

		case 2:						/* console is visible */
			if(n_scrlck()) {	/* scroll lock prevents text from printing */
				viewmode=13;
				vsrow=0;
				cstart=0;
				cend=0;
				cflag=0;
				cbuf=0;
				mcflag=0;
				scroll_row=n_row();
				scroll_col=n_col();
				c=n_color(console->colors[1]);
				n_cur(numline+1,61);
				n_draw("Scrl",4);	/* status in lower left */
				n_color(c);
				n_cur(scroll_row,scroll_col);
              } /* end if */
            if(0<n_chkchar())
				viewmode=10;	
			break;

		case 3:						/* help screen view1 */
		case 4:						/* help screen view2 */
			while(0<=(c=n_chkchar())) {	
				if(c==EXIT_TELNET)
					return(EXIT_TELNET);
				if(viewmode==3 && c==27) {
					viewmode=4;
          help2();
        } /* end if */
				else { 	 			/* restore view 0 */
          if(c==' ')
            viewmode=10;
#ifdef NOT /* rmg 931122 */
          else
            if(c>128)
              dokey(current,c); /* dokey might change view, if so, don't reset view 0 */
#endif
        } /* end else */
      } /* end while */
			break;

		case 5:						/* DOS screen view */
			viewmode=9;				/* wait for keypress */
			break;

		case 6:						/* server mode */
      statline();
      tprintf(console->vs,"\r\nServer mode, press ESC to exit or ALT-A to begin a session\r\n");
			viewmode=7;

		case 7:						/* server mode 2 */
			j=n_chkchar();
			switch(j) {
				case 27:
          tprintf(console->vs,"\n\r\n Ending server mode \r\n");
					return(EXIT_TELNET);	/* leave the program */

				case ALTA:
          if(!addsess(NULL))   /* start up a new one */
						viewmode=10;
          else {
						current=console;
						viewmode=6;
          } /* end else */
					break;

        case ALTE:      /* shell to dos */
					leavetek();
					n_window(0,0,numline+1,79);
					i=n_color(current->colors[0]);
					dosescape();
					wrest(console);
					viewmode=7;
					n_color(i);
					break;

        case ALTH:      /* help display (added to console window)  rmg 931100 */
          leavetek();
          prevmode=7;
          viewmode=3;
          helpmsg();
          break;

#ifdef FTP
        /* modified ALTW to query  rmg 931100 */
        case ALTW:        /* send our password to the machine we are connected to, for use in ftp'ing back to oneself */
          leavetek();
          if(bypass_passwd) {
            n_puts("\n OK then, we won't bypass the next FTP password after all.");
            bypass_passwd=0;
          }
          else {
            n_puts("\n Are you sure you want to bypass the FTP password once? Y/N");
            c=nbgetch();        /* get the answer */
            if(tolower(c)=='y') {
              n_puts("\n The next FTP connection will accept any password and give root access.");
              bypass_passwd=1;  /* set the flag to bypass the password check */
            } /* end if */
          }
          n_puts("\n Press any key to return");
          c=nbgetch();        /* get the answer */
          wrest(console);
          viewmode=7;      /* redraw screen */
          break;
#endif

				case -1:
					break;		/* no keypress */

				default:
          tprintf(console->vs,"\r\nYou must have an open session to use other commands.\r\n");
					viewmode=6;
					break;
      } /* end switch */
			break;

#ifdef USETEK
		case 8:
			if(graphit())				/* graphics menu screen */
				viewmode=10;
			break;
#endif

		case 9:							/* reset current screen on keypress */
			if(0<n_chkchar())
				viewmode=10;	
			break;

		case 10:						/* Display current screen */
			wrest(current);
			viewmode=0;					/* return to standard mode */
      /* for help screen in server window  rmg 931100 */
      if(prevmode==7) {
        viewmode=prevmode;
        prevmode=0;
      }
//      statline();
			break;

		case 11:						/* paste copy buffer to current session */
			temp-=netwrite(current->pnum,(char *)&copybuf[(int)(size-temp)],(int)temp);
			if(!temp)
				viewmode=0;
			break;

		case 13:
			if(!n_scrlck()) {
				VSsetrgn(current->vs,0,0,79,numline);
				viewmode=2;			/* set back if appropriate */
				scroll=0;
				wrest(console);
				statline();
				n_cur(scroll_row,scroll_col);
              } /* end if */
/* 
*  In scroll lock mode, take keys only for the scrollback, 
*  The scrollback routine will never block, so we keep servicing events.
*/
			scrollback(console);
			break;
      } /* end switch */

/*
*  Check for any relevant events that need to be handled by me
*/
	if(0<(i=Sgetevent(USERCLASS | CONCLASS | ERRCLASS, &cl, &dat))) {
		sw=cl*256+i;				/* class and event combination */
		cvs=console->vs;
		switch(sw) {
			case CONCLASS*256+CONOPEN:	/* a connection has just opened */
			    t1=wins[dat];			/* where the window pointer is stored */
				if(!t1)
					break;

				t1->sstat='/';			/* connection status */
				netpush(dat);

				/* Start negotiation on network */
                start_negotiation(t1,cvs);

				if(current!=t1) {
					current=t1;
					viewmode=10;
				  }
				break;

			case CONCLASS*256+CONCLOSE:	/* connection is closing */
				if(0<netqlen(dat))
					netputuev(CONCLASS,CONCLOSE,dat);  /* call me again */
					/* drop through, process any data */

			case CONCLASS*256+CONDATA:
				if(viewmode) {			/* not ready for it */
					netputuev(CONCLASS,CONDATA,dat);
					break;
				  }
			    t1=wins[dat];			/* where the window pointer is stored */
				if(!t1)
					break;

				if(inprocess(t1))
					return(EXIT_TELNET);
				break;

			case CONCLASS*256+CONFAIL:	/* can't open connection */
			    t1=wins[dat];			/* where the window pointer is stored */
				if(!t1)
					break;				/* this don't count */
                tprintf(cvs,"\r\nCan't open connection, timed out\r\n");
				netclose(dat);			/* close out attempt */
				if(!t1->next) {
					wrest(console);
					return(EXIT_TELNET);
				  }
				if(t1==current) {
					current=current->next;
					viewmode=10;
				  }
				delwindow(t1,1);
				statline();
				break;

/*
*  domain nameserver results.
*/
			case USERCLASS*256+DOMFAIL:			/* domain failed */
				mp=Slooknum(dat);				/* get machine info */
        tprintf(cvs,"\r\nDOMAIN lookup failed for: ");
				if(mp && mp->hname)
          tprintf(cvs,"%s\r\n",mp->hname);
				else 
					if(mp && mp->sname)
            tprintf(cvs,"%s\r\n",mp->sname);
				break;

			case USERCLASS*256+DOMOK:
				mp=Slooknum(dat);				/* get machine info */
				if(mp) {
          tprintf(cvs,"\r\nDOMAIN lookup OK for: ");   /* print session name and host name */
					if(mp->hname)
            tprintf(cvs,mp->hname);
					if(mp->sname) {
            tprintf(cvs," - %s",mp->sname);
						if(mp->port!=HTELNET) {
							char *s;

							if((s=(char *) malloc(strlen(mp->sname) + 6))!=NULL) {
								sprintf(s,"%s#%d",mp->sname,mp->port);
								mp->port=HTELNET;
								addsess(s);
								free(s);
							  }	/* end if */
						  }	/* end if */
						else
							addsess(mp->sname);
					  }
					else
						if(mp->port!=HTELNET) {
							char *s;

							if((s=(char *) malloc(strlen(mp->hname) + 6))!=NULL) {
								sprintf(s,"%s#%d",mp->hname,mp->port);
								mp->port=HTELNET;
								addsess(s);
								free(s);
							  }	/* end if */
						  }
						else
							addsess(mp->hname);
              tprintf(console->vs,"\r\nDomain Port is:%d\r\n",mp->port);
					viewmode=10;
				  }
				break;

/*
*  FTP status events.
*/
#ifdef FTP
			case USERCLASS*256+FTPBEGIN:		/* data connection */
                {
                    unsigned char host[4];

                    ftpact=dat;
                    Sftpname(s);                    /* get name */
                    Sftphost(host);
                    if (SftpDirection())
                        tprintf(cvs,"FTP: RECEIVING %s from host ", s);
                    else
                        tprintf(cvs,"FTP: SENDING %s to host ", s);
                    if((NULL==(mp=Slookip(host))) || (NULL==mp->sname))
                        tprintf(cvs,"%d.%d.%d.%d\r\n",host[0],host[1],host[2],host[3]);
                    else
                        tprintf(cvs,"%s\r\n",mp->sname);
                    ftpstart((char)(ftpact+2),s);
                    lastt=n_clicks();
                    break;
                }

			case USERCLASS*256+FTPLIST:			/* LIST or NLST */
        tprintf(cvs,"FTP directory beginning\r\n");
				break;

			case USERCLASS*256+FTPEND:			/* data connection ending */
				ftpact=0;
				statline();
        tprintf(cvs,"FTP transfer done\r\n");
				break;

			case USERCLASS*256+FTPCOPEN:		/* command connection */
        tprintf(cvs,"FTP server initiated from host: ");
				Sftphost(s);
				if((NULL==(mp=Slookip(s))) || (NULL==mp->sname)) 
                    tprintf(cvs,"%d.%d.%d.%d\r\n",s[0],s[1],s[2],s[3]);
				else
                    tprintf(cvs,"%s\r\n",mp->sname);
				break;

			case USERCLASS*256+FTPUSER:			/* user name entered */
                tprintf(cvs,"FTP user ");
        Sftpuser(s);
                tprintf(cvs,">> %s << login request\r\n",s);
				break;

      case USERCLASS*256+FTPANON:     /* passwordless user name entered */
                tprintf(cvs,"FTP user ");
				Sftpuser(s);
        Sftppass(parsedat);
                tprintf(cvs,">ANON< login request as: %s passwd: >> %s <<\r\n",s,parsedat);  /* parsedat is a rarely used global string */
				break;

      case USERCLASS*256+FTPPWOK:     /* user password verified */
                tprintf(cvs,"FTP Password verified\r\n");
				break;

      case USERCLASS*256+FTPPWSK1:     /* user password verified */
                tprintf(cvs,"FTP Password Skipped (no password file)\r\n");
				break;

      case USERCLASS*256+FTPPWSK2:     /* user password verified */
                tprintf(cvs,"FTP Password Skipped with Alt-W\r\n");
				break;

      case USERCLASS*256+FTPPWWT:     /* user password verified */
                tprintf(cvs,"FTP Password includes Write access\r\n");
				break;

      case USERCLASS*256+FTPPWRT:     /* user password verified */
                tprintf(cvs,"FTP Root access gained\r\n");
				break;

      case USERCLASS*256+FTPPWNO:     /* user password failed */
                tprintf(cvs,"FTP Password failed verification\r\n");
				break;

			case USERCLASS*256+FTPCLOSE:		/* command connection ends */
                tprintf(cvs,"FTP server ending session\r\n");
				break;
#endif

#ifdef RCP
			case USERCLASS*256+RCPBEGIN:		/* rcp starting */
                tprintf(cvs,"rcp file transfer\r\n");
				rcpact=1;
				break;

			case USERCLASS*256+RCPEND:			/* rcp ending */
                tprintf(cvs,"rcp ending\r\n");
				rcpact=0;
				break;
#endif

#ifdef USETEK
			case USERCLASS*256+PSDUMP:			/* dump graphics screen */
				if(VGpred(indev,outdev)) {
					if(dat) {
						endump();
                        tprintf(cvs,"Graphics writing finished\r\n");
						wrest(console);
						viewmode=2;
					  }
				  }
				else
					netputevent(USERCLASS,PSDUMP,dat);	/* remind myself */
				break;

#endif

      case ERRCLASS*256+ERR1:                     /* error message */
				p=neterrstring(dat);
				VSwrite(cvs,p,strlen(p));
                VSwrite(cvs,"\r\n",2);
                if(dat==407)
                    inv_port_err(0,0,NULL);

            default:
				break;
          } /* end switch */
      } /* end if */
/*
*	update the FTP spinner if we are in ftp, and update the clock
*/
	else {
#ifdef FTP
		if(ftpact && (n_clicks()>lastt + 10)) {
			ftpstart((char)(ftpact+2),s);
			lastt=n_clicks();
    }
#endif
		if(def.clock) {
      if((++time_check%4)==0 && (current->termstate<TEKTYPE) && (!ftpact)) { /* only check the time every four calls to dosessions to try to minimize the timer impact */
				time(&newtime);
				if(oldtime!=newtime) {
					strcpy(s,ctime(&newtime));
					clock_row=n_row();
					clock_col=n_col();
					c=n_color(current->colors[0]);
					n_cur(numline+1,72);
					set_cur(0);
					if(Scmode())	  /* check which screen writing mode to use */
						n_cheat(&s[11],9);
					else
						n_draw(&s[11],9);
					n_cur(clock_row,clock_col);
					n_color(c);
					oldtime=newtime;
					set_cur(1);
        } /* end if */
      } /* end if */
    } /* end if */
#ifdef NOT /* cRMG */
    if(scrolllocked) {
      ;
    }
#endif
  } /* end else */
	return(c);
}   /* end dosessions() */

/*********************************************************************/
/* inprocess
*  take incoming data and process it.  Close the connection if it
*  is the end of the connection.
*/
int inprocess(struct twin *tw)
{
	int cnt;

	cnt=netread(tw->pnum,s,200);	/* get some from incoming queue */
	if(cnt<0) {					/* close this session, if over */
		netclose(tw->pnum);

		if(tw->capon) {
			fclose(tw->capfp);		/* close the capture file */
			tw->capon=capon=0;
		  }
		n_color(tw->colors[0]);
		if(tw->next==NULL) 		/* if this is the last one */
			if(stand) {
				wins[tw->pnum]=NULL;
				freewin(tw);
				current=console;
				viewmode=6;
				wrest(current);
				return(0);
			  }	/* end if */
			else
				return(-1);		/* signal no sessions open */

#ifdef USETEK
		leavetek();					/* make Tek inactive */
#endif
		if(tw!=current)
			wrest(tw);

		if(!def.wingoaway)		/* check whether the window just goes away, or sticks around for a keypress */
			n_puts("\nConnection closed, press a key . . .");
		if(tw==current)
			current=tw->next;
		delwindow(tw,1);
		if(!def.wingoaway)		/* check whether the window just goes away, or sticks around for a keypress */
			viewmode=9;
		else
			viewmode=10;
		return(0);
      } /* end if */

    if(cnt)
        parse(tw,s,cnt);    /* display on screen, etc.*/
	return(0);
}   /* end inprocess() */

/*********************************************************************/
/* endall
*  clean up and leave
*/
void endall(void )
{
    netshut();      /* close down the network */

	n_cur(numline+1,0);			/* go to bottom of screen */
	n_color(7);
	n_draw(blankline,80);		/* blank it out */
	if(def.ega43>0)				/* restore screen */
		ega24();

	remove_break();				/* restore the previous ctrl-c interupt handler */
	restore_break();			/* restore the BREAK status */
    setvstate(&tel_vid_state);  /* restore the video state */
    if(save_screen)     /* is we saved the screen, restore it */
        end_text();
    if(console_file_wanted) /* is we were debugging the console, close the file */
        fclose(console_fp);
}   /* end endall() */

/*********************************************************************/
/*  errhandle
*   write error messages to the console window
*/
void errhandle(void )
{
	char *errmsg;
	int i,j;

	while(ERR1==Sgetevent(ERRCLASS,&i,&j)) {
		errmsg=neterrstring(j);
        tprintf(console->vs,"%s\r\n",errmsg);
        if(j==407)
			inv_port_err(0,0,NULL);
      } /* end while */
}   /* end errhandle() */

/*********************************************************************/
/*  vprint
*   print to a virtual screen
*/
void vprint(int w,char *str)
{
#ifdef CONSOLEDEBUG
	VSwrite(current->vs,str,strlen(str));		/* dump all messages to the current screen */
#else
    if(w==console->vs && console_file_wanted)
        fputs(str,console_fp);
    VSwrite(w,str,strlen(str));
#endif
}   /* vprint() */

/*********************************************************************/
/*  tprintf
*	print a formatted string to a virtual screen
*/
int tprintf(int w,char *fmt,...)
{
    char temp_str[256];     /* this may be a problem, if the string is too long */
    va_list arg_ptr;
    int str_len;            /* length of the formatted string */

	va_start(arg_ptr,fmt);		/* get a pointer to the variable arguement list */
    str_len=vsprintf(temp_str,fmt,arg_ptr); /* print the formatted string into a buffer */
	va_end(arg_ptr);
    if(str_len>0) {
        if(w==console->vs) {    /* write stuff to the console screen without going through the overhead of looking through the string for VT100 escape codes */
            if(console_file_wanted) {
                fputs(temp_str,console_fp);
                fflush(console_fp);
              } /* end if */
            VSdirectwrite(w,temp_str,str_len);
          } /* end if */
        else
#ifdef CONSOLEDEBUG
            VSwrite(current->vs,temp_str,str_len);     /* dump all messages to the current screen */
#else
            VSwrite(w,temp_str,str_len);
#endif
      } /* end if */
    return(str_len);
}   /* tprintf() */

/*********************************************************************/
/*  parsewrite
*   write out some chars from parse
*   Has a choice of where to send the stuff
*/
void parsewrite(struct twin *tw,char *dat,int len)
{
    char localdata[32];      /* local data for strings */
	int i;
/*
*  send the string where it belongs
*  1. Check for a capture file.  If so, echo a copy of the string
*  2. Check for dumb terminal type, convert special chars if so
*  3. Check for Tektronix mode, sending Tek stuff
*  3b. check for raster color type
*  4. or, send to virtual screen anyway
*/

#ifdef UM  /* #define UM statement at top of file is commented out */
	if (localprint) {
    for(i=0; i<len-3; i++) {
      if ((dat[i]==27)&&(dat[i+1]=='[')&&(dat[i+2]=='4')&&(dat[i+3]=='i')) {
        localprint=0;
      }
		}
		if (localprint)
			for(i=0; i<len; i++)
#ifdef MSC
        _bios_printer(_PRINTER_WRITE,lpt_port,dat[i]);
#elif __TURBOC__
				biosprint(0,ptr[i],0);
#endif
	}
#endif
	if(tw->capon)						/* capture to file? */
		fwrite(dat,len,1,tw->capfp);
/*
* raw mode for debugging, passes through escape sequences and other
* special characters as <27> symbols
*/
	if(tw->termstate==DUMBTYPE) {
		for (i=0; i<len; i++, dat++) 
			if(*dat==27 || *dat>126) {
                sprintf(localdata,"<%d>",*dat);
                VSwrite(tw->vs,localdata,strlen(localdata));
			  }
			else
				VSwrite(tw->vs,dat,1);
	  }
	else {
#ifdef USETEK
		if(tw->termstate==TEKTYPE) {
			i=VGwrite(temptek,dat,len);
			if(i<len) {
				leavetek();
				viewmode=10;
				parsewrite(tw,dat+i,len-i);
			  }
		  }				
		else 
#endif
#ifdef USERAS
			if(tw->termstate==RASTYPE) {
				i=VRwrite(dat,len);
				if(i<len) {
					tw->termstate=VTEKTYPE;
					parsewrite(tw,dat+i,len-i);
				  }
			  }
			else
#endif
        VSwrite(tw->vs,dat,len);  /* send to virtual VT102 */

	  }	/* end else */
}   /* end parsewrite() */

/*********************************************************************/
/* newkey
*  filter for command key sequences
*/
int newkey(struct twin *t1)
{
	int c;

	if(foundbreak) {
		foundbreak=0;
        c='\003';       /* ctrl-c */
        if(t1->lmflag) {       /* Telnet line mode is on */
            if(LMinterp_char(t1,c)) /* check if this character is a special line mode character */
                c=0;    /* don't want ^C on beginning of next line */
        } /* end if */
      } /* end if */
    else {
        if(ginon)
            c=0;
        else {
            if(t1->lmedit) {       /* Telnet line mode editting is on */
                c=LMgets(t1);
                if(c>0) {       /* check for an actual character */
#ifdef QAK
tprintf(console->vs,"Linemode on, c=%d, t1->linemode=%s\r\n",(int)c,t1->linemode);
#endif
                    if(LMinterp_char(t1,c))  /* check for a special line mode character */
                        c=0;    /* we handled this character */
                    else {  /* linemode routines didn't interpret this character */
                        if(t1->linemode[0]) {
#ifdef QAK
tprintf(console->vs,"c=%d, t1->linemode=%s\r\n",(int)c,t1->linemode);
#endif
                            netpush(t1->pnum);
                            netwrite(t1->pnum,t1->linemode,strlen(t1->linemode));
                            t1->linemode[0]='\0';
                          } /* end if */
                      } /* end else */
                  } /* end if */
              } /* end if */
            else {      /* no linemode */
                if(t1->echo)
                    c=n_chkchar();          /* a char available ? */
                else {
                    if(t1->halfdup) {       /* half duplex */
                        c=n_chkchar();
                        if(c==13) {
                            parse(t1,"\r\n",2); /* echo crlf */
                            vt100key(13);
                            c=10;
                          } /* end if */
                        else
                            if(c>0 && c<128)
                                parse(t1,(char *)&c,1);     /* echo char */
                      } /* end if */
                    else {                      /* kludge linemode */
                        c=RSgets(t1->vs,t1->linemode,79,1);
                        if(c==13) {         /* pressed return */
                            parse(t1,"\r\n",2);     /* echo the return */
                            strcat(t1->linemode,"\r\n");
                            netpush(t1->pnum);
                            netwrite(t1->pnum,t1->linemode,strlen(t1->linemode));
                            t1->linemode[0]='\0';
                            c=0;
                          } /* end if */
                        else {
                            if(c>0) {       /* write string, pass c to command interp */
                                if(t1->linemode[0]) {
                                    netpush(t1->pnum);
                                    netwrite(t1->pnum,t1->linemode,strlen(t1->linemode));
                                    t1->linemode[0]='\0';
                                  } /* end if */
                              } /* end if */
                          } /* end else */
                      } /* end else */
                  } /* end else */
#ifdef QAK
if(c!=(-1))
    tprintf(console->vs,"c=%u:%x\r\n",(unsigned int)c,(unsigned int)c);
#endif
              } /* end else */
          } /* end else */
      } /* end else */

	if(c<=0)
		return(c);
	return(dokey(t1,c));
}   /* end newkey() */

/************************************************************************/
/*  screendump
*   dump the contents of the current screen into the capture file
*
*/
void screendump(struct twin *t1,int whole_scrollback)
{
	int y,			/* variable to count the line of the screen we are dumping */
        line_num,   /* the number of lines to dump */
		len;		/* the length of the line with trailing blanks eliminated */
	unsigned char *c,*d;	/* temporary pointers into the text for a line */

	if(t1->capfp) {		/* make certain the file is open */
        if(VSvalids(t1->vs))    /* make certain there is a virtual screen to dump */
			return;
		capstat("Dump",1);
        if(whole_scrollback)        /* check if we want to dump the entire scroll scrollback */
            line_num=VSIw->lines;
        else
            line_num=numline+1;
        for(y=0; y<line_num; y++) {    /* dump each line */
			c=&VSIw->linest[y]->text[0];	/* get the address of the text line */
			d=c+VSIw->allwidth;			/* allwidth =79 for an 80 width window */
			while((*d==' ' || *d==0) && d>c)		/* don't print trailing blanks */
				d--;
			len=d-c+1;
            fprintf(t1->capfp,"%*.*s\r\n",len,len,c);   /* store the line */
		  }	/* end for */
        fprintf(t1->capfp,"\f");    /* print formfeed */
    statline();   /* re-print the statline */
	  }	/* end if */
}	/* end screendump() */

/************************************************************************/
/*  dokey
*   translates and sends keys and filters for command keys
*
*/
int dokey(struct twin *t1,int c)
{
	int i;

#ifdef QAK
tprintf(console->vs,"t1=%p, c=%d\n",t1,c);
#endif
    switch(c) {
		case BACKSPACE:		/* backspace */
			c=t1->bksp;		/* allows auto del instead of bs */
			break;

		case 13:			/* different CR mappings */
                  /*   even more different now - rmg 931100 */
      if(!t1->crfollow) {   /* most common case avoids switch statemant */
        vt100key(13);
        vt100key(10);
      }
      else {
        switch(t1->crfollow) {
          case 1:
            vt100key(13);
            break;
          case 2:
            vt100key(10);
            break;
          case 3:
            vt100key(13);
            vt100key(0);
            break;
        }
      }
			c=0;
			break;

		case 127:
			c=t1->del;		/* switch bs around, too */
			break;

		case THENUL:		/* user wants the true NUL char */
			c=0;
			netwrite(t1->pnum,(char *)&c,1);	/* write a NUL */
			break;

#ifdef USETEK
		case CTRLHOME:		/* tek clear screen */
		case E_CTRLHOME:	/* tek clear screen */
			if(def.tek) {	/* check whether we are allowed to go into tek mode */
                if(current->termstate!=TEKTYPE) {
					current->termstate=TEKTYPE;
					VGgmode(rgdevice);
					VGuncover(temptek);
                }
                VGwrite(temptek,"\033\014",2);  /* clear storage and screen */
				c=0;
			  }	/* end if */
			break;

		case HOME:			/* clear to text */
		case E_HOME:		/* clear to text */
			if(def.tek) {	/* check whether tektronix is enabled */
				if(leavetek()) {
					viewmode=10;
					c=0;
				  }
			  }	/* end if */
			break;
#endif

    case ALTA:        /* add session */
			c=0;
			if(0>addsess(NULL)) {		/* start up a new one */
        tprintf(console->vs,"\r\nPress any key to continue . . .");
				viewmode=9;
      }
			else
				viewmode=10;
			break;

		case ALTB:						/* session switch backwards */
			c=0;
			leavetek();
			if(current->prev==NULL)   /* are we only one ? */
				break;
			current=current->prev;
			viewmode=10;
			break;

		case ALTC:							/* toggle capture */
			if(capon && current->capon) {	/* already on */
				capstat("    ",0);
				fclose(current->capfp);		/* close the capture file */
				current->capon=capon=0;
			  }	/* end if */
			else 
				if(!capon) {				/* I want one */
					if(NULL==(current->capfp=Sopencap())) {
                        tprintf(console->vs,"\r\nCannot open capture file ");
						break;
					  }	/* end if */
					capstat("Capt",1);
					current->capon=capon=1;
				  }	/* end if */
				else {
                    tprintf(console->vs,"\r\nAnother session has capture file open, cannot open two at once\r\n");
					wrest(console);
					viewmode=2;
				  }	/* end else */
			c=0;
			break;

		case ALTD:		/* dump screen to capture file */
			c=0;
			if(!capon) {	/* if the capture file is not already open */
                if((current->capfp=Sopencap())==NULL) { /* try to open the capture file */
                    tprintf(console->vs,"\r\nCannot open capture file for screendump ");
					wrest(console);
					viewmode=2;
					break;
				  }	/* end if */
                screendump(current,0);    /* dump the current screen */
				fclose(current->capfp);
				current->capfp=NULL;
				break;
			  }	/* end if */
			if(current->capon && current->capfp)	/* ok, capture if on & the file is open */
                screendump(current,0);    /* dump the screen */
			else {
                tprintf(console->vs,"\r\nAnother session has a capture file open, cannot screendump\r\n");
				wrest(console);
				viewmode=2;
			  }	/* end else */
			break;

    case ALTE:    /* shell to commmand processor (DOS) */
			leavetek();
			n_window(0,0,numline+1,79);
			i=n_color(current->colors[0]); 
      if(!dosescape())
        viewmode=10;
      else
        viewmode=5;  /* error, pause */
			n_color(i);
			c=0;
			break;

#ifdef FTP
		case ALTF:							/* an ftp command */
			strcpy(s,"ftp ");
#ifdef AUX /* RMG */
fprintf(stdaux," ftpoptions %s ",current->ftpopts);
#endif
      //if((!Sneedpass()) && (current->ftpopts)) {  What's needpass() here for??
      if(current->ftpopts) {
				strcat(s,current->ftpopts);
				strcat(s," ");
      } /* end if */
      sprintf(&s[strlen(s)],"%d.%d.%d.%d\r\n",myipnum[0],myipnum[1],myipnum[2],myipnum[3]);
			netwrite(t1->pnum,s,strlen(s));
      if(!t1->echo)
        parse(t1,s,strlen(s));     /* echo the string */
			c=0;
			break;
#endif

#ifdef USETEK
		case ALTG:			/* graphics manipulation */
			if(Stmode()) {		/* make certain that tektronix has been initialized */
				c=0;
				leavetek();
				dispgr();
			  } /* end if */
			break;
#endif

		case ALTH:				/* help display */
			if(viewmode!=3) {
        leavetek();
        viewmode=3;
        helpmsg();
        c=0;
      } /* end if */
			break;

		case ALTI:							/* my internet address */
      sprintf(s,"%d.%d.%d.%d\r\n",myipnum[0],myipnum[1],myipnum[2],myipnum[3]);
			netwrite(t1->pnum,s,strlen(s));
      if(!t1->echo)
        parse(t1,s,strlen(s));      /* echo the string */
			c=0;
      break;

        case ALTJ:      /* for debuggin' purposes */
#ifdef MAL_DEBUG
            mem_file=fopen("c:\mem_dump","w");
            if(mem_file) {
                Mem_Display(mem_file);
                tprintf(console->vs,"wrote mem_file.\r\n");
                fclose(mem_file);
              } /* end if */
            else
                tprintf(console->vs,"failed mem_file write.\r\n");
#endif
#ifdef QAK
            mcb();
#endif
#ifdef QAK
            for(i=0; i<256; i++)
                fprintf(console_fp,"%d: %d -> %d\n",i,i,(int)outputtable[i]);
#endif
#ifdef CHECKNULL
            check_null_area();
#endif
            tprintf(console->vs,"numline=%d\n",numline);
            c=0;
			break;

		case ALTK:				/* erase char */
			netpush(t1->pnum);
			netwrite(t1->pnum,"\377\367",2);
			c=0;
            break;

        case ALTL:
            sound_on=!sound_on;
            c=0;
            break;
				
        case ALTM:                  /* mouse control on/off */
			c=0;
			use_mouse=!use_mouse;
			break;

		case ALTN:						/* session switch forwards */
			c=0;
			leavetek();
			if(current->next==NULL)   /* are we only one ? */
				break;
			current=current->next;
			viewmode=10;
			break;

		case ALTO:				/* abort output */
			netpush(t1->pnum);
			netwrite(t1->pnum,"\377\365",2);
			c=0;
			break;
				
		case ALTP:				/* change a parameter */
			parmchange();
			c=0;
			break;

		case ALTQ:				/* are you there? */
			netpush(t1->pnum);
			netwrite(t1->pnum,"\377\366",2);
			c=0;
			break;

		case ALTR:				/* reset screen values */
			if(!leavetek()) {
				if(current->capon) {
					fclose(current->capfp);
					current->capon=capon=0;
                  } /* end if */
				VSreset(current->vs);		/* reset's emulator */
              } /* end if */
			wrest(current);
			c=0;
			break;

		case ALTS:						/* skip to end */
			c=0;
			RSvis(0);
            while(0<(i=netread(t1->pnum,s,500)))
                parse(t1,s,i);
			viewmode=10;
			break;

    case ALTT:        /* reload keyboard file */
      c=0;
      if(read_keyboard_file(Scon.keyfile)<0) { /* rmg  940216 */
        leavetek();
        n_puts("\nError reading settings from keymap file.");
        n_puts("\n Press any key to return");
        nbgetch();
        wrest(console);
        viewmode=7;
      } /* end if */
      break;

		case ALTU:				/* erase line */
			netpush(t1->pnum);
			netwrite(t1->pnum,"\377\370",2);
			c=0;
			break;
				
		case ALTV:				/* paste clipboard into buffer */
			if(copybuf!=NULL) {
				temp=size;
				viewmode=11;
              } /* end if */
			c=0;
			break;

#ifdef FTP
    case ALTW:				/* send our password to the machine we are connected to, for use in ftp'ing back to oneself */
      leavetek();
      if(bypass_passwd) {
        n_puts("\n OK then, we won't bypass the next FTP password after all.");
        bypass_passwd=0;
      }
      else {
        n_puts("\n Are you sure you want to bypass the FTP password once? Y/N");
        c=nbgetch();        /* get the answer */
        if(tolower(c)=='y') {
          n_puts("\n The next FTP connection will accept any password and give root access.");
          bypass_passwd=1;  /* set the flag to bypass the password check */
        } /* end if */
      }
      n_puts("\n Press any key to return");
      c=nbgetch();        /* get the answer */
      viewmode=10;      /* redraw screen */
      c=0;
      break;
#endif

		case ALTX:						/* close the connection */
			leavetek();
			n_puts("\n Are you sure you want to close the connection? Y/N");
			c=nbgetch();				/* get the answer */
			if(tolower(c)=='y') {
				n_puts("\n Attempting to close . . .");
				netclose(t1->pnum);
				Stask();
				netputuev(CONCLASS,CONCLOSE,t1->pnum);
      } /* end if */
			else
				viewmode=10;			/* redraw screen */
			c=0;
			break;

		case ALTY:				/* interrupt */
			netpush(t1->pnum);
			netwrite(t1->pnum,"\377\364",2);
			t1->timing=1;
			netwrite(t1->pnum,"\377\375\006",3);
			c=0;
			break;

		case ALTZ:					/* view console */
			c=0;
			leavetek();
			wrest(console);
			viewmode=2;				/* console view mode */
			break;

#ifdef DEBUG
		case AF9:
      statcheck();
			break;
#endif

		case EXIT_TELNET:			/* abort Telnet */
			return(EXIT_TELNET);

		default:
			break;
	  }	/* end switch */

	if(c>0)
		vt100key(c);			/* send it, with VT100 translation */
	return(c);
}   /* end dokey() */

/***************************************************************************/
/*  dosescape
*  escape to dos for processing
*  put the connections to automated sleep while in DOS
*  As telnet has grown, this feature has deteriorated in practicality.
*/
int dosescape(void )
{
	int i;
	char *command_shell;		/* the command shell to shell out to */
  char oldDir[_MAX_PATH];
  struct vidstate shell_vid_state;   /* the video state before we shelled out */

	if(ftpact || rcpact) {
		n_puts("Please wait until file transfer is finished");
		n_puts("\nPress any key to continue");
    return 1;
      } /* end if */

    getcwd(oldDir,_MAX_PATH);

    getvstate(&shell_vid_state);   /* get the current video state */
    setvstate(&tel_vid_state);     /* restore the user's previous video state */

    n_clear();
	n_cur(0,0);
	n_puts("Warning, some programs will interfere with network communication and can");
    n_puts("cause lost connections.  Do not run any network programs from this shell.");
	n_puts("Type 'EXIT' to return to NCSA Telnet");

/*
*  invoke a put-to-sleep routine which calls netsleep every 8/18ths of a sec
*  Also:  disable ftp,rcp when asleep and suppress error messages
*/
	restore_break();		/* restore the break status */
    remove_break();         /* restore the previous ctrl-c interupt handler */

    netsleep(0);

    tinst();  /* Will crash if Stack checking is on */

  command_shell = getenv("COMSPEC");    /* search for the user's COMSPEC */

    if(command_shell!=NULL)     /* make certain that the COMSPEC exists */
      i=system(command_shell);        /* call DOS */
    else    /* tell the user if it doesn't */
      i=-1;

    tdeinst();

    chgdir(oldDir);

    install_break((int *)&foundbreak);      /* install our ctrl-c interupt handler */
    save_break();           /* save the break state again */

    setvstate(&shell_vid_state);    /* restore the telnet graphics state */

/* RMG */
#ifdef AUX
  i= -1;
#endif

    if(i<0) {
      n_puts("\n\nError loading DOS shell");
      n_puts("Make sure DOS shell is specified under COMSPEC.");
      n_puts(command_shell);
      //n_puts("It must also be in a directory which is in your PATH statement.");
      n_puts("Telnet does not always leave enough free memory for a DOS shell.");
      sprintf(s,"%d",_memavl());
      n_puts(s);
      n_row();
      n_puts("\nPress any key to return to telnet");
    } /* end if */

#ifdef Pauseme
    n_row();
    n_puts("\nPress any key to return to telnet"); /** rmg: no dont ***/
#endif

    viewmode=10;

#ifdef CHECKNULL
    for(i=0x88; i<=0x8b; i++)   /* patch to correct the change DOS makes to the INT 22h address when returning to the program */
        nullbuf[i]=*((unsigned char far *)i);
#endif

return(i<0);
}   /* end dosescape() */

/***********************************************************************/

void wrest(struct twin *t)
{
	RSvis(t->vs);
	statline();						/* done before, moves cursor */
    VSredraw(t->vs,0,0,79,numline);     /* redisplay, resets cursor correctly */
}   /* end wrest() */

/***************************************************************************/
void statline(void )
{
	struct twin *t1,*t2;
	int wn;
	int i,c,sm,rw,cl;

  if(current==NULL || current->termstate==TEKTYPE)
		return;
	c=n_color(current->colors[0]);			/* save current color */
	if(current->sstat!='*')
		current->sstat=254;					/* this is current one */
	rw=n_row();
	cl=n_col();
	t1=t2=current;
	wn=0;
	sm=Scmode();
  if(current!=console)  /* rmg 931122 */
    do {
      n_cur(numline+1,wn*15);
      n_color(t1->colors[2]);
      if(t1->sstat==254 && t1!=current)
        t1->sstat=176;
      n_putchar((char)t1->sstat);
      n_putchar(' ');
      i=strlen(t1->mname);
      if(i>=13) {   /* check for too long of a name */
        if(sm)
          n_cheat(t1->mname,13);        /* machine name of connection */
        else
          n_draw(t1->mname,13);       /* machine name of connection */
        } /* end if */
      else {
        if(sm) {
          n_cheat(t1->mname,i);       /* machine name of connection */
          n_cheat(blankline,13-i);    /* fill out to 13 spaces */
          }
        else {
          n_draw(t1->mname,i);        /* machine name of connection */
          n_draw(blankline,13-i);     /* fill out to 13 spaces */
          }
        } /* end else */
      if(t1->next)            /* if not the only window open */
        t1=t1->next;
      wn++;
    } while(t1!=current && wn<4);
	n_color(current->colors[0]);
	n_cur(numline+1,wn*15);
	if(def.clock)	/* if we have a clock, then only fill up to the edge of the capture indicator */
		if(sm)
			n_cheat(blankline,71-wn*15);			/* fill to edge of screen */
		else
			n_draw(blankline,71-wn*15); 			/* fill to edge of screen */
	else		/* for no clock, fill all the way across the bottom of the screen */
		if(sm)
			n_cheat(blankline,80-wn*15);			/* fill to edge of screen */
		else
			n_draw(blankline,80-wn*15);				/* fill to edge of screen */

	if(wn>3 && (t1!=t2)) {		/* check whether to display the '\' */
		i=176;		/* display a '\' if any of the windows has data and those windows don't appear on the statline, (windows>4) */
        while(t1!=t2 && i!=14) {
            if(t1->sstat!=254 && t1->sstat!=176)    /* check for a different status character */
				i=t1->sstat;
			if(t1->next)	/* go to the next window if there is one */
				t1=t1->next;
   } /* end while */
		n_color(current->colors[0]);
		n_cur(numline+1,71);
		n_putchar((char)i);
	  }	/* end if */
	else {	/* just display a blank */
		n_color(current->colors[0]);
        n_cur(numline+1,71);
		n_putchar((char)' ');
      } /* end else */

	if(current->capon)	  						/* put capture flag status */
		capstat("Capt",1);
	else
		capstat("    ",0);

	n_color(c);
	n_cur(rw,cl);
}   /* end statline() */

/***********************************************************************/
/*  creatwindow
*   returns a pointer to a new window
*/
struct twin *creatwindow(void )
{
	struct twin *p;
	int i;

	p=(struct twin *)malloc(sizeof(struct twin));
	if(p==NULL)
		return(NULL);
	p->pnum=-1;
	p->telstate=0;
	p->substate=0;
	p->termsent=0;
	if(vton)
		p->termstate=basetype;
	else
		p->termstate=DUMBTYPE;
	p->linemode[0]=0;
#ifdef OLD_WAY
	p->echo=1;
#else
    p->echo=0;
#endif
    p->ibinary=0;       /* I'm sending NVT ASCII data */
    p->iwantbinary=0;   /* I'm not the one who asked for binary transmission from me */
    p->ubinary=0;       /* Server is sending NVT ASCII data */
    p->uwantbinary=0;   /* I'm not the one who asked for server to begin binary transmission */
    p->ugoahead=0;      /* we want goahead suppressed */
	p->igoahead=0;		/* we want goahead suppressed */
	p->timing=0;
	p->capon=0;
	p->next=NULL;
	p->prev=NULL;
    p->lmflag=0;
    p->lmedit=0;        /* turn off the telnet linemode editting initially */
    p->litflag=0;       /* turn off the literal flag initially */
    p->litecho=0;       /* turn off the literal echo initially */
    p->softtab=0;       /* turn off the soft tabbing initially */
    p->trapsig=0;       /* turn off the signal trapping initially */
    p->linemode_mask=0; /* set the linemode mask to remote editting and signal processing */
    for(i=1; i<=NUMLMODEOPTIONS; i++) {
		p->slc[i]=-1;
        p->slm[i]=SLC_NOSUPPORT;
      } /* end for */
    p->rows=numline+1;
    p->slm[SLC_BRK]|=SLC_SUPPORTED;     /* set the supported flag for the SLC functions we can handle */
    p->slm[SLC_IP]|=SLC_SUPPORTED;
    p->slm[SLC_AO]|=SLC_SUPPORTED;
    p->slm[SLC_AYT]|=SLC_SUPPORTED;
    p->slm[SLC_ABORT]|=SLC_SUPPORTED;
    p->slm[SLC_EOF]|=SLC_SUPPORTED;
    p->slm[SLC_SUSP]|=SLC_SUPPORTED;
    p->slm[SLC_EC]|=SLC_SUPPORTED;
    p->slm[SLC_EL]|=SLC_SUPPORTED;
    p->slm[SLC_EW]|=SLC_SUPPORTED;
    p->slm[SLC_RP]|=SLC_SUPPORTED;
    p->slm[SLC_LNEXT]|=SLC_SUPPORTED;
    p->slm[SLC_XON]|=SLC_SUPPORTED;
    p->slm[SLC_XOFF]|=SLC_SUPPORTED;
    p->slm[SLC_FORW1]|=SLC_SUPPORTED;
    p->slm[SLC_FORW2]|=SLC_SUPPORTED;
    p->sstat='*';               /* connection not opened yet */

	if(mp==NULL) {
		p->bksp=127;
		p->del=8;
    p->crfollow=0;
		p->halfdup=0;
		p->vtwrap=1;
#ifdef OLD_WAY
		p->bkscroll=0;
#else
    p->bkscroll=500;
#endif
		p->width=80;
    p->slc[SLC_EC]=127;
    p->ftpopts=NULL;
    p->condebug=0;
    p->mapoutput=0;     /* turn off output mapping for console */

		for(i=0; i<3; i++)					/* start default colors */
			p->colors[i]=colors[i];

    /****!*!*!*!*!*!*!*!*!*!*!*!*****/
		i=VSnewscreen(500,1,80,0);			/* create a new virtual screen */
    if(i<0) {
        free(p);
        return(NULL);
      } /* end if */
    p->vs=i;
    screens[i]=p;                       /* we need to know where it is */
    VSsetlines(i,numline+1);
		VSsetrgn(i,0,0,79,numline);
  } /* end if */
	else {
		p->bksp=mp->bksp;
		if(p->bksp==127)
			p->del=8;
		else
			p->del=127;
		p->crfollow=mp->crmap;
		p->halfdup=mp->halfdup;
		p->vtwrap=mp->vtwrap;
		p->bkscroll=mp->bkscroll;
		p->width=mp->vtwidth;
		p->colors[0]=mp->nfcolor + (mp->nbcolor<<4);
		p->colors[1]=mp->ufcolor + (mp->ubcolor<<4);
		p->colors[2]=mp->bfcolor + (mp->bbcolor<<4);
    p->slc[SLC_EC]=mp->bksp;
    p->ftpopts=mp->ftpoptions;
    p->condebug=mp->consoledebug;
    p->mapoutput=mp->mapoutflag;     /* turn output mapping on if specified */

		i=VSnewscreen(mp->bkscroll,1,80,0);	/* create a new virtual screen */
        if(i<0) {
            free(p);
            return(NULL);
          } /* end if */
        p->vs=i;
        screens[i]=p;                       /* we need to know where it is */
        VSsetlines(i,numline+1);
		VSsetrgn(i,0,0,79,numline);

		if(i>=0 && mp->vtwrap)
			VSwrite(i,"\033[?7h",5);		/* turn wrap on */
		VSscrolcontrol(i,-1,mp->clearsave);	/* set clearsave flag */
      } /* end else */

#ifdef OLD_WAY
	if(i<0)
		return(NULL);
	p->vs=i;
	screens[i]=p;						/* we need to know where it is */
#endif
	return(p);
}   /* end creatwindow() */

/***********************************************************************/
/*  inswindow
*	insert a window into the circular linked list
*
*   current is used as a reference point for the new entry, the new entry
*   is put next in line past "current"
*/
void inswindow(struct twin *t,int wtype)
{
	struct twin *p,*q;

/*
*   put it into the port number array
*/
	if(wtype)
		wins[t->pnum]=t;

/*
*  check for the NULL case for current.
*/
	if(current==NULL || current==console) {
		current=t; 
		statline();
		return;
	  }
	p=current;					/* find surrounding elements */
	if(p->prev==NULL) {			/* only one now, we are adding 2nd */
		t->next=p;
		t->prev=p;
		p->next=t;
		p->prev=t;
	  }
	else {							/* adding third or more */
		q=p->next;				/* find next one */
		t->prev=p;
		t->next=q;				/* insert it as next after current */
		q->prev=t;
		p->next=t;
	  }
}   /* end inswindow() */

/***********************************************************************/
/*  delwindow()
*   take a window out of the linked list
*/
void delwindow(struct twin *t,int wtype)
{
	struct twin *p,*q;

	if(wtype)	
		wins[t->pnum]=NULL;		/* take out of array */
	p=t->prev;
	q=t->next;
	if(p==NULL) {				/* is only node */
		freewin(t);
		current=console;
		return;
	  }	/* end if */
	if(p==q) {				/* two in list */
		p->next=NULL;
		p->prev=NULL;
	  }	/* end if */
	else {
		q->prev=p;
		p->next=q;			/* merge two links */
	  }	/* end else */
	freewin(t);				/* release the space */
}	/* end delwindow() */

/************************************************************************/
/*  freewin
*   deallocate and detach all associated memory from a window
*/
void freewin(struct twin *t)
{
	VSdetatch(t->vs);
	free(t);
}	/* end freewin() */

/************************************************************************/
/*
*  hexbyte
*   return a byte taken from a string which contains hex digits
*/
int hexbyte(char *st)
{
	int i;

	if(*st>='A')
		i=((*st|32)-87)<<4;
	else
		i=(*st-48)<<4;
	st++;
	if(*st>'A')
		i|=(*st|32)-87;
	else
		i+=(*st-48);
	return(i);
}   /* end hexbyte() */

#ifdef USETEK

/***********************************************************************/
/* tekinit
*  tektronix initialization
*/
int tekinit(char *dev)
{
	if(strlen(dev)<1)
		return(0);
#ifdef OLD_WAY
	if(0>VGinit()) {
        tprintf(console->vs,"\r\nCannot initialize Tektronix driver\r\n");
		return(-1);
	  }
	else
        tprintf(console->vs,"\r\nTektronix initialized\r\n");
#else
	VGinit();
    tprintf(console->vs,"\r\nTektronix initialized\r\n");
#endif
	if(!strcmp(dev,"vga")) 
		rgdevice=7;
	  	/* end if */
	else if(!strcmp(dev,"no9"))
		rgdevice=4;
	else if(!strcmp(dev,"ega"))
		rgdevice=1;
	else if(!strcmp(dev,"hercules"))
		rgdevice=3;
	else if(!strcmp(dev,"cga") || !strcmp(dev,"pga"))
		rgdevice=5;
	else
		rgdevice=0;				/* null device */
	basetype=VTEKTYPE;
	temptek=VGnewwin(rgdevice);	/* default for drawing */
	return(0);
}   /* end tekinit() */

/***********************************************************************/
/*  function to write to file
*/
void fdump(char *str)
{
	fputs(str,tekfp);
}   /* end fdump() */

void fdumpc(int c)
{
	fputc(c,tekfp);
}   /* end fdumpc() */

void endump(void )
{
	VGclose(outdev);
	if(indev!=temptek) {
		VGclose(indev);
		if(tekfp) {
			fclose(tekfp);
			tekfp=NULL;
		 }
	  }
}   /* end endump() */

/***********************************************************************/
/* graphit
*  Get some user choices and execute them
*/
int graphit(void )
{
	int i,j,k,l,c;

	c=n_chkchar();
	if(c==27)
		return(1);
	if(c<0)
		return(0);
	switch (c) {
		case F2:
		case F4:
		case F6:	/* prompting for file name */
			n_puts("\nEnter new file name:");
			nbgets(s,50);
			if(s[0] && s[0]!=' ') {
				switch(c) {
					case F2:
						Snewpsfile(s);
						break;

					case F4:
						Snewhpfile(s);
						break;

					case F6:
						Snewtekfile(s);
						break;
				  }
				Sgetconfig(&def);
			  }
			dispgr();						/* leave in graphit mode */
			return(0);

		case F1:			/* postscript dump */
			if(*def.psfile=='+') {
				if(NULL==(tekfp=fopen(&def.psfile[1],"a")))
					return(1);
				fseek(tekfp,0L,2);      /* to end */
			  }
			else 
				if(NULL==(tekfp=fopen(def.psfile,"w"))) 
					return(1);
#ifdef MSC
			RGPoutfunc(fdump);		/* set function */
#else
			RGPoutfunc(&fdump);		/* set function */
#endif
			outdev=VGnewwin(2);
			indev=temptek;
			temptek=VGnewwin(rgdevice);
			VGgmode(2);
			VGzcpy(indev,temptek);
			VGzcpy(indev,outdev);
			VGuncover(outdev);
			VGpage(outdev);
			if(VGpred(indev,outdev))
				endump();
			else
				netputevent(USERCLASS,PSDUMP,1);		/* remind myself */
			return(1);
					
		case F3:			/* HPGL dump */
			if(*def.hpfile=='+') {			/* append feature */
				if(NULL==(tekfp=fopen(&def.hpfile[1],"a"))) 
					return(1);
				fseek(tekfp,0L,2);
			  }
			else 
				if(NULL==(tekfp=fopen(def.hpfile,"w"))) 
					return(1);
#ifdef MSC
			RGHPoutfunc(fdump);		/* set function */
#else
			RGHPoutfunc(&fdump);		/* set function */
#endif
			outdev=VGnewwin(6);
			indev=temptek;
			temptek=VGnewwin(rgdevice);
			VGgmode(6);
			VGzcpy(indev,temptek);
			VGzcpy(indev,outdev);
			VGuncover(outdev);
			VGpage(outdev);
			if(VGpred(indev,outdev))
				endump();
			else
				netputevent(USERCLASS,PSDUMP,1);		/* remind myself */
			return(1);

		case F5:			/* tektronix dump */
			if(*def.tekfile=='+') {
				if(NULL==(tekfp=fopen(&def.tekfile[1],"ab"))) 
					return(1);
				fseek(tekfp,0L,2);
			  }
			else 
				if(NULL==(tekfp=fopen(def.tekfile,"wb"))) 
					return(1);
			fputs("\033\014",tekfp);
#ifdef MSC
			VGdumpstore(temptek,fdumpc);
#else
			VGdumpstore(temptek,&fdumpc);
#endif
			fclose(tekfp);
			return(1);

		case F7:			/* tek view region */
			n_puts("\nEnter 0-4095 for lower left xy, upper right xy.");
			n_puts("\nExample:  0,0,4095,3119 is full view. (default if you leave it blank)");
			nbgets(s,30);
			if(4!=sscanf(s,"%d,%d,%d,%d",&i,&j,&k,&l))
				VGzoom(temptek,0,0,4096,3119);
			else
				VGzoom(temptek,i,j,k,l);
			dispgr();						/* leave in graphit mode */
			return(0);

		case 13:
			if (!def.tek) break;
			current->termstate=TEKTYPE;
			VGgmode(rgdevice);
			VGuncover(temptek);
			outdev=temptek;				/* redraw to itself */
			indev=temptek;
			tekfp=NULL;
			if(!VGpred(indev,outdev))
				netputevent(USERCLASS,PSDUMP,0);		/* remind myself */
 			viewmode=0;					/* normal logon state */
			break;

		default:
			break;
	}
	return(0);
}   /* end graphit() */
#endif /* usetek */

/*************************************************************************/
/*  addsess
*   Add a session to a named machine, or prompt for a machine to be named.
*/
int addsess(char *st)
{
	int i,new,cv,pflag=0,port=0;
	struct twin *newin;

	leavetek();
	cv=console->vs;
	if(st==NULL) {			/* no machine yet */
		wrest(console);
    tprintf(cv,"\n\r\nEnter new machine name/address, ESC to return: \r\n");
		s[0]='\0';
		while(0>=(i=RSgets(cv,s,70,1)))
			Stask();
		if(i==27 || !s[0])
			return(1);
        tprintf(cv,"\n\r\n");    /* skip down a little */
		st=s;					/* make a copy of the pointer to s */
  }
/*
*	Find out what port to open to
*/
    for(i=0; (st[i]!=' ') && (st[i]!='#') && (st[i]!='\0'); i++);

	if((st[i]=='#') || (st[i]==' ')) {
		st[i++]='\0';
		new=i;
		pflag=1;
    for( ; (st[i]!='\0') && isdigit(st[i]); i++);
 		if(st[i]!='\0') 
			pflag=0;
		if(pflag) 
			port=(unsigned int)atoi(&st[new]);
  } /* end if */
	mp=Sgethost(st);			/* gain access to host information */
	errhandle();
	if(!mp) {
		if(pflag)
			st[strlen(st)]='#';	/* Append port number */
		if(Sdomain(st)>0) 
      tprintf(cv,"\r\nQuerying the DOMAIN name server\r\n");
		else {
      tprintf(cv,"\r\nNo nameserver, cannot resolve IP address\r\n");
			return(-1);
    }
  } /* end if */
	else {
/*
*   tell user about it on the console
*/
    tprintf(cv,"\r\nTrying to open TCP connection to: %s\r\n",st);
		if(!pflag) 
			port=mp->port;

	/* try to serve the request */
    if(0>(new=Snetopen(mp,port))) {
			errhandle();
      tprintf(cv,"\r\nCould not open new connection to: %s\r\n",st);
			return(-1);
    } /* end if */
		newin=creatwindow();
		if(!newin) {				/* mem error */
      tprintf(console->vs,"\r\nMemory Allocation error for window\r\n");
      return(-1);
    } /* end if */
		newin->pnum=new;
		strncpy(newin->mname,st,14);
		newin->mname[14]='\0';
		inswindow(newin,1);
		vhead(newin->vs);
  } /* end else */
	return(0);
}   /* end addsess() */

#ifdef USETEK
int leavetek(void )
{
    if(current!=NULL && current->termstate==TEKTYPE) {
		VGwrite(temptek,"\037",1);			/* force to alpha */
		current->termstate=VTEKTYPE;
		VGtmode(rgdevice);
		resetgin();				/* make sure to reset the GIN mode */
								/* clear graphics mode */
        if(def.ega43==1)
			ega43();
        else if(def.ega43==2)
            vga50();
		return(1);
    }
	return(0);					/* we did nothing */
}   /* end leavtek() */
#endif

/***********************************************************************/
/*  capstat
*	Print the capture status on the screen
*/
void capstat(char *str,int i)
{
	int r,c,color;

	r=n_row();
	c=n_col();
	color=n_color(current->colors[i]);
	n_cur(numline+1,66);
	n_draw(str,strlen(str));
	n_color(color);
	n_cur(r,c);
}   /* end capstat() */

/***********************************************************************/
/*  set_vtwrap
*	QAK - 7/29/90
*	set the vtwrap parameter for any telnet window, added because changing
*	a virtual screen's auto-wrapping had no way to change the telnet window's
*	wrapping state
*/
void set_vtwrap(int vs_win,int value)
{
	struct twin *temp_window;

	temp_window=screens[vs_win];		/* get a pointer to the window for the virtual screen */
	if(temp_window!=NULL)
		temp_window->vtwrap=(unsigned char)value;		/* set the virtual screen's wrapping */
}	/* end set_vtwrap() */

/***********************************************************************/
/*  strchar
*   QAK - 2/24/92
*   Append a character to a string
*/
void strchar(char *s,char c)
{
    while(*s)
        s++;    /* find the terminating zero in the string */
    *s++=c;     /* replace the terminating zero with the character */
    *s='\0';    /* terminate the new string */
}   /* end strchar() */

#ifdef CHECKNULL
void check_null_area(void)
{
    unsigned u;
    unsigned char *s;

    if(null_done && memcmp(nullbuf,MK_FP(0x0,0x0),1024)) {
        puts("NULL overwritten!");
        s=MK_FP(0x0,0x0);
        for(u=0; u<1024; u++,s++)
            if(*s!=nullbuf[u])
                printf("s=%p, u=%u, val=%u\n",s,u,(unsigned int)*s);
        getch();
      } /* end if */
}   /* end check_null_area() */
#endif

#ifdef DEBUG
void heapdump(void)
{

	struct _heapinfo hinfo;
	long free_mem=0;
	int heapstatus;

	hinfo._pentry = NULL;
	while ((heapstatus = _heapwalk(&hinfo)) == _HEAPOK){
		free_mem+= (hinfo._useflag == _USEDENTRY ? 0 : hinfo._size);
		printf("%6s block at %p of size %4.4X\n",
				(hinfo._useflag == _USEDENTRY ? "USED" : "FREE"),
				hinfo._pentry, hinfo._size);

		}
	switch(heapstatus){
		case _HEAPEMPTY:
			printf("OK - empty heap\n\n");
			break;
		case _HEAPEND:
			printf("OK - end of heap \n\n");
			break;
		case _HEAPBADPTR:
			printf("ERROR - bad pointer to heap \n\n");
			break;
		case _HEAPBADBEGIN:
			printf("ERROR - bad start of heap \n\n");
			break;
		case _HEAPBADNODE:
			printf("ERROR - bad node in heap \n\n");
	}
	printf("free_mem=%ld\n",free_mem);
}   /* end heapdump() */

void print_windowlist(void )
{

	struct twin *p, *q;

	wrest(console);
	n_clear();
	p=q=current;
	printf("List of Machines following NEXT list\n");
	do{
		printf("Host is %s\n",p->mname);
		p=p->next;
		} while(p!=q);
	printf("Hit any key for prev list\n");
	getch();
	n_clear();
	p=q=current;
	printf("List of Machines following PREV list\n");
	do{
		printf("Host is %s\n",p->mname);
		p=p->prev;
		} while(p!=q);
	printf("Hit any key to return to normal\n");
	getch();
}   /* end print_windowlist() */
#endif