开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
TELNETD.C
资源名称：ertos.rar　[点击查看]
上传用户：sunrenlu
上传日期：2022-06-13
资源大小：1419k
文件大小：6k
源码类别：

操作系统开发

开发平台：

DOS

TELNETD.C：源码内容
  1. /*
  2.  * TELNET Server
  3.  *
  4.  * Copyright (c) 1990, 1999 Erick Engelke
  5.  */
  7. #include <net.h>
  8. #include <rtos.h>
  9. #include <telnetd.h>
  10. #include <stdio.h>
  11. #include <mem.h>
  12. #include <string.h>
  15. #define IO_ST_INIT 0
  16. #define IO_ST_NORM 1 /* normal chars */
  18. #define TEL_SE     240
  19. #define TEL_IP     244  /* interrupt process */
  20. #define TEL_AYT    246  /* are you there */
  21. #define TEL_WILL   251
  22. #define TEL_WONT   252
  23. #define TEL_DO    253
  24. #define TEL_DONT   254
  25. #define TEL_IAC    255
  27. #define LAST_MODE  6
  30. #define OPT_ECHO 1
  31. #define OPT_SUPPRESS_GA 3
  32. #define OPT_TERM_TYPE 24
  36. static void send_iac( teld_str *t, BYTE cmd, BYTE opt)
  37. {
  38.     static char io_data[3];
  39.     io_data[0] = TEL_IAC;
  40.     io_data[1] = cmd;
  41.     io_data[2] = opt;
  43.     sock_write( &t->teld_socket, io_data, 3 );
  44. }
  46. static int io_pre_get( teld_str *t )
  47. {
  48.     tcp_Socket *s = &t->teld_socket;
  49.     unsigned char ch;
  51.     if ( t->teld_iostate == IO_ST_INIT )
  52.         t->teld_iostate = IO_ST_NORM;
  54.     while (sock_dataready(s)) {
  55.         sock_fastread( s, &ch, 1 );
  56.         switch ( t->teld_iostate ) {
  57.     case IO_ST_NORM:
  58.     if (ch != TEL_IAC)
  59. return( ch );
  60.                     t->teld_iostate = TEL_IAC;
  61.     break;
  63.             case TEL_IAC :
  64.                     t->teld_iostate = IO_ST_NORM;      /* assume last */
  65.     if (ch == TEL_IAC)  /* byte stuffed */
  66. return( ch );
  68.                     if (ch >= TEL_IP )
  69.                         t->teld_iostate = ch;
  70.     break; /* loose all others */
  71.             case TEL_IP  :
  72.                     t->teld_iostate = IO_ST_NORM;
  73.                     return( 3 );         /* control break */
  74.             case TEL_AYT :
  75.                     t->teld_iostate = IO_ST_NORM;
  76.                     sock_puts( s, "[YES]");
  77.                     break;
  78.     case TEL_WILL:
  79.     case TEL_WONT:
  80.     case TEL_DO:
  81.     case TEL_DONT :
  82.                     if ( ch == OPT_TERM_TYPE ) t->teld_iostate = ch;
  83.                     else t->teld_iostate = IO_ST_NORM;
  84.     break;
  85.             case OPT_TERM_TYPE :
  86.                     if ( ch >= TEL_SE ) t->teld_iostate = ch;
  87.                     break;
  88.     default :
  89.                     t->teld_iostate = IO_ST_NORM;
  90.                     break;
  91. }
  92.     }
  93.     rt_sleep( 0 );
  94.     return( 0 );
  95. }
  100. /******************************************************************/
  102. teld_str *teld_listen( int port )
  103. {
  104.     teld_str *t;
  105.     tcp_Socket *s;
  107.     t = kcalloc( sizeof( teld_str ), 1 );
  108.     if ( t == NULL ) return( NULL );
  109.     if ( port == 0 ) port = TELNETPORT;
  111.     s = &t->teld_socket;
  112.     do {
  113.         tcp_listen( s, port, 0L, 0, NULL, 0 );
  115.         while ( ! sock_established( s )) {
  116.             if ( tcp_tick( s ) == NULL ) goto retry;
  117.             rt_sleep( 250 );
  118.         }
  120.         /* we are connected */
  121.         t->teld_connected = 1;
  122.         t->teld_iostate = IO_ST_INIT;
  123.         sock_mode( s, TCP_MODE_NONAGLE );
  124.         send_iac( t, TEL_WILL, OPT_ECHO );
  125.         return( t );
  127. retry:
  128.         sock_abort( s );
  129.     } while ( 1 );
  130. }
  132. /*
  133.  * teld_write - returns 0 on failure
  134.  */
  135. int teld_write( teld_str *t, char *buffer, int len )
  136. {
  137.     tcp_Socket *s;
  139.     if ( t->teld_connected == 0 ) return( 0 );
  141.     s = &t->teld_socket;
  142.     sock_write( s, buffer, len );
  143.     return( tcp_tick( s ) != 0);
  144. }
  146. int teld_puts( teld_str *t, char *s )
  147. {
  148.     return( teld_write( t, s, strlen( s)));
  149. }
  151. char teld_putch( teld_str *t, char x )
  152. {
  153.     return( teld_write( t, &x, 1 ) ? x : 0 );
  154. }
  156. /*
  157.  * teld_getc - returns character or 255 on connection failed
  158.  */
  159. BYTE teld_getc( teld_str *t )
  160. {
  162.     if ( ! tcp_tick( &t->teld_socket ))
  163.         t->teld_connected = 0;
  164.     if ( t->teld_connected == 0 )
  165.         return( 255 );
  166.     return( io_pre_get( t ));
  167. }
  169. int teld_iswaiting( teld_str *t )
  170. {
  171.     tcp_Socket *s;
  173.     s = &t->teld_socket;
  174.     if (tcp_tick( s ) == NULL ) t->teld_connected = 0;
  175.     if ( t->teld_connected == 0 ) return( 1 );  /* EOT is waiting */
  177.     return(sock_rbused( s ));
  178. }
  180. char *teld_getstring( teld_str *t, char *buf, int maxlen, long timeout, char dispchar )
  181. {
  182.     long now, whenever;
  183.     int len;
  184.     BYTE ch;
  186.     if ( timeout > 0 ) {
  187.         dos_enter();
  188.         now = time( NULL );
  189.         dos_exit();
  190.         whenever = now + timeout;
  191.     }
  192.     len = 0;
  193.     do {
  194.         buf[ len ] = 0;
  196.         /* reached max len */
  197.         if ( len == (maxlen - 1 )) {
  198.             return( buf );
  199.         }
  201.         if ( teld_iswaiting( t ) ) {
  202.             ch = teld_getc( t );
  203.             if ( ch == 255 ) {
  204.                 /* EOT */
  205.                 return( NULL );
  206.             }
  207.             if ( ch == 13 ) {
  208.                 buf[ len ] = 0;
  209.                 teld_puts( t, "rn");
  210.                 return( buf );
  211.             }
  212.             if (( ch == 8 ) || ( ch == 127 )) {
  213.                 if ( len > 0 ) {
  214.                     len--;
  215.                     teld_puts( t, "10 10" ); /* BS SP BS */
  216.                 } else
  217.                     teld_putch( t, 7 ); /* bell */
  218.             } else if ( ( ch == 0 ) || ( ch == 10 )) {
  219.                 /* do nothing */
  220.             } else {
  221.                 /* normal char */
  222.                 buf[ len++ ] = ch;
  223.                 /* handle normal or password type entries */
  224.                 teld_putch( t, dispchar ? dispchar : ch );
  225.             }
  226.             rt_sleep( 0 );      /* there may be more chars to process */
  227.         } else {
  228.             /* nothing to do.. so we do almost nothing */
  230.             rt_sleep( 10 );
  232.             /* look for timeout */
  233.             if ( timeout != 0 ) {
  234.                 dos_enter();
  235.                 now = time( NULL );
  236.                 dos_exit();
  237.                 if ( now >= whenever ) {
  238.                     return( NULL );
  239.                 }
  240.             }
  241.         }
  242.     } while ( 1 );
  243. }
  247. char *teld_getpassword( teld_str *t, char *buf, int maxlen, long timeout )
  248. {
  249.     return teld_getstring( t, buf, maxlen, timeout, '*' );
  250. }
  252. /*
  253.  * teld_gets - returns string on success
  254.  *           - returns NULL on closed session or on timeout reached
  255.  *           - timeout = 0 means never
  256.  */
  258. char *teld_gets( teld_str *t, char *buf, int maxlen, long timeout )
  259. {
  260.     return teld_getstring( t, buf, maxlen, timeout, 0 );
  261. }
  265. void teld_close( teld_str *t )
  266. {
  267.     tcp_Socket *s;
  269.     if ( t != NULL ) {
  270.         s = &t->teld_socket;
  273.         sock_close( s );
  274.         while ( tcp_tick( s ))
  275.             rt_sleep( 250 );
  276.         kfree( t );
  277.     }
  278. }