wattcp.h

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C头文件 代码 · 共 509 行 · 第 1/2 页

        BYTE   flags;
        WORD   window;
        WORD   checksum;
        WORD   urgent;
      } tcp_Header;

#define tcp_FlagFIN   0x01
#define tcp_FlagSYN   0x02
#define tcp_FlagRST   0x04
#define tcp_FlagPUSH  0x08
#define tcp_FlagACK   0x10
#define tcp_FlagURG   0x20
#define tcp_FlagMASK  0x3F

/*
 * The TCP/UDP Pseudo Header
 */
typedef struct tcp_PseudoHeader {
        DWORD  src;
        DWORD  dst;
        BYTE   mbz;
        BYTE   protocol;
        WORD   length;
        WORD   checksum;
      } tcp_PseudoHeader;

/*
 * Internet Group Management Protocol Packet
 */
typedef struct IGMP_packet {
        int    type    : 4;
        int    version : 4;
        BYTE   mbz;
        WORD   checksum;
        DWORD  address;
      } IGMP_packet;

#define IGMP_VERSION  1
#define IGMP_QUERY    1
#define IGMP_REPORT   2


/*
 * ARP/RARP headers
 */
typedef struct arp_Header {
        WORD        hwType;
        WORD        protType;
        BYTE        hwAddrLen;     /* MAC addr. length (6) */
        BYTE        protoAddrLen;  /* IP addr. length  (4) */
        WORD        opcode;
        eth_address srcEthAddr;
        DWORD       srcIPAddr;
        eth_address dstEthAddr;
        DWORD       dstIPAddr;
      } arp_Header;

#define rarp_Header arp_Header

/*
 * ARP definitions
 */
#define ARP_REQUEST    0x0100      /* ARP/RARP op codes, Request   */
#define ARP_REPLY      0x0200      /*                    Reply     */
#define RARP_REQUEST   0x0300
#define RARP_REPLY     0x0400
#define ARP_MAX        (sizeof(eth_Header) + sizeof(arp_Header))

#include <sys/packoff.h>           /* restore default packing */


/*
 * TCP states, from tcp specification RFC-793.
 * Note: close-wait state is bypassed by automatically closing a connection
 *       when a FIN is received.  This is easy to undo.
 */
#define tcp_StateLISTEN   0      /* listening for connection */
#define tcp_StateSYNSENT  1      /* SYN sent, active open */
#define tcp_StateSYNREC   2      /* SYN received, ACK+SYN sent. */
#define tcp_StateESTAB    3      /* established */
#define tcp_StateESTCL    4      /* established, but will FIN */
#define tcp_StateFINWT1   5      /* sent FIN */
#define tcp_StateFINWT2   6      /* sent FIN, received FINACK */
#define tcp_StateCLOSWT   7      /* received FIN waiting for close */
#define tcp_StateCLOSING  8      /* sent FIN, received FIN (waiting for FINACK) */
#define tcp_StateLASTACK  9      /* FIN received, FINACK+FIN sent */
#define tcp_StateTIMEWT   10     /* dally after sending final FINACK */
#define tcp_StateCLOSED   11     /* FINACK received */

#define tcp_MaxBufSize    2048   /* maximum bytes to buffer on input */
#define udp_MaxBufSize    tcp_MaxBufSize
#define tcp_MaxTxBufSize  tcp_MaxBufSize        /* and on tcp output */

/*
 * Fields common to UDP & TCP socket definition.
 * Tries to keep members on natural boundaries (words on word-boundary,
 * dwords on dword boundary)
 */

#define UDP_TCP_COMMON                                                      \
        WORD         ip_type;          /* UDP_PROTO or TCPPROTO */          \
        BYTE         ttl;              /* Time To Live */                   \
        BYTE         fill_1;                                                \
        const char  *err_msg;          /* null when all is ok */            \
        void       (*usr_yield)(void); /* yield while waiting */            \
        sol_upcall   sol_callb;        /* socket-layer callback (icmp) */   \
        BYTE         rigid;                                                 \
        BYTE         stress;                                                \
        WORD         sockmode;         /* a logical OR of bits */           \
        DWORD        usertimer;        /* ip_timer_set, ip_timer_timeout */ \
        ProtoHandler protoHandler;     /* call with incoming data */        \
        eth_address  hisethaddr;       /* peer's ethernet address */        \
        WORD         fill_2;                                                \
                                                                            \
        DWORD        myaddr;           /* my ip-address */                  \
        DWORD        hisaddr;          /* peer's internet address */        \
        WORD         hisport;          /* peer's source port */             \
        WORD         myport;           /* my source port */                 \
        WORD         locflags;         /* local option flags */             \
        WORD         fill_3;                                                \
                                                                            \
        UINT         queuelen;         /* optional Tx queue length */       \
        const BYTE  *queue;                                                 \
                                                                            \
        int          rdatalen;         /* Rx length, must be signed */      \
        UINT         maxrdatalen;                                           \
        BYTE        *rdata;                    /* received data pointer */  \
        BYTE         rddata[tcp_MaxBufSize+1]; /* received data buffer */   \
        DWORD        safetysig                 /* magic marker */

