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