NET.C
上传用户:sunrenlu
上传日期:2022-06-13
资源大小:1419k
文件大小:8k
源码类别:

操作系统开发

开发平台:

DOS

  1. /*
  2.  * Copyright (c) 1999 Erick Engelke
  3.  */
  4. #define ERTOS_NET_CORE 1
  5. #include <tcp.h>
  6. #include <rtos.h>
  7. #include <stdio.h>
  8. static crit_x *tcp_cs = NULL;
  9. int rt_tcp_tick( void *s )
  10. {
  11.     int r;
  12.     cs_enter( tcp_cs );
  13.     r = tcp_tick( s );
  14.     cs_exit( tcp_cs );
  15.     return r;
  16. }
  17. /* low priority network tick function */
  18. static void netthread( DWORD x )
  19. {
  20.     rt_setpriority( NULL, 127 );
  21.     while ( 1 ) {
  22.         rt_tcp_tick( NULL );
  23.         rt_sleep(0);
  24.     }
  25. }
  26. static void knetyield()
  27. {
  28.     /* called inside functions when we have nothing to do */
  29.     cs_exit( tcp_cs );
  30.     rt_sleep( 0 );
  31.     cs_enter( tcp_cs );
  32. }
  33. void rt_sock_init()
  34. {
  35. extern int kctrlbrkhandler( void );
  36.     if ( tcp_cs == NULL )
  37.         tcp_cs = cs_alloc();
  38.     cs_enter( tcp_cs );
  39.     sock_init();
  40.     sock_yield( NULL, knetyield );
  41.     cs_exit( tcp_cs );
  42.     rt_newthread( &netthread, 0, 4096, 0, "network heartbeat");
  43. #if defined(__TURBOC__)||defined(__BORLANDC__)
  44.     ctrlbrk( kctrlbrkhandler );
  45. #endif
  46. }
  47. int rt_sock_fastread(void  *s, byte *dp, int len )
  48. {
  49.     int r;
  50.     cs_enter( tcp_cs );
  51.     r = sock_fastread( s, dp, len );
  52.     cs_exit( tcp_cs );
  53.     return r;
  54. }
  55. int rt_sock_fastwrite( void *s, byte *dp, int len )
  56. {
  57.     int r;
  58.     cs_enter( tcp_cs );
  59.     r = sock_fastwrite( s, dp, len );
  60.     cs_exit( tcp_cs );
  61.     return r;
  62. }
  63. int rt_sock_read(void  *s, byte *dp, int len )
  64. {
  65.     int r;
  66.     cs_enter( tcp_cs );
  67.     /* uses internal yield set up in open */
  68.     r = sock_read( s, dp, len );
  69.     cs_exit( tcp_cs );
  70.     return r;
  71. }
  72. int rt_sock_write(void  *s, byte *dp, int len )
  73. {
  74.     int r;
  75.     cs_enter( tcp_cs );
  76.     /* uses internal yield set up in open */
  77.     r = sock_write( s, dp, len );
  78.     cs_exit( tcp_cs );
  79.     return r;
  80. }
  81. void rt_sock_enqueue(void  *s, byte *dp, int len)
  82. {
  83.     cs_enter( tcp_cs );
  84.     sock_enqueue( s, dp, len );
  85.     cs_exit( tcp_cs );
  86.     return;
  87. }
  88. int rt_sock_flush( void  *s )
  89. {
  90.     int r;
  91.     cs_enter( tcp_cs );
  92.     r = sock_flush( s );
  93.     cs_exit( tcp_cs );
  94.     return r;
  95. }
  96. int rt_sock_flushnext( void  *s)
  97. {
  98.     int r;
  99.     cs_enter( tcp_cs );
  100.     r = sock_flushnext( s );
  101.     cs_exit( tcp_cs );
  102.     return r;
  103. }
  104. int rt_sock_puts( void  *s, byte *dp )
  105. {
  106.     int r;
  107.     cs_enter( tcp_cs );
  108.     r = sock_puts( s, dp );
  109.     cs_exit( tcp_cs );
  110.     return r;
  111. }
  112. word rt_sock_gets( void  *s, byte *dp, int n )
  113. {
  114.     int r;
  115.     cs_enter( tcp_cs );
  116.     r = sock_gets( s, dp, n );
  117.     cs_exit( tcp_cs );
  118.     return r;
  119. }
  120. byte rt_sock_putc( void  *s, byte c )
  121. {
  122.     byte r;
  123.     cs_enter( tcp_cs );
  124.     r = sock_putc( s, c );
  125.     cs_exit( tcp_cs );
  126.     return r;
  127. }
  128. byte rt_sock_getc( void  *s )
  129. {
  130.     byte r;
  131.     cs_enter( tcp_cs );
  132.     r = sock_getc( s );
  133.     cs_exit( tcp_cs );
  134.     return r;
  135. }
  136. word rt_sock_dataready( void  *s )
  137. {
  138.     word r;
  139.     cs_enter( tcp_cs );
  140.     r = sock_dataready( s );
  141.     cs_exit( tcp_cs );
  142.     return r;
  143. }
  144. word rt_sock_close( void *s )
  145. {
  146.     word r;
  147.     cs_enter( tcp_cs );
  148.     r = sock_close( s );
  149.     cs_exit( tcp_cs );
  150.     return r;
  151. }
  152. int rt_sock_abort( void *s )
  153. {
  154.     int r;
  155.     cs_enter( tcp_cs );
  156.     r = sock_abort( s );
  157.     cs_exit( tcp_cs );
  158.     return r;
  159. }
  160. //extern sock_printf( void  *s, char *format, ... );
  161. //extern sock_scanf( void  *s, char *format, ... );
  162. int rt_sock_mode( void *s, word mode )
  163. {
  164.     int r;
  165.     cs_enter( tcp_cs );
  166.     r = sock_mode( s , mode );
  167.     cs_exit( tcp_cs );
  168.     return r;
  169. }
  170. /*
  171.  * TCP or UDP specific stuff, must be used for open's and listens, but
  172.  * sock stuff is used for everything else
  173.  */
  174. int rt_udp_open(void *s, word lport, longword ina, word port, int (*datahandler)())
  175. {
  176.     int r;
  177.     cs_enter( tcp_cs );
  178.     r = udp_open( s , lport, ina, port, datahandler );
  179.     cs_exit( tcp_cs );
  180.     return r;
  181. }
  182. int rt_tcp_open(void *s, word lport, longword ina, word port, int (*datahandler)())
  183. {
  184.     int r;
  185.     cs_enter( tcp_cs );
  186.     r = tcp_open( s , lport, ina, port, datahandler );
  187.     cs_exit( tcp_cs );
  188.     return r;
  189. }
  190. int rt_tcp_listen(void *s, word lport, longword ina, word port, int (*datahandler)(), word timeout)
  191. {
  192.     int r;
  193.     cs_enter( tcp_cs );
  194.     r = tcp_listen( s , lport, ina, port, datahandler, timeout );
  195.     cs_exit( tcp_cs );
  196.     return r;
  197. }
  198. int rt_tcp_established(void *s)
  199. {
  200.     int r;
  201.     cs_enter( tcp_cs );
  202.     r = tcp_established( s );
  203.     cs_exit( tcp_cs );
  204.     return r;
  205. }
  206. longword rt_resolve( char *name)
  207. {
  208.     longword r;
  209.     cs_enter( tcp_cs );
  210.     r = resolve( name );
  211.     cs_exit( tcp_cs );
  212.     return r;
  213. }
  214. #if defined(__TURBOC__)||defined(__BORLANDC__)
  215. extern int reverse_addr_lookup( longword ipaddr, char *name );
  216. int rt_reverse_addr_lookup( longword ipaddr, char *name )
  217. {
  218.     int x;
  219.     cs_enter( tcp_cs );
  220.     x = reverse_addr_lookup( ipaddr, name );
  221.     cs_exit( tcp_cs );
  222.     return x ;
  223. }
  224. #endif
  225. /*
  226.  * sock_wait_... macros
  227.  */
  228. /*
  229.  * sock_wait_established()
  230.  * - waits then aborts if timeout on s connection
  231.  * sock_wait_input()
  232.  * - waits for received input on s
  233.  * - may not be valid input for sock_Gets... check returned length
  234.  * sock_tick()
  235.  * - do tick and jump on abort
  236.  * sock_wait_closed();
  237.  * - discards all received data
  238.  *
  239.  * jump to sock_err with contents of *statusptr set to
  240.  *  1 on closed
  241.  * -1 on timeout
  242.  *
  243.  */
  244. int _rt_ip_delay0( void *s, int seconds, int (*fn)(), void *statusptr )
  245. {
  246.     int r;
  247.     cs_enter( tcp_cs );
  248.     r = _ip_delay0( s, seconds, fn, statusptr );
  249.     cs_exit( tcp_cs );
  250.     return r;
  251. }
  252. int _rt_ip_delay1( void *s, int seconds, int (*fn)(), void *statusptr )
  253. {
  254.     int r;
  255.     cs_enter( tcp_cs );
  256.     r = _ip_delay1( s, seconds, fn, statusptr );
  257.     cs_exit( tcp_cs );
  258.     return r;
  259. }
  260. int _rt_ip_delay2( void *s, int seconds, int (*fn)(), void *statusptr )
  261. {
  262.     int r;
  263.     cs_enter( tcp_cs );
  264.     r = _ip_delay2( s, seconds, fn, statusptr );
  265.     cs_exit( tcp_cs );
  266.     return r;
  267. }
  268. /*
  269. #define sock_wait_established( s, seconds, fn, statusptr ) 
  270.     if (_rt_ip_delay0( s, seconds, fn, statusptr )) goto sock_err;
  271. #define sock_wait_input( s, seconds, fn , statusptr ) 
  272.     if (_rt_ip_delay1( s, seconds, fn, statusptr )) goto sock_err;
  273. #define sock_tick( s, statusptr ) 
  274.     if ( !rt_tcp_tick(s)) { if (statusptr) *statusptr = 1 ; goto sock_err; }
  275. #define sock_wait_closed(s, seconds, fn, statusptr )
  276.     if (_rt_ip_delay2( s, seconds, fn, statusptr )) goto sock_err;
  277. */
  278. extern int _send_ping( longword host, longword countnum, byte ttl, byte tos, longword *theid );
  279. #if defined(__TURBOC__) || defined(__BORLANDC__)
  280. int _rt_ping( longword host , longword countnum, byte ttl, byte tos, longword *theid  )
  281. {
  282.     int r;
  283.     cs_enter( tcp_cs );
  284.     r = _send_ping( host, countnum, ttl, tos, theid );
  285.     cs_exit( tcp_cs );
  286.     return r;
  287. }
  288. longword _rt_chk_ping( longword host , longword *ptr)
  289. {
  290.     longword r;
  291.     cs_enter( tcp_cs );
  292.     r = _chk_ping( host, ptr );
  293.     cs_exit( tcp_cs );
  294.     return r;
  295. }
  296. #endif // BorlandC
  297. /*
  298.  * recv routines -- pcrecv.c
  299.  */
  300. int rt_sock_recv_init( void *s, void *space, word len )
  301. {
  302.     int r;
  303.     cs_enter( tcp_cs );
  304.     r = sock_recv_init( s, space, len );
  305.     cs_exit( tcp_cs );
  306.     return r;
  307. }
  308. int rt_sock_recv_from( void *s, long *hisip, word *hisport, char *buffer, int len, word flags )
  309. {
  310.     int r;
  311.     cs_enter( tcp_cs );
  312.     r = sock_recv_from( s, hisip, hisport, buffer, len, flags );
  313.     cs_exit( tcp_cs );
  314.     return r;
  315. }
  316. int rt_sock_recv( void *s, char *buffer, int len, word flags )
  317. {
  318.     int r;
  319.     cs_enter( tcp_cs );
  320.     r = sock_recv( s, buffer, len, flags );
  321.     cs_exit( tcp_cs );
  322.     return r;
  323. }
  324. /* bsd-similar stuff */
  325. /* .. */