/*
 * UDP socket definition
 */
typedef struct udp_Socket {
        struct udp_Socket *next;
        UDP_TCP_COMMON;
      } udp_Socket;

/*
 * TCP Socket definition (fields common to udp_Socket must come first)
 */
typedef struct tcp_Socket {
        struct  tcp_Socket *next;  /* link to next tcp-socket */
        UDP_TCP_COMMON;

        UINT   state;              /* tcp connection state */
        DWORD  acknum;             /* data ACK'ed */
        DWORD  seqnum;             /* sequence number */

#if defined(USE_DEBUG)
        DWORD  last_acknum[2];     /* for pcdbug.c; to follow SEQ/ACK */
        DWORD  last_seqnum[2];     /* increments */
#endif

        DWORD  timeout;            /* timeout, in milliseconds */
        BYTE   unhappy;            /* flag, indicates retransmitting segt's */
        BYTE   recent;             /* 1 if recently transmitted */
        WORD   flags;              /* tcp flags for last packet sent */

        UINT   window;             /* other guy's window */
        UINT   datalen;            /* number of bytes of data to send */
        int    unacked;            /* unacked data, must be signed */

        BYTE   cwindow;            /* Congestion window */
        BYTE   wwindow;            /* Van Jacobson's algorithm */
        WORD   fill_4;

        DWORD  vj_sa;              /* VJ's alg, standard average   (SRTT) */
        DWORD  vj_sd;              /* VJ's alg, standard deviation (RTTVAR) */
        DWORD  vj_last;            /* last transmit time */
        UINT   rto;                /* retransmission timeout */
        BYTE   karn_count;         /* count of packets */
        BYTE   tos;                /* priority */
        WORD   fill_5;

        DWORD  rtt_time;           /* Round Trip Time value */
        DWORD  rtt_lasttran;       /* RTT at last transmission */

        DWORD  ts_sent;            /* last TimeStamp value sent */
        DWORD  ts_recent;          /* last TimeStamp value received */
        DWORD  ts_echo;            /* last TimeStamp echo received */

        UINT   max_seg;
        DWORD  missed_seg[2];      /* S. Lawson - handle one dropped segment */
        DWORD  inactive_to;        /* for the inactive flag */
        DWORD  datatimer;          /* EE 99.08.23, note broken connections */
        int    sock_delay;

        BYTE   send_wscale;        /* to-do!!: window scales shifts, tx/rx */
        BYTE   recv_wscale;

        BYTE   data[tcp_MaxBufSize+1]; /* data for transmission */
        DWORD  safetytcp;              /* extra magic marker */
      } tcp_Socket;


/*
 * Raw IP socket definition. Only used in BSD-socket API.
 */
typedef struct raw_Socket {
        struct raw_Socket *next;
        WORD   ip_type;               /* same ofs as for udp/tcp Socket */
        BOOL   used;                  /* used flag; packet not read yet */
        struct in_Header ip;
        BYTE   data [MAX_FRAG_SIZE];  /* room for 1 jumbo IP packet */
      } raw_Socket;

/*
 * sock_type used for socket I/O
 */
typedef union sock_type {
        udp_Socket udp;
        tcp_Socket tcp;
        raw_Socket raw;
      } sock_type;

typedef struct watt_sockaddr {
        WORD   s_type;
        WORD   s_port;
        DWORD  s_ip;
        BYTE   s_spares[6];    /* unused in TCP realm */
      } watt_sockaddr;

/*
 * A simple RTT cache based on Phil Karn's KA9Q.
 * # of TCP round-trip-time cache entries
 */
#define RTTCACHE  16  

struct tcp_rtt {
       DWORD ip;
       UINT  rto;
     };

/*
 * Stuff for Multicast Support - JRM 6/7/93
 */
#define CLASS_D_MASK  0xE0000000UL  /* the mask that defines IP Class D  */
#define IPMULTI_MASK  0x007FFFFFUL  /* to get the low-order 23 bits      */
#define ETH_MULTI     0x01005EUL    /* high order bits of multi eth addr */
#define IPMULTI_SIZE  20            /* the size of the ipmulti table     */
#define ALL_SYSTEMS   0xE0000001UL  /* the default mcast addr 224.0.0.1  */

typedef struct multicast {
        DWORD       ina;            /* IP address of group               */
        eth_address ethaddr;        /* Ethernet address of group         */
        BYTE        processes;      /* number of interested processes    */
        DWORD       replytime;      /* IGMP query reply timer            */
        BYTE        active;         /* is this an active entry           */
      } multicast;

#endif /* __WATTCP_H */