home *** CD-ROM | disk | FTP | other *** search
/ Super Net 1 / SUPERNET_1.iso / PC / OTROS / MSDOS / WATTCP / UNZIPPED / WNWATTCP / SRC / PCRECV.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-06  |  3.4 KB  |  155 lines
  1. #include <wattcp.h>
  2.  
  3. #define RECV_USED    0xf7e3d2b1L
  4. #define RECV_UNUSED  0xe6d2c1afL
  5.  
  6. typedef struct {
  7.     longword      recv_sig;
  8.     byte    *recv_bufs;
  9.     word     recv_bufnum;    /* for udp */
  10.     word     recv_len;    /* for tcp */
  11. } recv_data;
  12.  
  13. typedef struct {
  14.     longword     buf_sig;
  15.     longword     buf_hisip;
  16.     int         buf_len;
  17.     byte     buf_data[ 1500 ];
  18. } recv_buf;
  19.  
  20.  
  21. /*
  22.  *  recvd - gets upcalled when data arrives
  23.  */
  24. _recvdaemon( udp_Socket *s, byte *data, int len, tcp_PseudoHeader *ph )
  25. {
  26.     recv_data *r;
  27.     recv_buf *p;
  28.     tcp_Socket *t;
  29.     int i;
  30.  
  31.     /* check for length problem */
  32.     if ( !len || (len >= 1500 )) return( 0 );
  33.  
  34.     switch ( s->ip_type ) {
  35.     case UDP_PROTO :r = (recv_data*)(s->rdata);
  36.             if (r->recv_sig != RECV_USED ) {
  37. #ifndef WINDOWS
  38.                 outs("ERROR: udp recv data conflict");
  39. #endif
  40.                 return( 0 );
  41.             }
  42.  
  43.             p = (recv_buf *)(r->recv_bufs);
  44.  
  45.             /* find a buffer */
  46.             for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  47.                 switch ( p->buf_sig ) {
  48.                 case RECV_USED   : break;
  49.                 case RECV_UNUSED :
  50.                     /* take this one */
  51.                     p->buf_sig = RECV_USED;
  52.                     p->buf_len = len;
  53.                     p->buf_hisip = ph->src;
  54.                     movmem( data, p->buf_data, len );
  55. #ifndef WINDOWS
  56.                     outs("ERROR: sock_recv_init data err");
  57. #endif
  58.                     return( 0 );
  59.                 default       :
  60.                     return( 0 );
  61.                 }
  62.             }
  63.             return( 0 );
  64.     case TCP_PROTO :
  65.             t=s;
  66.             r = (recv_data*)(t->rdata);
  67.             if (r->recv_sig != RECV_USED ) {
  68. #ifndef WINDOWS
  69.                 outs("ERROR: udp recv data conflict");
  70. #endif
  71.                 return( 0 );
  72.             }
  73.  
  74.             /* stick it on the end if you can */
  75.             i = t->rmaxdatalen - t->rdatalen;
  76.             if ( i > 1 ) {
  77.                 /* we can accept some of this */
  78.                 if ( len > i ) len = i;
  79.                 movmem( data, &r->recv_bufs[s->rdatalen], len );
  80.                 s->rdatalen += len;
  81.                 return( len );
  82.             }
  83.             return( 0 );    /* didn't take none */
  84.     }
  85. }
  86.  
  87.  
  88.  
  89. sock_recv_init( udp_Socket *s, void *space, word len )
  90. {
  91.     tcp_Socket *t;
  92.     recv_buf *p;
  93.     recv_data *r;
  94.     int i;
  95.  
  96.     /* clear data area */
  97.     memset( p = space, 0, len );
  98.  
  99.     s->dataHandler = _recvdaemon;
  100.     /* clear table */
  101.     memset( r = s->rdata, 0, tcp_MaxBufSize );
  102.  
  103.     r->recv_sig = RECV_USED;
  104.     r->recv_bufs = p;
  105.     r->recv_bufnum = len / sizeof( recv_buf );
  106.     r->recv_len = len;
  107.     if (s->ip_type == UDP_PROTO )
  108.     for ( i = 0 ; i < r->recv_bufnum ; ++i, ++p )
  109.         p->buf_sig = RECV_UNUSED;
  110.     return( 0 );
  111. }
  112.  
  113. int sock_recv( udp_Socket *s, char *buffer, int len, word flags )
  114. {
  115.     tcp_Socket *t;
  116.     recv_data *r;
  117.     recv_buf *p;
  118.     int i;
  119.  
  120.     r = s->rdata;
  121.     if (r->recv_sig != RECV_USED )
  122.     return( -1 );
  123.  
  124.     switch ( s->ip_type ) {
  125.     case UDP_PROTO :
  126.         p = r->recv_bufs;
  127.  
  128.         /* find a buffer */
  129.         for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  130.         switch ( p->buf_sig ) {
  131.             case RECV_UNUSED:
  132.             break;
  133.             case RECV_USED  :
  134.             p->buf_sig = RECV_USED;
  135.             if ( len > p->buf_len ) len = p->buf_len;
  136.             movmem( p->buf_data, buffer, len );
  137.             p->buf_sig = RECV_UNUSED;
  138.             return( len );
  139.             default      :
  140. #ifndef WINDOWS
  141.             outs("ERROR: sock_recv_init data err");
  142. #endif
  143.             return( 0 );
  144.         }
  145.         }
  146.         return( 0 );
  147.     case TCP_PROTO :
  148.         t = s;
  149.         if ( len > t->rdatalen ) len = t->rdatalen;
  150.         if ( len )
  151.         movmem( r->recv_bufs, buffer, len );
  152.         return( len );
  153.     }
  154. }
  155.