#ifdef __TURBOC__
#include "turboc.h"
#endif
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#include <malloc.h>
#include <dos.h>
#include <ctype.h>
#include <process.h>
#include <errno.h>
#ifdef MSC
#include <direct.h>
#include <signal.h>
#include <time.h>
#endif
#ifdef MEMORY_DEBUG
#include "memdebug.h"
#endif
#include "netevent.h"
#include "hostform.h"
#include "whatami.h"
#include "netutils.h"
#include "externs.h"
/* #define DEBUG */
/*
* Global variables
*/
struct machinfo *mp;
unsigned char parsedat[32]; /* character buffer to store network writes */
extern unsigned char connected_flags; /* flags indicating whether a port is connected yet */
extern unsigned char buf[256];
#ifdef CHECKNULL
extern unsigned char nullbuf[1024]; /* buffer for checking the NULL area */
#endif
#define SERIAL 0x14
#define NUM_COMM_PORTS 4 /* the number of comm. ports supported, remember to change this variable in int14.asm also */
/* Definitions for telnet protocol */
#define STNORM 0
#define SE 240
#define NOP 241
#define DM 242
#define BREAK 243
#define IP 244
#define AO 245
#define AYT 246
#define EC 247
#define EL 248
#define GOAHEAD 249
#define SB 250
#define WILLTEL 251
#define WONTTEL 252
#define DOTEL 253
#define DONTTEL 254
#define IAC 255
/* Assigned Telnet Options */
#define BINARY 0
#define ECHO 1
#define RECONNECT 2
#define SGA 3
#define AMSN 4
#define STATUS 5
#define TIMING 6
#define RCTAN 7
#define OLW 8
#define OPS 9
#define OCRD 10
#define OHTS 11
#define OHTD 12
#define OFFD 13
#define OVTS 14
#define OVTD 15
#define OLFD 16
#define XASCII 17
#define LOGOUT 18
#define BYTEM 19
#define DET 20
#define SUPDUP 21
#define SUPDUPOUT 22
#define SENDLOC 23
#define TERMTYPE 24
#define EOR 25
#define TACACSUID 26
#define OUTPUTMARK 27
#define TERMLOCNUM 28
#define REGIME3270 29
#define X3PAD 30
#define NAWS 31
#define TERMSPEED 32
#define TFLOWCNTRL 33
#define LINEMODE 34
#define MODE 1
#define EDIT 1
#define TRAPSIG 2
#define MODE_ACK 4
#define FORWARDMASK 2
#define SLC 3
#define NO_SUPPORT 0
#define CANTCHANGE 1
#define SLC_VALUE 2
#define SLC_DEFAULT 3
#define SLC_LEVELBITS 3
#define SLC_AWK 128
#define SLC_SYNCH 1
#define SLC_BRK 2
#define SLC_IP 3
#define SLC_AO 4
#define SLC_AYT 5
#define SLC_EOR 6
#define SLC_ABORT 7
#define SLC_EOF 8
#define SLC_SUSP 9
#define SLC_EC 10
#define SLC_EL 11
#define SLC_EW 12
#define SLC_RP 13
#define SLC_LNEXT 14
#define SLC_XON 15
#define SLC_XOFF 16
#define SLC_FORW1 17
#define SLC_FORW2 18
#define XDISPLOC 35
#define XOPTIONS 255
#define ESCFOUND 5
#define IACFOUND 6
#define NEGOTIATE 1
#ifdef DEBUG
char *telstates[]={
"Subnegotiation End",
"NOP",
"Data Mark",
"Break",
"Interrupt Process",
"Abort Output",
"Are You There",
"Erase Character",
"Erase Line",
"Go Ahead",
"Subnegotiate",
"Will",
"Won't",
"Do",
"Don't"
};
char *teloptions[256]={
"Binary", /* 0 */
"Echo",
"Reconnection",
"Supress Go Ahead",
"Message Size Negotiation",
"Status", /* 5 */
"Timing Mark",
"Remote Controlled Trans and Echo",
"Output Line Width",
"Output Page Size",
"Output Carriage-Return Disposition", /* 10 */
"Output Horizontal Tab Stops",
"Output Horizontal Tab Disposition",
"Output Formfeed Disposition",
"Output Vertical Tabstops",
"Output Vertical Tab Disposition", /* 15 */
"Output Linefeed Disposition",
"Extended ASCII",
"Logout",
"Byte Macro",
"Data Entry Terminal", /* 20 */
"SUPDUP",
"SUPDUP Output",
"Send Location",
"Terminal Type",
"End of Record", /* 25 */
"TACACS User Identification",
"Output Marking",
"Terminal Location Number",
"3270 Regime",
"X.3 PAD", /* 30 */
"Negotiate About Window Size",
"Terminal Speed",
"Toggle Flow Control",
"Linemode",
"X Display Location", /* 35 */
"36","37","38","39",
"40","41","42","43","44","45","46","47","48","49",
"50","51","52","53","54","55","56","57","58","59",
"60","61","62","63","64","65","66","67","68","69",
"70","71","72","73","74","75","76","77","78","79",
"80","81","82","83","84","85","86","87","88","89",
"90","91","92","93","94","95","96","97","98","99",
"100","101","102","103","104","105","106","107","108","109",
"110","111","112","113","114","115","116","117","118","119",
"120","121","122","123","124","125","126","127","128","129",
"130","131","132","133","134","135","136","137","138","139",
"140","141","142","143","144","145","146","147","148","149",
"150","151","152","153","154","155","156","157","158","159",
"160","161","162","163","164","165","166","167","168","169",
"170","171","172","173","174","175","176","177","178","179",
"180","181","182","183","184","185","186","187","188","189",
"190","191","192","193","194","195","196","197","198","199",
"200","201","202","203","204","205","206","207","208","209",
"210","211","212","213","214","215","216","217","218","219",
"220","221","222","223","224","225","226","227","228","229",
"230","231","232","233","234","235","236","237","238","239",
"240","241","242","243","244","245","246","247","248","249",
"250","251","252","253","254",
"Extended Options List" /* 255 */
};
char *LMoptions[]={
"None",
"SYNCH",
"BREAK",
"IP",
"ABORT OUTPUT",
"AYT",
"EOR",
"ABORT",
"EOF",
"SUSP",
"EC",
"EL",
"EW",
"RP",
"LNEXT",
"XON",
"XOFF",
"FORW1",
"FORW2"
};
char *LMflags[]={
"NOSUPPORT",
"CANTCHANGE",
"VALUE",
"DEFAULT"
};
#endif
static void int14parse(int comm_port,unsigned char *st,int cnt);
static void int14parsewrite(int comm_port,char *dat,int len);
extern unsigned char port_buffer[NUM_COMM_PORTS][64]; /* four buffers to store the machine name to connect to */
extern unsigned char buffer_offset[NUM_COMM_PORTS]; /* the offset into the buffer currently */
extern int pnum[NUM_COMM_PORTS]; /* the port numbers we are connected to */
extern volatile unsigned char *data_begin[NUM_COMM_PORTS]; /* pointers to the beginning of the data buffer for the comm.ports */
extern unsigned char *data_max[NUM_COMM_PORTS]; /* pointers to the maximum value for the data_end pointers */
extern volatile unsigned char *data_end[NUM_COMM_PORTS]; /* pointers to the end of the data buffer for the comm. ports */
extern unsigned char *data_start[NUM_COMM_PORTS]; /* pointers to the start of the data buffer for the comm. ports */
extern int comm_port_index[NPORTS]; /* lookup table from a network port number to a comm port number */
int telstate[NUM_COMM_PORTS]; /* the telnet state for each comm. port */
int substate[NUM_COMM_PORTS]; /* the telnet substate for each comm. port */
int igoahead[NUM_COMM_PORTS];
int ugoahead[NUM_COMM_PORTS];
int echo[NUM_COMM_PORTS];
int timing[NUM_COMM_PORTS];
static char c;
#ifndef DEBUG
#ifdef __WATCOMC__
void cdecl print_int(int num)
#else
void print_int(int num)
#endif
{
#ifdef QAK
printf("number: %d:%x\n",num,num);
#else
printf("number: %d:%x\t",num,num);
#endif
} /* end print_int() */
#ifdef __WATCOMC__
void cdecl print_int2(int num)
#else
void print_int2(int num)
#endif
{
printf("number2: %d:%x\n",num,num);
} /* end print_int2() */
#endif
/*
* int14open
*
* Entry :
* int comm_port - which comm port this connection is attached to
*
*/
#ifdef __WATCOMC__
int cdecl int14open(int comm_port)
#else
int int14open(int comm_port)
#endif
{
int ev,what,dat;
char *errmsg;
#ifdef QAK
printf("opening connection to: %s:%d\n",port_buffer[comm_port],comm_port);
#endif
mp=gethostinfo(port_buffer[comm_port]); /* look up in hosts cache, also checks for domain lookup */
#ifdef QAK
puts("after opening connection to the machine\n");
#endif
if(!mp) {
puts("need to domain lookup!?!?\n");
return(0); /* error return */
} /* end if */
else {
while((ev=Sgetevent(ERRCLASS,&what,&dat))!=0) { /* sift through the error events potentially generated by a domain lookup */
#ifdef OLD_WAY
if(dat!=801 && dat!=805) { /* filter out reports of using domain lookup */
errmsg=neterrstring(dat);
puts(errmsg);
} /* end if */
#endif
} /* end while */
if(0>(pnum[comm_port]=Snetopen(mp,mp->port))) { /* use requested ports RMG 931230 */
#ifdef QAK
errhandle();
#else
puts("Network open failed");
#endif
netshut();
return(0);
} /* end if */
comm_port_index[pnum[comm_port]]=comm_port; /* assign the comm port to the TCP port number */
}
return(1); /* indicate sucessful session opening */
} /* end int14open() */
/*********************************************************************/
/* int14process
* take incoming data and process it. Close the connection if it
* is the end of the connection.
*/
int int14process(int comm_port)
{
int cnt;
cnt=netread(pnum[comm_port],buf,64); /* get some from incoming queue */
if(cnt<0) { /* close this session, if over */
netclose(pnum[comm_port]);
return(0);
}
if(cnt)
int14parse(comm_port,buf,cnt); /* display on screen, etc.*/
#ifdef QAK
puts("leaving int14process()");
#endif
return(0);
}
/*********************************************************************/
/* int14parse
* Do the telnet negotiation parsing.
*
* look at the string which has just come in from outside and
* check for special sequences that we are interested in.
*
* Tries to pass through routine strings immediately, waiting for special
* characters ESC and IAC to change modes.
*/
void int14parse(int comm_port,unsigned char *st,int cnt)
{
int i;
unsigned char *mark,*orig;
orig=st; /* remember beginning point */
mark=st+cnt; /* set to end of input string */
netpush(pnum[comm_port]);
/*
* traverse string, looking for any special characters which indicate that
* we need to change modes.
*/
while(st<mark) {
switch(telstate[comm_port]) {
case ESCFOUND:
int14parsewrite(comm_port,"\033",1); /* send the missing ESC */
telstate[comm_port]=STNORM;
break;
case IACFOUND: /* telnet option negotiation */
if(*st==IAC) { /* real data=255 */
st++; /* real 255 will get sent */
telstate[comm_port]=STNORM;
break;
}
if(*st>239) {
telstate[comm_port]=*st++; /* by what the option is */
break;
}
#ifdef DEBUG
printf("strange telnet option %s\n",itoa(*st,parsedat,10));
#endif
orig=st;
telstate[comm_port]=STNORM;
break;
case EL: /* received a telnet erase line command */
case EC: /* received a telnet erase character command */
case AYT: /* received a telnet Are-You-There command */
case AO: /* received a telnet Abort Output command */
case IP: /* received a telnet Interrupt Process command */
case BREAK: /* received a telnet Break command */
case DM: /* received a telnet Data Mark command */
case NOP: /* received a telnet No Operation command */
case SE: /* received a telnet Subnegotiation End command */
#ifdef DEBUG
printf("RECV: %s\n",telstates[telstate[comm_port]-SE]);
#endif
telstate[comm_port]=STNORM;
orig=st;
break;
case GOAHEAD: /* telnet go ahead option*/
telstate[comm_port]=STNORM;
orig=st;
break;
case DOTEL: /* received a telnet DO negotiation */
#ifdef DEBUG
printf("RECV: %s %s\n",telstates[telstate[comm_port]-SE],teloptions[*st]);
#endif
switch(*st) {
case SGA: /* Suppress go-ahead */
if(igoahead[comm_port]) { /* suppress go-ahead */
#ifdef DEBUG
printf("SEND: %s %s\n",telstates[WILLTEL-SE],teloptions[*st]);
#endif
sprintf(parsedat,"%c%c%c",IAC,WILLTEL,*st);
netwrite(pnum[comm_port],parsedat,3); /* take it */
igoahead[comm_port]=1;
}
#ifdef DEBUG
else
printf("NO REPLY NEEDED: %s %s\n",telstates[WILLTEL-SE],teloptions[SGA]);
#endif
telstate[comm_port]=STNORM;
orig=++st;
break;
default:
#ifdef DEBUG
printf("SEND: %s %s\n",telstates[WONTTEL-SE],teloptions[*st]);
#endif
sprintf(parsedat,"%c%c%c",IAC,WONTTEL,*st++);
netwrite(pnum[comm_port],parsedat,3); /* refuse it */
telstate[comm_port]=STNORM;
orig=st;
break;
}
break;
case DONTTEL: /* Received a telnet DONT option */
#ifdef DEBUG
printf("RECV: %s %s\n",telstates[telstate[comm_port]-SE],teloptions[*st]);
#endif
telstate[comm_port]=STNORM;
orig=++st;
break;
case WILLTEL: /* received a telnet WILL option */
#ifdef DEBUG
printf("RECV: %s %s\n",telstates[telstate[comm_port]-SE],teloptions[*st]);
#endif
telstate[comm_port]=STNORM;
switch(*st++) {
case SGA: /* suppress go-ahead */
if(ugoahead[comm_port])
break;
ugoahead[comm_port]=1;
#ifdef DEBUG
printf("SEND: %s %s\n",telstates[DOTEL-SE],teloptions[*st]);
#endif
sprintf(parsedat,"%c%c%c",IAC,DOTEL,3); /* ack */
netwrite(pnum[comm_port],parsedat,3);
break;
case ECHO: /* echo */
if(echo[comm_port])
break;
echo[comm_port]=1;
#ifdef DEBUG
printf("SEND: %s %s\n",telstates[DOTEL-SE],teloptions[*st]);
#endif
sprintf(parsedat,"%c%c%c",IAC,DOTEL,1); /* ack */
netwrite(pnum[comm_port],parsedat,3);
break;
case TIMING: /* Timing mark */
timing[comm_port]=0;
break;
default:
#ifdef DEBUG
printf("SEND: %s %s\n",telstates[DONTTEL-SE],teloptions[*st]);
#endif
sprintf(parsedat,"%c%c%c",IAC,DONTTEL,*(st-1));
netwrite(pnum[comm_port],parsedat,3); /* refuse it */
break;
} /* end switch */
orig=st;
break;
case WONTTEL: /* Received a telnet WONT option */
#ifdef DEBUG
printf("RECV: %s %s\n",telstates[telstate[comm_port]-SE],teloptions[*st]);
#endif
telstate[comm_port]=STNORM;
switch(*st++) { /* which option? */
case ECHO: /* echo */
if(echo[comm_port])
break;
echo[comm_port]=0;
sprintf(parsedat,"%c%c%c",IAC,DONTTEL,ECHO);
netwrite(pnum[comm_port],parsedat,3); /* OK with us */
break;
case TIMING: /* Telnet timing mark option */
timing[comm_port]=0;
break;
default:
break;
}
orig=st;
break;
case SB: /* telnet sub-options negotiation */
telstate[comm_port]=NEGOTIATE;
orig=st;
i=substate[comm_port]=0; /* Defined for each */
break;
case NEGOTIATE:
if(substate[comm_port]<200) {
switch(*st) {
case IAC:
if(*(st+1)==IAC) { /* skip over double IAC's */
parsedat[i++]=*st++;
parsedat[i++]=*st++;
} /* end if */
else {
parsedat[i]='\0';
substate[comm_port]=*st++;
} /* end else */
break;
default:
parsedat[i++]=*st++;
break;
} /* end switch */
} /* end if */
else {
switch(substate[comm_port]) {
case IAC:
substate[comm_port]=*st++;
orig=st;
telstate[comm_port]=STNORM;
break;
default:
orig=st;
telstate[comm_port]=STNORM;
break;
} /* end switch */
} /* end else */
break;
default:
telstate[comm_port]=STNORM;
break;
}
/*
* quick scan of the remaining string, skip chars while they are
* uninteresting
*/
if(telstate[comm_port]==STNORM) {
/*
* skip along as fast as possible until an interesting character is found
*/
while(st<mark && *st!=27 && *st<IAC) {
/* #ifdef EIGHT_BIT_CLEAN */
/* if(!tw->binary) */
/* RMG 8bit */
// *st &= 127; /* mask off high bit */
/* #endif */
st++;
}
if(!timing[comm_port] && st>orig)
int14parsewrite(comm_port,orig,st-orig);
orig=st; /* forget what we have sent already */
if(st<mark)
switch (*st) {
case IAC: /* telnet IAC */
telstate[comm_port]=IACFOUND;
st++;
break;
case 27: /* ESCape code */
if(st==mark-1 || *(st+1)==12 || *(st+1)=='^')
telstate[comm_port]=ESCFOUND;
st++; /* strip or accept ESC char */
break;
#ifdef DEBUG
default:
#ifdef QAK
vprint(cv," strange char>128\r\n");
#else
puts("strange char>128\n");
#endif
st++;
break;
#endif
} /* end switch */
} /* end if */
} /* end while */
#ifdef QAK
puts("leaving int14parse()");
#endif
}
/*********************************************************************/
/* int14parsewrite
* write out some chars from parse
* Has a choice of where to send the stuff
*/
void int14parsewrite(int comm_port,char *dat,int len)
{
int i; /* local counting variable */
for(i=0; i<len; i++) {
#ifdef QAK
buffer_stat++;
if(buffer_stat>max_buffer_stat)
max_buffer_stat=buffer_stat;
printf("buffer_stat=%d, max_buffer_stat=%d\n",buffer_stat,max_buffer_stat);
#endif
#ifdef DEBUG
printf("data_end[%d]=%p, data_begin[%d]=%p\n",comm_port,data_end[comm_port],comm_port,data_begin[comm_port]);
#endif
/* small fix here rmg 931100 */
// *data_end[comm_port]++= dat[i];
*data_end[comm_port] = dat[i]; /* store the character in the appropriate character buffer */
data_end[comm_port]++;
if(data_end[comm_port]>=data_max[comm_port]) /* check if we went off the end of the buffer */
data_end[comm_port]=data_start[comm_port]; /* wrap back to the beginning */
if(data_end[comm_port]==data_begin[comm_port]) { /* check if we are going to wrap around */
#ifdef DEBUG
printf("data_end[%d] pushed data_begin[%d]\n",comm_port,comm_port);
#endif
data_begin[comm_port]++; /* lose data at the beginning of the buffer */
if(data_begin[comm_port]>=data_max[comm_port]) /* check if we went off the end of the buffer */
data_begin[comm_port]=data_start[comm_port]; /* wrap back to the beginning */
} /* end if */
} /* end for */
#ifdef DEBUG
printf("b:data_end[%d]=%p, data_begin[%d]=%p\n",comm_port,data_end[comm_port],comm_port,data_begin[comm_port]);
#endif
}
/*********************************************************************/
/* get_comm_char
* used by the interrupt service routine to get characters from the
* comm. buffers
*/
#ifdef __WATCOMC__
int cdecl get_comm_char(int comm_port)
#else
int get_comm_char(int comm_port)
#endif
{
int i; /* local counting variable */
while(data_end[comm_port]==data_begin[comm_port]); /* wait for a character */
#ifdef QAK
buffer_stat--;
#endif
i=*data_begin[comm_port]++;
if(data_begin[comm_port]>=data_max[comm_port])
data_begin[comm_port]=data_start[comm_port];
return(i);
}
/*********************************************************************/
/* int14netsleep
* manage the network in the background, grabs packets from the network
* Has a choice of where to send the stuff
*/
#ifdef __WATCOMC__
void cdecl int14netsleep(void)
#else
void int14netsleep(void)
#endif
{
int ev,what,dat;
char *errmsg;
#ifdef DEBUG
printf("int14netsleep().a: stackavail=%u\n",stackavail());
#endif
#ifdef CHECKNULL
/* If we are running in NULL debugging mode, check that */
if(memcmp(nullbuf,MK_FP(0x0,0x0),1024)) {
unsigned u;
unsigned char *s;
s=MK_FP(0x0,136);
if(*s!=nullbuf[136]) {
nullbuf[136]=*s++;
nullbuf[137]=*s++;
nullbuf[138]=*s++;
nullbuf[139]=*s;
} /* end if */
else {
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 else */
} /* end if */
#endif
/* check to make certain we are actually connected to the network before
* dealing with network events
*/
if(!connected_flags) /* if any ports are connected, we have to parse data */
return;
/*
* get event from network, these two classes return all of the events
* of user interest.
*/
#ifdef QAK
ev=Sgetevent(USERCLASS | CONCLASS | ERRCLASS,&what,&dat);
#else
ev=Sgetevent(CONCLASS | ERRCLASS,&what,&dat);
#endif
if(!ev) {
#ifdef DEBUG
printf("int14netsleep().b: stackavail=%u\n",stackavail());
#endif
return;
} /* end if */
if(what==ERRCLASS) { /* error event */
#ifdef OLD_WAY
errmsg=neterrstring(dat);
puts(errmsg); /* ifdef'ed out because of messing up DOS */
#endif
}
else
if(what==CONCLASS) { /* event of user interest */
switch (ev) {
case CONOPEN: /* connection opened or closed */
#ifdef DEBUG
puts("CONOPEN received");
#endif
netpush(dat); /* negotiation */
netwrite(dat,"\377\375\001\377\375\003\377\374\030",9);
break;
default:
break;
case CONDATA: /* data arrived for me */
#ifdef OLD_WAY
cnt=netread(dat,buf,80);
for(i=0; i<cnt; i++)
if(buf[i]<128)
putchar(buf[i]);
#else
#ifdef QAK
puts("int14netsleep: data received\n");
#endif
if(int14process(comm_port_index[dat]))
c=16; /* break out of the loop */
#endif
break;
case CONFAIL:
#ifdef DEBUG
puts("CONFAIL received");
#endif
#ifdef DEBUG
puts("Connection attempt failed");
#endif
/* drop through to exit */
case CONCLOSE:
#ifdef DEBUG
puts("CONCLOSE received");
#endif
#ifdef QAK
netshut();
exit(1);
#else
c=16;
#endif
}
}
#ifdef QAK
else
if(what==USERCLASS) {
switch (ev) {
case DOMOK: /* domain worked */
#ifdef DEBUG
puts("DOMOK received");
#endif
mp=Slooknum(dat); /* get machine info */
pnum[PORT]=Snetopen(mp,mp->port); /* open to host name */ /* use requested ports RMG 931230 */
break;
case DOMFAIL: /* domain failed */
#ifdef DEBUG
n_puts("domain failed");
#endif
#ifdef QAK
netshut();
exit(1);
#else
c=16;
#endif
default:
break;
}
}
#endif
#ifdef DEBUG
printf("int14netsleep().c: stackavail=%u\n",stackavail());
#endif
}
