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