home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Programmierung / SOURCE.mdf / programm / msdos / c / mscwattc / src / pcrecv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-13  |  3.3 KB  |  147 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.                 outs("ERROR: udp recv data conflict");
  38.                 return( 0 );
  39.             }
  40.  
  41.             p = (recv_buf *)(r->recv_bufs);
  42.  
  43.             /* find a buffer */
  44.             for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  45.                 switch ( p->buf_sig ) {
  46.                 case RECV_USED   : break;
  47.                 case RECV_UNUSED :
  48.                     /* take this one */
  49.                     p->buf_sig = RECV_USED;
  50.                     p->buf_len = len;
  51.                     p->buf_hisip = ph->src;
  52.                     movmem( data, p->buf_data, len );
  53.                     return( 0 );
  54.                 default       :
  55.                     outs("ERROR: sock_recv_init data err");
  56.                     return( 0 );
  57.                 }
  58.             }
  59.             return( 0 );
  60.     case TCP_PROTO :
  61.             t=(tcp_Socket *)s;
  62.             r = (recv_data*)(t->rdata);
  63.             if (r->recv_sig != RECV_USED ) {
  64.                 outs("ERROR: udp recv data conflict");
  65.                 return( 0 );
  66.             }
  67.  
  68.             /* stick it on the end if you can */
  69.             i = t->rmaxdatalen - t->rdatalen;
  70.             if ( i > 1 ) {
  71.                 /* we can accept some of this */
  72.                 if ( len > i ) len = i;
  73.                 movmem( data, &r->recv_bufs[s->rdatalen], len );
  74.                 s->rdatalen += len;
  75.                 return( len );
  76.             }
  77.             return( 0 );    /* didn't take none */
  78.     }
  79. }
  80.  
  81.  
  82.  
  83. sock_recv_init( udp_Socket *s, void *space, word len )
  84. {
  85.     tcp_Socket *t;
  86.     recv_buf *p;
  87.     recv_data *r;
  88.     int i;
  89.  
  90.     /* clear data area */
  91.     memset( p = space, 0, len );
  92.  
  93.     s->dataHandler = _recvdaemon;
  94.     /* clear table */
  95.     memset( r = (recv_data *)s->rdata, 0, tcp_MaxBufSize );
  96.  
  97.     r->recv_sig = RECV_USED;
  98.     r->recv_bufs = (byte *)p;
  99.     r->recv_bufnum = len / sizeof( recv_buf );
  100.     r->recv_len = len;
  101.     if (s->ip_type == UDP_PROTO )
  102.     for ( i = 0 ; i < r->recv_bufnum ; ++i, ++p )
  103.         p->buf_sig = RECV_UNUSED;
  104.     return( 0 );
  105. }
  106.  
  107. int sock_recv( udp_Socket *s, char *buffer, int len, word flags )
  108. {
  109.     tcp_Socket *t;
  110.     recv_data *r;
  111.     recv_buf *p;
  112.     int i;
  113.  
  114.     r = (recv_data *)s->rdata;
  115.     if (r->recv_sig != RECV_USED )
  116.     return( -1 );
  117.  
  118.     switch ( s->ip_type ) {
  119.     case UDP_PROTO :
  120.         p = (recv_buf *)r->recv_bufs;
  121.  
  122.         /* find a buffer */
  123.         for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  124.         switch ( p->buf_sig ) {
  125.             case RECV_UNUSED:
  126.             break;
  127.             case RECV_USED  :
  128.             p->buf_sig = RECV_USED;
  129.             if ( len > p->buf_len ) len = p->buf_len;
  130.             movmem( p->buf_data, buffer, len );
  131.             p->buf_sig = RECV_UNUSED;
  132.             return( len );
  133.             default      :
  134.             outs("ERROR: sock_recv_init data err");
  135.             return( 0 );
  136.         }
  137.         }
  138.         return( 0 );
  139.     case TCP_PROTO :
  140.         t = (tcp_Socket *)s;
  141.         if ( len > t->rdatalen ) len = t->rdatalen;
  142.         if ( len )
  143.         movmem( r->recv_bufs, buffer, len );
  144.         return( len );
  145.     }
  146. }
  147.