home *** CD-ROM | disk | FTP | other *** search
/ Super Net 1 / SUPERNET_1.iso / PC / OTROS / MSDOS / WATTCP / WNWATTCP.ZIP / INCLUDE / WATTCP.H < prev   
Encoding:
C/C++ Source or Header  |  1992-02-07  |  12.8 KB  |  440 lines
  1. #define WATTCPH
  2.  
  3. /*
  4. #define DEBUG
  5. */
  6. /*
  7. #define MoveW( a , b, c ) movmem( a, b,c )
  8. #define busyouta(c) (putch(c))
  9. */
  10.  
  11.  
  12. #include <stdio.h>
  13. #include <elib.h>
  14.  
  15. #define set_mstimeout( x ) (set_timeout(0)+ (x / 55))
  16.  
  17. #define MAX_GATE_DATA 12
  18. #define MAX_NAMESERVERS 10
  19. #define MAX_COOKIES 10
  20. #define MAX_STRING 50    /* most strings are limited */
  21.  
  22. #define MAXBUFS        5       /* maximum number of Ethernet buffers */
  23. #undef  BUFSIZE
  24. #define BUFSIZE        1500
  25.  
  26. #define MAXVJSA     1440 /* 10 s */
  27. #define MAXVJSD     360  /* 10 s */
  28. #define SAFETYTCP  0x538f25a3L
  29. #define SAFETYUDP  0x3e45e154L
  30. #define TRUE        1
  31. #define true        TRUE
  32. #define FALSE       0
  33. #define false       FALSE
  34.  
  35. /* These are Ethernet protocol numbers but I use them for other things too */
  36. #define UDP_PROTO  0x11
  37. #define TCP_PROTO  0x06
  38. #define ICMP_PROTO 0x01
  39.  
  40. #define TCP_MODE_BINARY  0       /* default mode */
  41. #define TCP_MODE_ASCII   1
  42. #define UDP_MODE_CHK     0       /* default to having checksums */
  43. #define UDP_MODE_NOCHK   2       /* turn off checksums */
  44. #define TCP_MODE_NAGLE   0       /* Nagle algorithm */
  45. #define TCP_MODE_NONAGLE 4
  46.  
  47.  
  48. typedef int (*procref)();
  49.  
  50. typedef unsigned long longword;     /* 32 bits */
  51. typedef unsigned short word;        /* 16 bits */
  52. typedef unsigned char byte;         /*  8 bits */
  53. typedef byte eth_address[6];
  54.  
  55. /* Structure containing all vairables referenced by the packet */
  56. /* driver.  Putting them all in 1 struct makes it easier to map */
  57. /* them when running under Windows. */
  58. struct pkt_struct {
  59.     word ip_type;
  60.     word arp_type;
  61.     byte eth_addr[ 6 ];
  62.     byte send_buf[14 + BUFSIZE];    /* 6 src, 6 dest, 2 type = 14 */
  63.     byte buf[MAXBUFS][ BUFSIZE + 2 ]; /* 1st byte is busy flag, 2nd spare */
  64. };
  65.  
  66. /* undesirable */
  67. extern longword MsecClock();
  68. #define clock_ValueRough() MsecClock()
  69.  
  70. #define TICKS_SEC 18
  71.  
  72. #define checksum( p, len) inchksum( p, len )
  73.  
  74. #define PD_ETHER 1
  75. #define PD_SLIP  6
  76.  
  77. extern word sock_inactive;      /* in pcbootp.c */
  78. extern word _pktdevclass;
  79. extern word _mss;
  80. extern word _bootptimeout;    /* in pcbootp.c */
  81. extern longword _bootphost;    /* in pcbootp.c */
  82. extern word _bootpon;
  83.  
  84. /* The Ethernet header */
  85. typedef struct {
  86.     eth_address     destination;
  87.     eth_address     source;
  88.     word            type;
  89. } eth_Header;
  90.  
  91. /* The Internet Header: */
  92. typedef struct {
  93.     unsigned        hdrlen  : 4;
  94.     unsigned        ver     : 4;
  95.     byte        tos;
  96.     word            length;
  97.     word            identification;
  98.     word            frag;
  99.     byte        ttl;
  100.     byte        proto;
  101.     word            checksum;
  102.     longword        source;
  103.     longword        destination;
  104. } in_Header;
  105.  
  106.  
  107. #ifdef WATTCPH
  108. #define in_GetVersion(ip) ( (ip)->ver )
  109. #define in_GetHdrlen(ip)  ( (ip)->hdrlen )  /* 32 bit word size */
  110. #define in_GetHdrlenBytes(ip)  ( in_GetHdrlen(ip) << 2 ) /* 8 bit byte size */
  111. #define in_GetTos(ip)      ( (ip)->tos)
  112.  
  113. #define in_GetTTL(ip)      ((ip)->ttl)
  114. #define in_GetProtocol(ip) ((ip)->proto )
  115.  
  116. #else
  117. /*
  118. #define in_GetVersion(ip) (((ip)->vht >> 12) & 0xf)
  119. #define in_GetHdrlen(ip)  (((ip)->vht >> 8) & 0xf)
  120. #define in_GetHdrlenBytes(ip)  (((ip)->vht >> 6) & 0x3c)
  121. #define in_GetTos(ip)      ((ip)->vht & 0xff)
  122.  
  123. #define in_GetTTL(ip)      ((ip)->ttlProtocol >> 8)
  124. #define in_GetProtocol(ip) ((ip)->ttlProtocol & 0xff)
  125. */
  126. #endif WATTCPH
  127. typedef struct {
  128.     word        srcPort;
  129.     word        dstPort;
  130.     word        length;
  131.     word        checksum;
  132. } udp_Header;
  133.  
  134. #define UDP_LENGTH ( sizeof( udp_Header ))
  135.  
  136. typedef struct {
  137.     word            srcPort;
  138.     word            dstPort;
  139.     longword        seqnum;
  140.     longword        acknum;
  141.     word            flags;
  142.     word            window;
  143.     word            checksum;
  144.     word            urgentPointer;
  145. } tcp_Header;
  146.  
  147.  
  148. /*
  149. #ifdef WATTCPH
  150. #define tcp_FlagFIN     0x0100
  151. #define tcp_FlagSYN     0x0200
  152. #define tcp_FlagRST     0x0400
  153. #define tcp_FlagPUSH    0x0800
  154. #define tcp_FlagACK     0x1000
  155. #define tcp_FlagURG     0x2000
  156. #define tcp_FlagDO      0x00F0
  157. #define tcp_GetDataOffset(tp) ((tp)->flags >> 4)
  158. #else
  159. */
  160. #define tcp_FlagFIN     0x0001
  161. #define tcp_FlagSYN     0x0002
  162. #define tcp_FlagRST     0x0004
  163. #define tcp_FlagPUSH    0x0008
  164. #define tcp_FlagACK     0x0010
  165. #define tcp_FlagURG     0x0020
  166. #define tcp_FlagDO      0xF000
  167. #define tcp_GetDataOffset(tp) (intel16((tp)->flags) >> 12)
  168. /*
  169. #endif WATTCPH
  170. */
  171. /* The TCP/UDP Pseudo Header */
  172. typedef struct {
  173.     longword    src;
  174.     longword    dst;
  175.     byte        mbz;
  176.     byte        protocol;
  177.     word        length;
  178.     word        checksum;
  179. } tcp_PseudoHeader;
  180.  
  181. /*
  182.  * TCP states, from tcp manual.
  183.  * Note: close-wait state is bypassed by automatically closing a connection
  184.  *       when a FIN is received.  This is easy to undo.
  185.  */
  186. #define tcp_StateLISTEN  0      /* listening for connection */
  187. #define tcp_StateSYNSENT 1      /* syn sent, active open */
  188. #define tcp_StateSYNREC  2      /* syn received, synack+syn sent. */
  189. #define tcp_StateESTAB   3      /* established */
  190. #define tcp_StateESTCL   4      /* established, but will FIN */
  191. #define tcp_StateFINWT1  5      /* sent FIN */
  192. #define tcp_StateFINWT2  6      /* sent FIN, received FINACK */
  193. #define tcp_StateCLOSWT  7      /* received FIN waiting for close */
  194. #define tcp_StateCLOSING 8      /* sent FIN, received FIN (waiting for FINACK) */
  195. #define tcp_StateLASTACK 9      /* fin received, finack+fin sent */
  196. #define tcp_StateTIMEWT  10     /* dally after sending final FINACK */
  197. #define tcp_StateCLOSEMSL 11
  198. #define tcp_StateCLOSED  12     /* finack received */
  199.  
  200. #define tcp_MaxBufSize 2048         /* maximum bytes to buffer on input */
  201.  
  202.  
  203.  
  204. /*
  205.  * UDP socket definition
  206.  */
  207. typedef struct _udp_socket {
  208.     struct _udp_socket *next;
  209.     word        ip_type;        /* always set to UDP_PROTO */
  210.     char       *err_msg;        /* null when all is ok */
  211.     void      (*usr_yield)();
  212.     word        sock_mode;            /* a logical OR of bits */
  213.     longword        usertimer;        /* ip_timer_set, ip_timer_timeout */
  214.     procref        dataHandler;
  215.     eth_address     hisethaddr;        /* peer's ethernet address */
  216.     longword        hisaddr;        /* peer's internet address */
  217.     word        hisport;        /* peer's UDP port */
  218.     word        myport;
  219.  
  220.     int             queuelen;
  221.     byte           *queue;
  222.  
  223.     int             rdatalen;           /* must be signed */
  224.     byte        rdata[ tcp_MaxBufSize + 1];        /* if dataHandler = 0, len == 512 */
  225.     longword        safetysig;
  226. } udp_Socket;
  227. /*
  228.  * TCP Socket definition
  229.  */
  230.  
  231.  
  232. typedef struct _tcp_socket {
  233.     struct _tcp_socket *next;
  234.     word        ip_type;        /* always set to TCP_PROTO */
  235.     char        *err_msg;
  236.     void      (*usr_yield)();
  237.     word        sock_mode;        /* a logical OR of bits */
  238.  
  239.     longword        usertimer;        /* ip_timer_set, ip_timer_timeout */
  240.     procref         dataHandler;    /* called with incoming data */
  241.     eth_address     hisethaddr;     /* ethernet address of peer */
  242.     longword        hisaddr;        /* internet address of peer */
  243.     word            hisport;        /* tcp ports for this connection */
  244.     word        myport;
  245.  
  246.     int             queuelen;
  247.     byte           *queue;
  248.  
  249.     int             rdatalen;       /* must be signed */
  250.     byte        rdata[tcp_MaxBufSize+1];    /* received data */
  251.     longword        safetysig;
  252.     word        rmaxdatalen;    /* normally tcp_MaxBufSize */
  253.     word        state;          /* connection state */
  254.  
  255.     longword        acknum;
  256.     longword        seqnum;         /* data ack'd and sequence num */
  257.     long            timeout;        /* timeout, in milliseconds */
  258.     byte            unhappy;        /* flag, indicates retransmitting segt's */
  259.     byte            recent;         /* 1 if recently transmitted */
  260.     word            flags;          /* tcp flags word for last packet sent */
  261.  
  262.     word        window;        /* other guy's window */
  263.     int         datalen;        /* number of bytes of data to send */
  264.                     /* must be signed */
  265.     int             unacked;        /* unacked data */
  266.  
  267.     byte        cwindow;        /* Van Jacobson's algorithm */
  268.     byte        wwindow;
  269.  
  270.     word        vj_sa;        /* VJ's alg, standard average */
  271.     word        vj_sd;        /* VJ's alg, standard deviation */
  272.     longword        vj_last;        /* last transmit time */
  273.     word        rto;
  274.     byte        karn_count;        /* count of packets */
  275.  
  276.     /* retransmission timeout proceedure */
  277.     /* these are in clock ticks */
  278.     longword        rtt_lasttran;       /* last transmission time */
  279.     longword        rtt_smooth;         /* smoothed round trip time */
  280.     longword        rtt_delay;          /* delay for next transmission */
  281.     longword        rtt_time;           /* time of next transmission */
  282.  
  283.     word            mss;
  284.     longword        inactive_to;           /* for the inactive flag */
  285.  
  286.     byte            data[tcp_MaxBufSize+1]; /* data to send */
  287. } tcp_Socket;
  288.  
  289. /* sock_type used for socket io */
  290. typedef union {
  291.     udp_Socket udp;
  292.     tcp_Socket tcp;
  293. } sock_type;
  294.  
  295. /* similar to UNIX */
  296. typedef struct sockaddr {
  297.     word        s_type;
  298.     word        s_port;
  299.     longword    s_ip;
  300.     byte        s_spares[6];    /* unused in TCP realm */
  301. };
  302.  
  303. extern longword my_ip_addr;
  304. extern eth_address _eth_addr;
  305. extern eth_address _eth_brdcast;
  306. extern longword sin_mask;
  307. extern word sock_delay;
  308.  
  309. /*
  310.  * ARP definitions
  311.  */
  312. #ifdef WATTCPH
  313. #define arp_TypeEther  0x100        /* ARP type of Ethernet address */
  314. #else
  315. #define arp_TypeEther  0x1        /* ARP type of Ethernet address */
  316. #endif WATTCPH
  317.  
  318. /* harp op codes */
  319. #ifdef WATTCPH
  320. #define ARP_REQUEST 0x0100
  321. #define ARP_REPLY   0x0200
  322. #else
  323. #define ARP_REQUEST 1
  324. #define ARP_REPLY   2
  325. #endif WATTCPH
  326.  
  327. /*
  328.  * Arp header
  329.  */
  330. typedef struct {
  331.     word            hwType;
  332.     word            protType;
  333.     word            hwProtAddrLen;  /* hw and prot addr len */
  334.     word            opcode;
  335.     eth_address     srcEthAddr;
  336.     longword        srcIPAddr;
  337.     eth_address     dstEthAddr;
  338.     longword        dstIPAddr;
  339. } arp_Header;
  340.  
  341. #define ETH_MSS 1400  /* MSS for Ethernet */
  342.  
  343. /*
  344.  * Ethernet interface:
  345.  */
  346.  
  347. void  _eth_init();
  348. byte *_eth_formatpacket( void *eth_dest, word eth_type );
  349. int   _eth_send( word len);
  350. void  _eth_free( void *buf);
  351. byte *_eth_arrived( word *type_ptr);
  352. void  _eth_release();
  353. void *_eth_hardware(byte *p);
  354.  
  355. void ip_timer_init();
  356. int  ip_timer_expired();
  357.  
  358. /*
  359.  * socket macros
  360.  */
  361.  
  362. /*
  363.  * sock_wait_established()
  364.  *    - waits then aborts if timeout on s connection
  365.  * sock_wait_input()
  366.  *    - waits for received input on s
  367.  *    - may not be valid input for sock_Gets... check returned length
  368.  * sock_tick()
  369.  *    - do tick and jump on abort
  370.  * sock_wait_closed();
  371.  *    - discards all received data
  372.  *
  373.  * jump to sock_err with contents of *statusptr set to
  374.  *     1 on closed
  375.  *    -1 on timeout
  376.  *
  377.  */
  378.  
  379. _ip_delay0( sock_type *s, int timeoutseconds, procref fn, int *statusptr );
  380. _ip_delay1( sock_type *s, int timeoutseconds, procref fn, int *statusptr );
  381. _ip_delay2( sock_type *s, int timeoutseconds, procref fn, int *statusptr );
  382.  
  383. #define sock_wait_established( s, seconds, fn, statusptr ) \
  384.     if (_ip_delay0( s, seconds, fn, statusptr )) goto sock_err;
  385. #define sock_wait_input( s, seconds, fn , statusptr ) \
  386.     if (_ip_delay1( s, seconds, fn, statusptr )) goto sock_err;
  387. #define sock_tick( s, statusptr ) \
  388.     if ( !tcp_tick(s)) { *statusptr = 1 ; goto sock_err; }
  389. #define sock_wait_closed(s, seconds, fn, statusptr )\
  390.     if (_ip_delay2( s, seconds, fn, statusptr )) goto sock_err;
  391.  
  392. /* in UDP_NDS.C */
  393. longword resolve();
  394.  
  395. extern int _last_cookie;
  396. extern longword _cookie[MAX_COOKIES];
  397.  
  398. extern char *def_domain;
  399. extern longword def_nameservers[MAX_NAMESERVERS];
  400. extern int _last_nameserver;
  401. extern char *_hostname;
  402.  
  403. word isaddr( char *string );
  404. longword aton( char *string );
  405.  
  406.  
  407. int _ping( longword host , longword countnum );
  408. longword _chk_ping( longword host , longword *ptr);
  409. void _arp_register( longword use, longword instead_of );
  410. _arp_resolve( longword ina, eth_address *ethap);
  411.  
  412. void * _pkt_eth_init();
  413. pkt_release();
  414. int pkt_send( char *buffer, int length );
  415. pkt_buf_wipe();
  416. pkt_buf_release( char *ptr );
  417. void * pkt_received();
  418.  
  419.  
  420.  
  421. void _add_server( int *counter, int max, longword *array, longword value );
  422. extern word debug_on;
  423. char *rip( char *s);
  424. _chk_socket( tcp_Socket *s );
  425. char *inet_ntoa( char *s, longword x );
  426. char *psocket( tcp_Socket *s );
  427. longword inet_addr( char *s );
  428. char *sockerr( tcp_Socket *s );
  429. char *sockstate( tcp_Socket *s );
  430. getpeername( tcp_Socket *s, void *dest, int *len );
  431. getsockname(  tcp_Socket *s, void *dest, int *len );
  432. longword gethostid();
  433. longword sethostid( longword ip );
  434. char *getdomainname( char *name, int length );
  435. char *setdomainname( char *string );
  436. word ntohs( word a );
  437. word htons( word a );
  438. longword ntohl( longword x );
  439. longword htonl( longword x );
  440.