TCPPORT.C
上传用户:better800
上传日期:2022-06-13
资源大小:1853k
文件大小:18k
源码类别:

TCP/IP协议栈

开发平台:

DOS

  1. #define OLD 1       /* new changes not complete */
  2. /*
  3.  * TCPPORT - make tcp connections from virtual serial ports
  4.  *
  5.  * Copyright (C) 1989, 1990, 1991 Erick Engelke
  6.  * Portions Copyright (C) 1991, Trustees of Columbia University
  7.  *    in the City of New York.  Permission is granted to any
  8.  *    individual or institution to use, copy, or redistribute
  9.  *    this software as long as it is not sold for profit, provided
  10.  *    this copyright notice is retained.
  11.  *
  12.  *   This program is distributed in the hope that it will be useful,
  13.  *   but without any warranty; without even the implied warranty of
  14.  *   merchantability or fitness for a particular purpose.
  15.  *
  16.  * Authors:
  17.  * Erick Engelke (erick@development.watstar.uwaterloo.ca),
  18.  *  Engineering Computing, University of Waterloo.
  19.  * Bruce Campbell (bruce@development.watstar.uwaterloo.ca),
  20.  *      Engineering Computing, University of Waterloo
  21.  * Frank da Cruz (fdc@columbia.edu, FDCCU@CUVMA.BITNET),
  22.  * Columbia University Center for Computing Activities.
  23.  *
  24.  *   1.00 - May 13, 1991 : E. Engelke - stole negotiations from Frank's
  25.  *  & F. Da Cruz   telnet portion of C-KERMIT
  26.  *   0.04 - May  7, 1991 : E. Engelke - got echo/no echo working
  27.  *   0.03 - Apr 24, 1991 : E. Engelke - hacked terminal negotiation
  28.  *   0.02 - Mar 24, 1991 : E. Engelke - convert r to n for UNIX compatibility
  29.  *   0.01 - Feb   , 1991 : E. Engelke - converted Bruce's program to TCP
  30.  * - 1.00 -              : B. Campbell- created original program
  31.  *
  32.  *  To force a particular terminal type, set the environment variable
  33.  *  tcpterm to something like vt102, vt100, etc.
  34.  *
  35.  *  To decrease the size of the executable I have used outs rather than
  36.  *  printf.  outs is used by the Waterloo TCP kernal for displaying error
  37.  *  messages through the BIOS services.
  38.  *
  39.  */
  40. #include <stdio.h>
  41. #include <stdlib.h>
  42. #include <string.h>
  43. #include <ctype.h>
  44. #include <mem.h>
  45. #include <dos.h>
  46. #include <conio.h>
  47. #include <tcp.h>
  48. typedef struct stk {
  49.     word bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flgs;
  50. };
  51. extern outhexes( byte far *p, int n );
  52. #define IAC     255
  53. #define DONT    254
  54. #define DO      253
  55. #define WONT    252
  56. #define WILL    251
  57. #define SB      250
  58. #define BREAK   243
  59. #define SE      240
  60. #define TELOPT_ECHO     1
  61. #define TELOPT_SGA      3
  62. #define TELOPT_STATUS   5
  63. #define TELOPT_TTYPE    24
  64. #define NTELOPTS        24
  65. #define TCPTERM "TCPTERM" /* environment variable */
  66. char termtype[ 32 ]; /* from the environment, used in negotiations */
  67. int echo = 1; /* default on, but hate it */
  68. #define TRANSMIT_TICKS   1     /* do the transmit after this many ticks */
  69. #define TRANSMIT_BUF_SIZE 4096
  70. #define TRANSMIT_MAX      256       /* most to transmit at a time */
  71. #define RECEIVE_TICKS    1
  72. #define RECEIVE_BUF_SIZE 4096
  73. extern unsigned long rdvct();
  74. extern unsigned long get_general();
  75. void far serial_2();
  76. void far serial_t();
  77. unsigned char transmit_buffer[ TRANSMIT_BUF_SIZE ];
  78. unsigned char receive_buffer[ RECEIVE_BUF_SIZE ];
  79. unsigned int tran_in = 0;
  80. unsigned int tran_out = 0;
  81. unsigned int rec_in = 0;
  82. unsigned int rec_out = 0;
  83. int transmit_clock = TRANSMIT_TICKS;
  84. int receive_clock = RECEIVE_TICKS;
  85. void interrupt far (*old14)(void);
  86. void interrupt far (*old8)(void);
  87. word oldsp, oldss;
  88. char stack[ 8192 ];
  89. char bigbuf[ 8192 ]; /* used to speed up tcp recvs */
  90. longword host;
  91. tcp_Socket *s, socketdata;
  92. int moved_vectors = 0;
  93. int sock_status = 0;
  94. int sem_stack = 0;
  95. struct stk far *stkptr;
  96. longword recvtimeout;
  97. /* TCP/IP Telnet negotiation support code */
  98. static int sgaflg = 0;                      /* telnet SGA flag */
  99. #ifndef TELCMDS
  100. char *telcmds[] = {
  101.     "SE", "NOP", "DMARK", "BRK",  "IP",   "AO", "AYT",  "EC",
  102.     "EL", "GA",  "SB",    "WILL", "WONT", "DO", "DONT", "IAC",
  103. };
  104. #endif /* TELCMDS */
  105. char *telopts[] = {
  106.         "BINARY", "ECHO", "RCP", "SUPPRESS GO AHEAD", "NAME",
  107.         "STATUS", "TIMING MARK", "RCTE", "NAOL", "NAOP",
  108.         "NAOCRD", "NAOHTS", "NAOHTD", "NAOFFD", "NAOVTS",
  109.         "NAOVTD", "NAOLFD", "EXTEND ASCII", "LOGOUT", "BYTE MACRO",
  110.         "DATA ENTRY TERMINAL", "SUPDUP", "SUPDUP OUTPUT",
  111. "SEND LOCATION", "TERMINAL TYPE", "END OF RECORD",
  112. "TACACS UID", "OUTPUT MARKING", "TTYLOC", "3270 REGIME",
  113. "X.3 PAD", "NAWS", "TSPEED", "LFLOW", "LINEMODE"
  114. };
  115. int ntelopts = sizeof(telopts) / sizeof(char *);
  116. /*
  117.  * prototypes
  118.  */
  119. void do_reception(void);
  120. int do_transmission(void);
  121. int ttinc( int fast );
  122. int tn_sttyp(void);
  123. unsigned  sytek_int( unsigned ax /*, unsigned dx */ );
  124. /*
  125.  * send_iac - send interupt character and pertanent stuff
  126.  *     - return 0 on success
  127.  */
  128. int send_iac( char cmd, char opt)
  129. {
  130.     byte io_data[3];
  131.     io_data[0] = IAC;
  132.     io_data[1] = cmd;
  133.     io_data[2] = opt;
  134.     sock_fastwrite( s, io_data, 3 );
  135.     return( !tcp_tick( s ));
  136. }
  137. /* Initialize a telnet connection. */
  138. /* Returns -1 on error, 0 is ok */
  139. int tn_ini( void )
  140. {
  141.     sgaflg = 0;                         /* SGA flag starts out this way. */
  142.     if (send_iac( WILL, TELOPT_TTYPE )) return( -1 );
  143.     if (send_iac( DO, TELOPT_SGA )) return( -1 );
  144. /*
  145.  *  The ECHO negotiations are not necessary for talking to full-duplex
  146.  *  systems, and they don't seem to do any good when sent to half-duplex
  147.  *  ones -- they still refuse to echo, and what's worse, they get into
  148.  *  prolonged negotiation loops.  Real telnet sends only the two above
  149.  *  at the beginning of a connection.
  150.  */
  151.     if (send_iac(WONT,TELOPT_ECHO)) return( -1 );  /* I won't echo. */
  152.     if (send_iac(DO,TELOPT_ECHO)) return( -1 );    /* Please, you echo. */
  153.     return(0);
  154. }
  155. /*
  156.  * Process in-band Telnet negotiation characters from the remote host.
  157.  * Call with the telnet IAC character and the current duplex setting
  158.  * (0 = remote echo, 1 = local echo).
  159.  * Returns:
  160.  *   0 on success
  161.  *  -1 on failure (= internal or i/o error)
  162.  */
  163. #define TSBUFSIZ 41
  164. char sb[TSBUFSIZ];                      /* Buffer for subnegotiations */
  165. int tn_doop(int c)
  166. {
  167.     int x, y, n, flag;
  168.     x = ttinc(0) & 0xff;                /* Read command character */
  169.     switch (x) {
  170.       case TELOPT_ECHO:                 /* ECHO negotiation. */
  171.         if (c == WILL) {                /* Host says it will echo. */
  172.     if (echo) {                 /* Only reply if change required */
  173. echo = 0;
  174. if (send_iac(DO,x))   /* Please do. */
  175.     return(-1);
  176.     }
  177.     return(0);
  178. }
  179.         if (c == WONT) {                /* Host says it won't echo. */
  180.             if (!echo) {                /* If I'm not echoing already */
  181. if (send_iac(DONT,x)) /* agree to echo. */
  182.     return(-1);
  183. echo = 1;
  184.     }
  185.     return(0);
  186. }
  187.         if (c == DO) {                  /* Host wants me to echo */
  188.     if (send_iac(WONT,x)) /* I say I won't, */
  189. return(-1);
  190.     if (send_iac(DO,x)) /* and ask the host to echo. */
  191. return(-1);
  192.     echo = 0;
  193.     return( 0 );
  194.         }
  195.         if (c == DONT) {                /* Host wants me not to echo */
  196.     if (send_iac(WONT,x)) /* I say I won't. */
  197. return(-1);
  198.     echo = 0;
  199.     return( 0 );
  200.         }
  201.         return(0);
  202.       case TELOPT_SGA:                  /* Suppress Go-Ahead */
  203.         if (c == WONT) {                /* Host says it won't. */
  204.             sgaflg = 1;                 /* Remember. */
  205.             if (!echo) {                /* If we're not echoing, */
  206. if (send_iac(DONT,x)) /* acknowledge, */
  207.     return(-1);
  208. echo = 1; /* and switch to local echo. */
  209.     }
  210.         }
  211.         if (c == WILL) {                /* Host says it will. */
  212.             sgaflg = 0;                 /* Remember. */
  213.             if (echo) {                 /* If I'm echoing now, */
  214. if (send_iac(DO,x)) /* this is a change, so ACK. */
  215.     return(-1);
  216. if (send_iac(DO,TELOPT_ECHO)) /* Request remote echo */
  217.     return(-1);
  218.             }
  219.         }
  220.         return(0);
  221.       case TELOPT_TTYPE:                /* Terminal Type */
  222.         switch (c) {
  223.           case DO:                      /* DO terminal type. */
  224.     if (send_iac(WILL,x))    /* Say I'll send it if asked. */
  225. return(-1);
  226.     return(0);
  227.   /* enter subnegociations */
  228.           case SB:
  229.             n = flag = 0;               /* Flag for when done reading SB */
  230.             while (n < TSBUFSIZ) {      /* Loop looking for IAC SE */
  231.                 if ((y = ttinc(0)) < 0)
  232.   return(-1);
  233. y &= 0xff;              /* Make sure it's just 8 bits. */
  234. sb[n++] = y;            /* Save what we got in buffer. */
  235.                 if (y == IAC) {         /* If this is an IAC */
  236.                     flag = 1;           /* set the flag. */
  237.                 } else {                /* Otherwise, */
  238.                     if (flag && y == SE) /* if this is SE which immediately */
  239.                       break;            /* follows IAC, we're done. */
  240.                     else flag = 0;      /* Otherwise turn off flag. */
  241.                 }
  242.     }
  243.     if (!flag)
  244.        return(-1);      /* Make sure we got a valid SB */
  245.     if ( *sb == 1 ) {
  246. if ( tn_sttyp() )
  247.                   return(-1);
  248.     };
  249.           default:                      /* Others, ignore */
  250.             return(0);
  251.         }
  252.       default:                          /* All others: refuse */
  253.         switch(c) {
  254.           case WILL:                    /* You will? */
  255.     if (send_iac(DONT,x)) /* Please don't. */
  256. return(-1);
  257.             break;
  258.           case DO:                      /* You want me to? */
  259.     if (send_iac(WONT,x)) /* I won't. */
  260. return(-1);
  261.     if (send_iac(DONT,x)) /* Don't you either. */
  262. return(-1);
  263.             break;
  264.           case DONT:                    /* (fall thru...) */
  265.     if (send_iac(WONT,x)) /* I won't. */
  266. return(-1);
  267.           case WONT:                    /* You won't? */
  268.             break;                      /* Good. */
  269.           }
  270.         return(0);
  271.     }
  272. }
  273. /*
  274.  * serial port portion
  275.  *
  276.  */
  277. /* Telnet send terminal type */
  278. /* Returns -1 on error, 0 on success */
  279. int tn_sttyp(void)
  280. {                            /* Send telnet terminal type. */
  281.     char *ttn;
  282.     int ttl;                 /* Name & length of terminal type. */
  283.     ttn = termtype; /* we already got this from environment */
  284.     if ((*ttn == 0) || ((ttl = strlen(ttn)) >= TSBUFSIZ)) {
  285.         ttn = "UNKNOWN";
  286.         ttl = 7;
  287.     }
  288.     ttn = strcpy(&sb[1],ttn); /* Copy to subnegotiation buffer */
  289.     ttn = strchr( strupr(ttn), 0 );
  290.     *sb    = 0; /* 'is'... */
  291.     *ttn++ = IAC;
  292.     *ttn   = SE;
  293.     if (send_iac(SB,TELOPT_TTYPE)) /* Send: Terminal Type */
  294. return(-1);
  295.     sock_fastwrite( s, sb, ttl+3 );
  296.     return(0);
  297. }
  298. /*
  299.  * ttinc   - destructively read a character from our buffer
  300.  *    - if fast = 0, never times out
  301.  */
  302. int ttinc( int fast )
  303. {
  304.     char ch;
  305.     /* organized to reduce number of set_timeouts when data waiting */
  306.     while ( rec_in == rec_out ) {
  307.         if ( !tcp_tick( s )) {
  308.     sock_status = 0;
  309.             s = NULL;
  310.             return( -1 );
  311.         }
  312.         /* do processing */
  313. kbhit();
  314.         do_transmission();
  315.         do_reception();
  316.         if (fast) break;
  317.     }
  318.     ch = receive_buffer[ rec_out ];
  319.     if ( ++rec_out >= RECEIVE_BUF_SIZE ) rec_out = 0;
  320.     return( (word)(ch) & 0x00ff );
  321. }
  322. void interrupt ourhandler(unsigned bp /* , unsigned di, unsigned si, unsigned ds,
  323.    unsigned es, unsigned dx, unsigned cx, unsigned bx, unsigned ax,
  324.    unsigned ip, unsigned cs, unsigned flgs */)  /* trailing parms not used */
  325. {
  326.     stkptr = (struct stk far *)&bp;
  327.     oldss = _SS;
  328.     oldsp = _SP;
  329.     _SS = FP_SEG(stack);
  330.     _SP = FP_OFF(&stack[ sizeof( stack ) - 2 ]);
  331.     stkptr->ax = sytek_int( stkptr->ax /*, stkptr->dx*/ );
  332.     _SS = oldss;
  333.     _SP = oldsp;
  334. }
  335. void stuff_char( char ch )
  336. {
  337.     transmit_buffer[ tran_in ] = ch;
  338.     tran_in = (tran_in + 1) % TRANSMIT_BUF_SIZE;
  339. }
  340. unsigned  sytek_int( unsigned ax /*, unsigned dx */ )
  341. {
  342.     unsigned char ah;
  343.     unsigned char ch;
  344. /*    int sent; */
  345.     unsigned int status;
  346.     if ( !s ) {
  347.         return( 0x1000 );   /* timeout */
  348.     }
  349.     if (chk_timeout( recvtimeout )) {
  350.         do_reception();
  351.         recvtimeout = set_ttimeout( 2 );    /* 10 ms */
  352.     }
  353.     /* disable(); receive_clock = RECEIVE_TICKS; enable(); } */
  354.     ah = ax >> 8;
  355.     if( ah == 1 ) { /* send char in AL */
  356. ch = ax & 0x0FF;
  357. /* if (ch == 'r') ch = 'n'; */
  358. if( ((tran_in + 1) % TRANSMIT_BUF_SIZE) == tran_out ) {
  359.     outs( "?tr_buf_full?" );
  360.     status = 0x08000 | ch;
  361. } else {
  362.     if ((ch == 'r') && echo ) stuff_char( 'n' );
  363.     else stuff_char( ch );
  364.     status = 0x06000 | ch;
  365.     /* local echoing if requested */
  366.     if ( echo ) {
  367. receive_buffer[ rec_in ] = ch;
  368. rec_in = (rec_in + 1) % RECEIVE_BUF_SIZE;
  369. if (ch == 'r') {
  370.     receive_buffer[ rec_in ] = 'n';
  371.     rec_in = (rec_in + 1) % RECEIVE_BUF_SIZE;
  372. }
  373.     }
  374. }
  375.     } else if( ah == 2 ) { /* receive char into AL */
  376.         do {
  377.             ch = 0;
  378.             if( rec_in == rec_out )
  379.         status = 0x08000;
  380.             else {
  381. status = ch = (ttinc( 0 ) & 0xff);
  382.                 if ( ch == IAC ) {
  383.                     /* process this stuff */
  384.     ch = ttinc( 0 );
  385.                     if ( ch == IAC ) ch = 0; /* let it pass through */
  386.     else tn_doop(ch);
  387.                 }
  388.             }
  389. } while ( ch == IAC );
  390. /* status = 0x0800; timeout */
  391.     }
  392.     else if( ah == 3 ) { /* get status */
  393. if( rec_in == rec_out )
  394.     status = 0x06010;
  395. else {
  396.     status = 0x06110;
  397. }
  398.     } else if( ah == 0 ) { /* init port */
  399. status = 0x06010;
  400.     } else {
  401. status = ax;
  402. outs( "?command_err?" );
  403.     }
  404.     /* here we do the io */
  405.     if( transmit_clock <= 0 ) {
  406.         do_transmission();
  407.         disable();
  408.         transmit_clock = TRANSMIT_TICKS;
  409.         enable();
  410.     }
  411.     return( status );
  412. }
  413. void sytek_tick( void )
  414. {
  415.     if( transmit_clock ) transmit_clock--;
  416.     if( receive_clock ) receive_clock--;
  417. }
  418. void interrupt tcpport_tick( void )
  419. {
  420.     (*old8)();
  421.     if( transmit_clock ) transmit_clock--;
  422.     if( receive_clock ) receive_clock--;
  423. }
  424. void do_reception(void)
  425. {
  426.     unsigned int maxtransfer;
  427. #ifdef OLD
  428.     unsigned int newtransfer;
  429.     int status;
  430.     unsigned int chars_avail, i;
  431. #endif
  432.     sock_tick( s, &status );
  433. #ifdef OLD
  434.     if ( sock_dataready( s )) {
  435. if (rec_out > rec_in ) {
  436.     /* we can fill intermediate portion of buffer */
  437.     maxtransfer = rec_out - rec_in;
  438. } else {
  439.     /* we fill end of buffer and leave start for next attempt */
  440.     maxtransfer = RECEIVE_BUF_SIZE - rec_in;
  441. }
  442. if (maxtransfer) {
  443.     rec_in += sock_fastread( s, &receive_buffer[ rec_in ], maxtransfer );
  444.     if ( rec_in >= RECEIVE_BUF_SIZE )
  445. rec_in -= RECEIVE_BUF_SIZE;
  446. }
  447.     }
  448. #else
  449.     maxtransfer = RECEIVE_BUF_SIZE - rec_in;
  450.     if (rec_out > rec_in) maxtransfer = rec_out - rec_in;
  451.     maxtransfer = sock_recv( s, &receive_buffer[ rec_in ], maxtransfer );
  452.     if (maxtransfer)
  453. rec_in = (rec_in + maxtransfer) % RECEIVE_BUF_SIZE ;
  454. #endif OLD
  455. /*    return( 0 ); */
  456.     return;
  457. sock_err:
  458.     switch (status) {
  459. case 1 : outs("nr7[??Host closed connection??]nr");
  460.  break;
  461. case-1 : outs("nr7[??Host reset connection??]nr");
  462.  break;
  463.     }
  464.     s = NULL;
  465.     sock_status = 0;
  466. }
  467. int do_transmission(void)
  468. {
  469.     unsigned int send_chars;
  470.     int status;
  471.     if( tran_in == tran_out ) return(0);
  472.     if( tran_in > tran_out )
  473. send_chars = tran_in - tran_out;
  474.     else
  475. send_chars = TRANSMIT_BUF_SIZE - tran_out;
  476.     if( send_chars > TRANSMIT_MAX ) send_chars = TRANSMIT_MAX;
  477.     sock_flushnext( s );
  478.     send_chars = sock_fastwrite( s, &transmit_buffer[ tran_out], send_chars );
  479.     /* this only changes it by the number of bytes we have emptied out */
  480.     tran_out = (tran_out + send_chars) % TRANSMIT_BUF_SIZE;
  481.     return(0);
  482. }
  483. int main( int argc, char *argv[] )
  484. {
  485. /*    int i; */
  486.     int status = 0;
  487.     char *temp;
  488.     if (argc < 4 ) {
  489. outs("SERTN host port program optionsnr");
  490. exit(1);
  491.     }
  492.     sock_init();
  493.     if (!( host = resolve( argv[1] ))) {
  494. outs( "Bad Hostnr" );
  495. exit(1);
  496.     }
  497.     if ( (temp = getenv( TCPTERM )) != NULL ) {
  498. /* deal with strncpy limitation */
  499. movmem( temp, termtype, sizeof( termtype ));
  500. termtype[ sizeof(termtype) -1 ] = 0;
  501. outs("TERMINAL EMULATION :");
  502. outs( termtype );
  503. outs("nr");
  504.     } else
  505. strcpy(termtype, "UNKNOWN");
  506.     s = &socketdata;
  507.     if ( host == my_ip_addr ) {
  508. outs("Incomming sessions not supported...nr");
  509. sock_wait_established( s, 0, NULL, &status );
  510. exit( -3 );
  511.     }
  512.     if (! tcp_open( s, 0, host, atoi( argv[2]), NULL )) {
  513. #ifndef OLD
  514. sock_recv_init( s, bigbuf, sizeof( bigbuf ), 0);
  515. #endif OLD
  516. outs( "Unable to opennr");
  517. exit(1);
  518.     }
  519.     sock_wait_established( s, sock_delay, NULL, &status );
  520.     sock_mode( s, TCP_MODE_NAGLE );
  521.     sock_status = 1; /* allow interrupts */
  522.     /* move vectors */
  523.     moved_vectors = 1;
  524.     old8 =  getvect( 0x08 );
  525.     old14 =  getvect( 0x014 );
  526. /*
  527.     setvect( 0x08, (void interrupt (*)())serial_t );
  528. */
  529.     setvect( 0x08, tcpport_tick );
  530.     setvect( 0x014,ourhandler);  /* was serial_2 */
  531.     recvtimeout = set_ttimeout( 1 );
  532.     outs("Running...");
  533.     outs( argv[3] );
  534.     outs( "nr");
  535.     system( argv[ argc-1 ] );
  536.     outs("Done, now closing sessionnr");
  537.     setvect( 0x014, old14 );
  538.     setvect( 0x08, old8 );
  539.     moved_vectors = 0;
  540.     if ( s ) {
  541. sock_close( s );
  542. sock_wait_closed( s, sock_delay, NULL, &status );
  543.     }
  544. sock_err:
  545.     switch (status) {
  546.     case 1 : outs("Done.nr");
  547.      break;
  548.     case -1: outs("Remote host reset connection.");
  549.      break;
  550.     }
  551.     if (moved_vectors) {
  552. setvect( 0x014, old14 );
  553. setvect( 0x08, old8 );
  554.     }
  555.     exit( (status)? 2 : 0);
  556.     return (0);   /* not reached */
  557. }