home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / DataScope 2.0.3 / DataScope2l / TCPIncludes / protocol.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-04  |  10.2 KB  |  406 lines  |  [TEXT/MPS ]
  1. /*
  2. *    Protocol structures for network communication
  3. *
  4. *  This file contains the structure definitions for each type of 
  5. *  protocol that this program wishes to handle.  A companion file,
  6. *  'protinit.c' initializes sample versions of each type of header, 
  7. *  improving the efficiency of sending packets with constants in most
  8. *  of the fields.
  9. * 
  10. */
  11.  
  12. #include "whatami.h"
  13.  
  14. /************************************************************************/
  15. /*  Ethernet frames
  16. *      All Ethernet transmissions should use this Ethernet header which
  17. *   denotes what type of packet is being sent.
  18. *
  19. *   The header is 14 bytes.  The first 6 bytes are the target's hardware
  20. *   Ethernet address, the second 6 are the sender's hardware address and
  21. *   the last two bytes are the packet type.  Some packet type definitions
  22. *   are included here.
  23. *
  24. *   the two-byte packet type is byte-swapped, PC is lo-hi, Ether is hi-lo
  25. */
  26.  
  27.  
  28. #ifdef PC
  29. #define  EXNS  0x0006           /* probably need swapping */
  30. #define  EIP   0x0008
  31. #define  EARP  0x0608
  32. #define  ERARP    0x3580            /* I guess this is RARP */
  33. #define  ECHAOS  0x0408
  34. #else
  35. #define  EXNS  0x0600           /* these don't need swapping */
  36. #define  EIP   0x0800
  37. #define  EARP  0x0806
  38. #define  ERARP    0x8035
  39. #define  ECHAOS  0x0804
  40. #endif
  41.  
  42. struct ether {
  43.     uint8 
  44.         dest[DADDLEN],                /* where the packet is going */
  45.         me[DADDLEN];                /* who am i to send this packet */
  46.  
  47.     uint16 
  48.         type;                        /* Ethernet packet type  */
  49. };
  50.  
  51. typedef struct ether DLAYER;
  52.  
  53.  
  54. #ifdef notneededanymore
  55.  
  56. #define    EIP        22
  57. #define EARP    23
  58. #define IPSock    72                     /* Later Change to random */
  59.  
  60. struct aTalk {
  61.     uint16 count;
  62.     uint8
  63.          dest[DADDLEN],    /* where the packet is going */
  64.          me[DADDLEN],
  65.         type, paddingchar;        /* Give an even length so we will be at even */
  66.     };
  67.  
  68. typedef struct aTalk DLAYER;
  69.  
  70. #endif
  71.  
  72. /*************************************************************************/
  73. /*  Dave Plummer's  Address Resolution Protocol (ARP) (RFC-826) and 
  74. *   Finlayson, Mann, Mogul and Theimer's Reverse ARP packets.
  75. *
  76. *   Note that the 2 byte ints are byte-swapped.  The protocols calls for
  77. *   in-order bytes, and the PC is lo-hi ordered.
  78. *   
  79. */
  80.  
  81. #define RARPR    0x0004          /*  RARP reply, from host, needs swap */
  82. #define RARPQ    0x0003            /*  RARP request, needs swapping */
  83. #define ARPREP  0x0002          /*  reply, byte swapped when used */
  84. #define ARPREQ  0x0001          /*  request, byte-swapped when used */
  85. #define ARPPRO    0x0800            /*  IP protocol, needs swapping */
  86.  
  87. #define HTYPE     0x0001            /*  Ethernet hardware type, needs swapping */
  88.  
  89. #ifdef noATALKanymore
  90. #define HTYPE    0x0003          /*  Appletalk, will not be swapped */
  91. #endif
  92.  
  93. struct plummer {
  94.     DLAYER d;                 /* data link layer packet header */
  95.  
  96.     uint16
  97.             hrd,            /* hardware type, Ethernet = 1 */
  98.             pro;            /* protocol type to resolve for */
  99.     uint8    
  100.             hln,            /* byte length of hardware addr = 6 for ETNET */
  101.             pln;            /* byte length of protocol = 4 for IP */
  102.     uint16
  103.             op;            /* opcode, request = 1, reply = 2, RARP = 3,4 */
  104.     uint8
  105.             sha[DADDLEN],
  106.             spa[4],
  107.             tha[DADDLEN],
  108.             tpa[4];
  109. /*
  110. *   the final four fields (contained in 'rest') are:
  111. *      sender hardware address:   sha       hln bytes
  112. *      sender protocol address:   spa       pln bytes
  113. *      target hardware address:   tha       hln bytes
  114. *      target protocol address:   tpa       pln bytes
  115. */
  116. };
  117.  
  118. typedef struct plummer ARPKT;
  119.  
  120. /***********************************************************************/
  121. /*  ARP cache
  122. *   Data structure for saving low-level information until needed
  123. */
  124. struct acache {
  125.     uint8
  126.         hrd[DADDLEN],            /* hardware address for this IP address */
  127.         ip[4],                    /* the IP # in question */
  128.         gate;                    /* is this a gateway? */
  129.     int32 
  130.         tm;                        /* time information */
  131. };
  132.  
  133. /***********************************************************************/
  134. /*   Internet protocol
  135. *
  136. */
  137. struct iph {
  138.  
  139.     uint8
  140.         versionandhdrlen;
  141.                             /* I prefer to OR them myself */
  142.                             /* each half is four bits */
  143.     uint8 
  144.         service;            /* type of service for IP */
  145.     uint16
  146.         tlen,                /* total length of IP packet */
  147.         ident,                /* these are all BYTE-SWAPPED! */
  148.         frags;                /* combination of flags and value */
  149.  
  150.     uint8
  151.         ttl,                /* time to live */
  152.         protocol;            /* higher level protocol type */
  153.  
  154.     uint16
  155.         check;                /* header checksum, byte-swapped */
  156.  
  157.     uint8 
  158.         ipsource[4],        /* IP addresses */
  159.         ipdest[4];
  160.  
  161. };
  162.  
  163. typedef struct iph IPLAYER;
  164.  
  165. /*  
  166. *  full IP packet, with data and ip header
  167. */
  168.  
  169. struct ip {
  170.     DLAYER d;
  171.     IPLAYER i;
  172.  
  173.     union {
  174.         uint8 
  175.             data[536];            /* largest recommended, may include options */
  176.         uint8
  177.             options[40];
  178.     } x;
  179. };
  180.  
  181. typedef struct ip IPKT;
  182.  
  183. #define PROTUDP        17
  184. #define PROTTCP        6        /* standard protocol types for IP */
  185. #define PROTICMP    1
  186. /************************************************************************/
  187. /* ICMP packet
  188. *  all of them are of a similar form, some generic fields are spec'd here.
  189. */
  190. struct icmph {
  191.     uint8
  192.         type,                /* ICMP type field */
  193.         code;                /* ICMP code field */
  194.     uint16 
  195.         check,              /* checksum */
  196.         part1,part2;        /* depends on type and code */
  197. };
  198.  
  199. typedef struct icmph ICMPLAYER;
  200.  
  201. struct icmp {
  202.     DLAYER d;
  203.     IPLAYER i;
  204.     ICMPLAYER c;
  205.     uint8 
  206.         data[ICMPMAX];
  207. };
  208.  
  209. typedef struct icmp ICMPKT;
  210.  
  211. /**************************************************************************/
  212. /*  TCP protocol
  213. *      define both headers required and create a data type for a typical
  214. *      outgoing TCP packet (with IP header)
  215. *   
  216. *  Note:  So far, there is no way to handle IP options fields
  217. *    which are associated with a TCP packet.  They are mutually exclusive
  218. *    for both receiving and sending.  Support may be added later.
  219. *
  220. *   The tcph and iph structures can be included in many different types of
  221. *   arbitrary data structures and will be the basis for generic send and
  222. *   receive subroutines later.  For now, the packet structures are optimized 
  223. *   for packets with no options fields.  (seems to be almost all of them from
  224. *   what I've observed.
  225. */
  226.  
  227. struct tcph {
  228.     uint16 
  229.         source,dest;            /* TCP port numbers, all byte-swapped */
  230.     uint32 
  231.         seq,ack;                /* sequence, ACK numbers */
  232.     uint8
  233.         hlen,                        /* length of TCP header in 4 byte words */
  234.         flags;                    /* flag fields */
  235.     uint16
  236.         window,                    /* advertised window, byte-swapped */
  237.         check,                    /* TCP checksum of whole packet */
  238.         urgent;                    /* urgent pointer, when flag is set */
  239. };
  240.  
  241. typedef struct tcph TCPLAYER;
  242.  
  243. /*
  244. *  used for computing checksums in TCP
  245. */
  246. struct pseudotcp {
  247.     uint8 
  248.         source[4],dest[4],        /* IP #'s for source,dest */
  249.         z,proto;                /* zero and protocol number */
  250.     uint16 
  251.         tcplen;                    /* byte-swapped length field */
  252. };
  253.  
  254. struct tcp {
  255.     DLAYER d;
  256.     IPLAYER i;
  257.     TCPLAYER t;
  258.  
  259.     union {
  260.         uint8 
  261.             options[40];        /* not very likely, except on SYN */
  262.         uint8 
  263.             data[TMAXSIZE];    /* largest TCP data we will use */
  264.     } x;
  265. };
  266.  
  267. typedef struct tcp TCPKT;
  268.  
  269. /* 
  270. *  flag field definitions, first two bits undefined
  271. */
  272.  
  273. #define TURG    0x20
  274. #define TACK    0x10
  275. #define TPUSH    0x08
  276. #define TRESET    0x04
  277. #define TSYN    0x02
  278. #define TFIN    0x01
  279.  
  280. /*************************************************************************/
  281. /*   TCP queuing
  282. *   data types for all TCP queuing operations
  283. *   Each open port will have one of these structures assigned to it.
  284. */
  285.  
  286. struct window {
  287.     uint32    
  288.         nxt,                /* sequence number, not byte-swapped */
  289.         ack;                /* what the other machine acked */
  290.     int32
  291.         lasttime;            /* (signed) used for timeout checking */
  292.     uint8
  293.         where[WINDOWSIZE],    /* storage for queue */
  294.         *endbuf,            /* set to end of queue */
  295.         *base,                /* where useful data is in queue */
  296.         *endlim,            /* first spot in queue to add more data */
  297.         push;                /* flag for TCP push */
  298.     uint
  299.         size,                /* size of window advertised */
  300.         port,                /* port numbers from one host or another */
  301.         contain;            /* how many bytes in queue? */
  302. };
  303.  
  304. struct port {
  305.     struct window in,out;
  306.     TCPKT tcpout;                /* pre-initialized as much as possible */
  307.     uint8 state;                /* connection state */
  308.     struct pseudotcp tcps;        /* pseudo-tcp for checksumming */
  309.     int
  310.         credit,                    /* choked-down window for fast hosts */
  311.         sendsize,                /* MTU value for this connection */
  312.         rto;                    /* retrans timeout */
  313. };
  314.  
  315.  
  316. /*************************************************************************/
  317. /*  TCP states
  318. *     each connection has an associated state in the connection flow.
  319. *     the order of the states now matters, those less than a certain
  320. *     number are the "inactive" states.
  321. */
  322. #define SCLOSED 1
  323. #define SLISTEN 2
  324. #define STWAIT    3
  325. #define SSYNR   4
  326. #define SSYNS    5
  327. #define SEST    6
  328. #define SCWAIT    10
  329. #define SFW1    7
  330. #define SFW2    8
  331. #define SCLOSING 9
  332. #define SLAST    11
  333.  
  334. /*
  335. *     services which we will want to use
  336. */
  337. #define HFTP    21
  338. #define HTELNET    23
  339. #define HNAME    42
  340. #define HSUNRPC    111
  341. #define HPRINTER 515
  342.  
  343. /*************************************************************************/
  344. /*  UDP
  345. *   User Datagram Protocol
  346. *   Each packet is an independent datagram, no sequencing information
  347. *
  348. *   UDP uses the identical checksum to TCP
  349. */
  350.  
  351. struct udph {
  352.     uint16
  353.         source,dest;        /* port numbers, all byte-swapped */
  354.     uint16
  355.         length,                /* length of packet, including hdr */
  356.         check;                /* TCP checksum of whole packet */
  357. };
  358.  
  359. typedef struct udph UDPLAYER;
  360.  
  361. struct udp {
  362.     DLAYER d;
  363.     IPLAYER i;
  364.     UDPLAYER u;
  365.     uint8 
  366.         data[UMAXLEN];      /* largest UDP data we will use */
  367. };
  368.  
  369. typedef struct udp UDPKT;
  370.  
  371. struct uport {
  372.     UDPKT udpout;
  373.     struct pseudotcp tcps;        /* pseudo-tcp for checksumming */
  374.     uint16
  375.         listen,                    /* what port should this one listen to? */
  376.         length;                    /* how much data arrived in last packet? */
  377.     uint8 
  378.         data[UMAXLEN],            /* incoming, last datagram of that type */
  379.         who[4],                    /* who sent it to me ? */
  380.         stale;                    /* have we read this packet yet? */
  381. };
  382.  
  383. /*************************************************************************/
  384. /*  event queue
  385. *   records what happens, especially errors, and keeps them for any
  386. *   routines that poll, looking for what happened.
  387. *   Eight event classes are masked in the event class byte.
  388. *    There can be 256 event types per class.
  389. *   The data field is handled differently by each event type.
  390. */
  391. struct eq {
  392.     uint8
  393.         eclass,            /* class, defined in netevent.h */
  394.         event;            /* which event */
  395.     int 
  396.         next,            /* ordering for events in queue  */
  397.         idata;            /* integer data, if you feel like it */
  398. };
  399.  
  400. /*  
  401. *  events which can occur and be placed into the event queue
  402. */
  403. #define NEVENTS 50
  404.  
  405. /*  classes defined in netevent.h   */
  406.