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