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