home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / PPPBCKP / SRC15B19.ZIP / WATTSRC.ZIP / SRC / PCRECV.C < prev    next >
Text File  |  1994-11-28  |  5KB  |  199 lines
  1. #include <wattcp.h>
  2. #include <mem.h>
  3.  
  4. #define RECV_USED    0xf7e3d2b1L
  5. #define RECV_UNUSED  0xe6d2c1afL
  6.  
  7. typedef struct {
  8.     longword      recv_sig;
  9.     byte    *recv_bufs;
  10.     word     recv_bufnum;    /* for udp */
  11.     word     recv_len;    /* for tcp */
  12. } recv_data;
  13.  
  14. typedef struct {
  15.     longword     buf_sig;
  16.     longword     buf_hisip;
  17.     word         buf_hisport;
  18.     int         buf_len;
  19.     byte     buf_data[ 1500 ];
  20. } recv_buf;
  21.  
  22.  
  23. /*
  24.  *  recvd - gets upcalled when data arrives
  25.  */
  26. static int _recvdaemon( sock_type *s, byte *data, int len, tcp_PseudoHeader *ph, void *h)
  27. {
  28.     recv_data *r;
  29.     recv_buf *p;
  30.     tcp_Socket *t;
  31.     int i;
  32.     udp_Header *uh;
  33.  
  34.     /* check for length problem */
  35.     if ( !len || (len >= 1500 )) return( 0 );
  36.  
  37.     switch ( s->udp.ip_type ) {
  38.     case UDP_PROTO :r = (recv_data*)(s->udp.rdata);
  39.                         uh = (udp_Header *) h;
  40.             if (r->recv_sig != RECV_USED ) {
  41.                 outs("ERROR: udp recv data conflict");
  42.                 return( 0 );
  43.             }
  44.  
  45.             p = (recv_buf *)(r->recv_bufs);
  46.  
  47.             /* find a buffer */
  48.             for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  49.                 switch ( p->buf_sig ) {
  50.                 case RECV_USED   : break;
  51.                 case RECV_UNUSED :
  52.                     /* take this one */
  53.                     p->buf_sig = RECV_USED;
  54.                     p->buf_len = len;
  55.                     p->buf_hisip = ph->src;
  56.                                         p->buf_hisport = uh->srcPort;
  57.                     movmem( data, p->buf_data, len );
  58.                     return( 0 );
  59.                 default       :
  60.                     outs("ERROR: sock_recv_init data err");
  61.                     return( 0 );
  62.                 }
  63.             }
  64.                         break;
  65.     case TCP_PROTO :
  66.             t= (tcp_Socket*)s;
  67.             r = (recv_data*)(t->rdata);
  68.             if (r->recv_sig != RECV_USED ) {
  69.                 outs("ERROR: udp recv data conflict");
  70.                 return( 0 );
  71.             }
  72.  
  73.             /* stick it on the end if you can */
  74.             i = t->maxrdatalen - t->rdatalen;
  75.             if ( i > 1 ) {
  76.                 /* we can accept some of this */
  77.                 if ( len > i ) len = i;
  78.                 movmem( data, &r->recv_bufs[t->rdatalen], len );
  79.                 t->rdatalen += len;
  80.                 return( len );
  81.             }
  82.                         break;
  83.     }
  84.     return( 0 );    /* didn't take none */
  85. }
  86.  
  87.  
  88. int sock_recv_init( sock_type *s, void *space, word len )
  89. {
  90. /*    tcp_Socket *t; */
  91.     recv_buf *p;
  92.     recv_data *r;
  93.     int i;
  94.  
  95.     /* clear data area */
  96.     memset( p = space, 0, len );
  97.  
  98.     s->udp.dataHandler = (dataHandler_t)_recvdaemon;
  99.     /* clear table */
  100.     memset( r = (recv_data*) s->udp.rddata, 0, tcp_MaxBufSize );
  101.  
  102.     r->recv_sig = RECV_USED;
  103.     r->recv_bufs = (byte *) p;
  104.     r->recv_bufnum = len / sizeof( recv_buf );
  105.     r->recv_len = len;
  106.     if (s->udp.ip_type == UDP_PROTO )
  107.     for ( i = 0 ; i < r->recv_bufnum ; ++i, ++p )
  108.         p->buf_sig = RECV_UNUSED;
  109.     return( 0 );
  110. }
  111.  
  112. int sock_recv_from( sock_type *s, long *hisip, word *hisport, char *buffer, int len, word flags )
  113. {
  114.     tcp_Socket *t;
  115.     recv_data *r;
  116.     recv_buf *p;
  117.     int i;
  118. flags=flags;            /* get rid of warning */
  119.     r = (recv_data *) s->udp.rdata;
  120.     if (r->recv_sig != RECV_USED )
  121.     return( -1 );
  122.  
  123.     switch ( s->udp.ip_type ) {
  124.     case UDP_PROTO :
  125.         p = (recv_buf *) r->recv_bufs;
  126.  
  127.         /* find a buffer */
  128.         for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  129.         switch ( p->buf_sig ) {
  130.             case RECV_UNUSED:
  131.             break;
  132.             case RECV_USED  :
  133.             p->buf_sig = RECV_USED;
  134.             if ( len > p->buf_len ) len = p->buf_len;
  135.             movmem( p->buf_data, buffer, len );
  136.                         if (hisip) *hisip = p->buf_hisip;
  137.                         if (hisport) *hisport = p->buf_hisport;
  138.             p->buf_sig = RECV_UNUSED;
  139.             return( len );
  140.             default      :
  141.             outs("ERROR: sock_recv_init data err");
  142.             return( 0 );
  143.         }
  144.         }
  145.         return( 0 );
  146.     case TCP_PROTO :
  147.         t = (tcp_Socket *) s;
  148.         if ( len > t->rdatalen ) len = t->rdatalen;
  149.         if ( len )
  150.         movmem( r->recv_bufs, buffer, len );
  151.         return( len );
  152.     }
  153.     return( 0 );
  154. }
  155.  
  156. int sock_recv( sock_type *s, char *buffer, int len, word flags )
  157. {
  158.     tcp_Socket *t;
  159.     recv_data *r;
  160.     recv_buf *p;
  161.     int i;
  162.  
  163. flags=flags;            /* get rid of warning */
  164.     r = (recv_data *) s->udp.rdata;
  165.     if (r->recv_sig != RECV_USED )
  166.     return( -1 );
  167.  
  168.     switch ( s->udp.ip_type ) {
  169.     case UDP_PROTO :
  170.         p = (recv_buf *) r->recv_bufs;
  171.  
  172.         /* find a buffer */
  173.         for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  174.         switch ( p->buf_sig ) {
  175.             case RECV_UNUSED:
  176.             break;
  177.             case RECV_USED  :
  178.             p->buf_sig = RECV_USED;
  179.             if ( len > p->buf_len ) len = p->buf_len;
  180.             movmem( p->buf_data, buffer, len );
  181.             p->buf_sig = RECV_UNUSED;
  182.             return( len );
  183.             default      :
  184.             outs("ERROR: sock_recv_init data err");
  185.             return( 0 );
  186.         }
  187.         }
  188.         return( 0 );
  189.     case TCP_PROTO :
  190.         t = (tcp_Socket*) s;
  191.         if ( len > t->rdatalen ) len = t->rdatalen;
  192.         if ( len )
  193.         movmem( r->recv_bufs, buffer, len );
  194.         return( len );
  195.     }
  196.     return( 0 );
  197. }
  198.  
  199.