PageRenderTime 49ms CodeModel.GetById 12ms RepoModel.GetById 0ms app.codeStats 1ms

/kernel/ttd/ttd_comm.c

https://github.com/Prajna/mach
C | 1183 lines | 662 code | 173 blank | 348 comment | 89 complexity | 1171e0ea3129f55139c5bca6956cdbfd MD5 | raw file
    

  1. /* 
    2. 

  2.  * Mach Operating System
    3. 

  3.  * Copyright (c) 1992 Carnegie Mellon University
    4. 

  4.  * All Rights Reserved.
    5. 

  5.  * 
    6. 

  6.  * Permission to use, copy, modify and distribute this software and its
    7. 

  7.  * documentation is hereby granted, provided that both the copyright
    8. 

  8.  * notice and this permission notice appear in all copies of the
    9. 

  9.  * software, derivative works or modified versions, and any portions
    10. 

  10.  * thereof, and that both notices appear in supporting documentation.
    11. 

  11.  * 
    12. 

  12.  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
    13. 

  13.  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
    14. 

  14.  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
    15. 

  15.  * 
    16. 

  16.  * Carnegie Mellon requests users of this software to return to
    17. 

  17.  * 
    18. 

  18.  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
    19. 

  19.  *  School of Computer Science
    20. 

  20.  *  Carnegie Mellon University
    21. 

  21.  *  Pittsburgh PA 15213-3890
    22. 

  22.  * 
    23. 

  23.  * any improvements or extensions that they make and grant Carnegie Mellon
    24. 

  24.  * the rights to redistribute these changes.
    25. 

  25.  */
    26. 

  26. /*
    27. 

  27.  * TTD Communications parsing code for the kernel ttd server.
    28. 

  28.  *
    29. 

  29.  * HISTORY:
    30. 

  30.  * $Log:	ttd_comm.c,v $
    31. 

  31.  * Revision 2.2  93/05/10  23:24:28  rvb
    32. 

  32.  * 	Checkin for MK80 branch.
    33. 

  33.  * 	[93/05/10  15:05:52  grm]
    34. 

  34.  * 
    35. 

  35.  * Revision 2.1.2.2  93/04/20  10:51:43  grm
    36. 

  36.  * 	Changed for use with mips and machines of both endian types.
    37. 

  37.  * 	Changed many of the types so that the same protocol will be
    38. 

  38.  * 	decodable by many machine types.
    39. 

  39.  * 	[93/04/20            grm]
    40. 

  40.  * 
    41. 

  41.  * Revision 2.1.2.1  93/03/03  14:35:46  grm
    42. 

  42.  * 	Second version of code.  It works.
    43. 

  43.  * 	[93/03/03            grm]
    44. 

  44.  * 
    45. 

  45.  * Revision 2.1.1.10  93/01/22  15:51:24  grm
    46. 

  46.  * 	Added request pkt length checks.
    47. 

  47.  * 
    48. 

  48.  * Revision 2.1.1.9  93/01/21  13:02:00  grm
    49. 

  49.  * 	Changed to ansi prototypes.
    50. 

  50.  * 
    51. 

  51.  * Revision 2.1.1.8  92/10/23  21:16:53  grm
    52. 

  52.  * 	Fixed bug in kttd_valid_request so that it looks at correct
    53. 

  53.  * 	incoming packet.
    54. 

  54.  * 	[92/10/23            grm]
    55. 

  55.  * 
    56. 

  56.  * Revision 2.1.1.7  92/10/08  14:27:10  grm
    57. 

  57.  * 	Now sends and receives packets.
    58. 

  58.  * 	[92/10/08            grm]
    59. 

  59.  * 
    60. 

  60.  * Revision 2.1.1.6  92/10/01  15:35:50  grm
    61. 

  61.  * 	Restructuring of ttd code checkpoint.
    62. 

  62.  * 	[92/10/01            grm]
    63. 

  63.  * 
    64. 

  64.  * Revision 2.1.1.5  92/09/30  13:32:31  grm
    65. 

  65.  * 	Changed for use with Mach specific kttd routines (sync and async).
    66. 

  66.  * 	Added get_request, and valid_request.
    67. 

  67.  * 	[92/09/30            grm]
    68. 

  68.  * 
    69. 

  69.  * Revision 2.1.1.4  92/09/25  15:15:34  grm
    70. 

  70.  * 	checkpointing...
    71. 

  71.  * 	[92/09/25            grm]
    72. 

  72.  * 
    73. 

  73.  * Revision 2.1.1.3  92/09/21  13:22:17  grm
    74. 

  74.  * 	This version uses bootp, and responds to arp requests.
    75. 

  75.  * 	[92/09/21            grm]
    76. 

  76.  * 
    77. 

  77.  * Revision 2.1.1.2  92/09/15  18:27:57  grm
    78. 

  78.  * 	Checkpoint version with bootp working.
    79. 

  79.  * 
    80. 

  80.  * Revision 2.1.1.1  92/09/09  14:44:07  grm
    81. 

  81.  * 	Initial checkin.
    82. 

  82.  * 
    83. 

  83.  */
    84. 

  84. /***********************************************************
    85. 

  85. Copyright 1992 by Digital Equipment Corporation, Maynard, Massachusetts,
    86. 

    87. 

  87.                         All Rights Reserved
    88. 

    89. 

  89. Permission to use, copy, modify, and distribute this software and its 
    90. 

  90. documentation for any purpose and without fee is hereby granted, provided 
    91. 

  91. that the above copyright notice appear in all copies and that both that 
    92. 

  92. copyright notice and this permission notice appear in supporting 
    93. 

  93. documentation, and that the name of Digital not be used in advertising 
    94. 

  94. or publicity pertaining to distribution of the software without specific, 
    95. 

  95. written prior permission.  Digital makes no representations about the 
    96. 

  96. suitability of this software for any purpose.  It is provided "as is"
    97. 

  97. without express or implied warranty.
    98. 

    99. 

  99. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
    100. 

  100. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
    101. 

  101. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
    102. 

  102. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
    103. 

  103. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
    104. 

  104. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
    105. 

  105. SOFTWARE.
    106. 

    107. 

  107. ******************************************************************/
    108. 

  108. 

  109. /*****************************************************/
    110. 

  110. /*                    ttd_comm.c                     */
    111. 

  111. /* Simple TTD/UDP/IP/ARP protocol package for lowttd */
    112. 

  112. /*****************************************************/
    113. 

  113. 

  114. #include <device/if_ether.h>
    115. 

  115. #include <device/net_status.h>
    116. 

  116. #include <ttd/ttd_stub.h>
    117. 

  117. #include <ttd/ttd_comm.h>
    118. 

  118. #include <ttd/ttd_types.h>
    119. 

  119. #include <ttd/ttd_msg.h>
    120. 

  120. #include <ttd/ttd_debug.h>
    121. 

  121. 

  122. 

  123. static struct ether_hardware_address broadcast = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
    124. 

  124. 

  125. static struct ip_address my_ip_addr;
    126. 

  126. static struct ip_address ip_broadcast = {0xff, 0xff, 0xff, 0xff};
    127. 

  127. static struct ip_address ip_undefined = {0x00, 0x00, 0x00, 0x00};
    128. 

  128. 

  129. #define skip_pkt_header(pkt)	(arp_packet_t)((natural_t)pkt + sizeof(struct packet_header))
    130. 

  130. 

  131. /*
    132. 

  132.  * My own damn byte swapping routines:
    133. 

  133.  */
    134. 

  134. #if	BYTE_MSF
    135. 

  135. #else
    136. 

  136. u_short netswap_2_bytes(u_short n)
    137. 

  137. {
    138. 

  138. 	u_short	tmp0;
    139. 

  139. 

  140. 	tmp0 = (n << 8);
    141. 

  141. 	tmp0 |= (n >> 8);
    142. 

  142. 		
    143. 

  143. 	return tmp0;
    144. 

  144. }
    145. 

  145. 

  146. uint32 netswap_4_bytes(uint32 n)
    147. 

  147. {
    148. 

  148. 	uint32 tmp0, tmp1;
    149. 

  149. 

  150. 	tmp0 = (n << 24) | (n >> 24);
    151. 

  151. 	tmp1 = (n & 0xff00) << 8;
    152. 

  152. 	tmp0 |= tmp1;
    153. 

  153. 	tmp1 = (n >> 8) & 0xff00;
    154. 

  154. 	return tmp0 | tmp1;
    155. 

  155. }
    156. 

  156. #endif	/* BYTE_MSF */
    157. 

  157. 

  158. /***************************************/
    159. 

  159. /*        Checksum routines            */
    160. 

  160. /***************************************/
    161. 

  161. 

  162. /*
    163. 

  163.  * finish_checksum converts a two's complement accumulation of
    164. 

  164.  * HalfWords into the one's complement checksum.
    165. 

  165.  */
    166. 

  166. static int finish_checksum(int w)
    167. 

  167. {
    168. 

  168. 	if (w == 0)
    169. 

  169. 		return 0xffff;
    170. 

  170. 	while (w > 0xffff)
    171. 

  171. 		w = (w & 0xffff) + (w >> 16);
    172. 

  172. 	return w ^ 0xffff;
    173. 

  173. }
    174. 

  174. 

  175. /*
    176. 

  176.  * checksum_ip_header is applied to an IP direct from the
    177. 

  177.  * network interface, before any byteswapping.
    178. 

  178.  * Note that this means that the addition is
    179. 

  179.  * performed with the bytes of each halfword
    180. 

  180.  * reversed, but this is OK due to the magic
    181. 

  181.  * nature of ones complement arithmetic!
    182. 

  182.  * A checksum in network order is returned.
    183. 

  183.  */
    184. 

  184. static int checksum_ip_header(struct ip_header *ip)
    185. 

  185. {
    186. 

  186. 	half_word_t *wp;
    187. 

  187. 	int all, i, ip_header_halfwords;
    188. 

  188. 

  189. 	all = - ip->header_checksum;     /* don't count checksum field */
    190. 

  190. 	wp = (half_word_t *) ip;
    191. 

  191. 	ip_header_halfwords = ip->header_words * 2;
    192. 

  192. 	for (i = 0; i < ip_header_halfwords; i++)
    193. 

  193. 		all += wp[i];
    194. 

  194. 	return (finish_checksum(all));
    195. 

  195. }
    196. 

  196. 

  197. static boolean_t ip_checksum_ok(struct ip_header *ip)
    198. 

  198. {
    199. 

  199. 	int net_check;
    200. 

  200. 

  201. 	net_check = ip->header_checksum;
    202. 

  202. 	return ((net_check == 0) || (checksum_ip_header(ip) == net_check));
    203. 

  203. }
    204. 

  204. 

  205. static void set_ip_checksum(struct ip_header *ip)
    206. 

  206. {
    207. 

  207. 	ip->header_checksum = checksum_ip_header(ip);
    208. 

  208. }
    209. 

  209. 

  210. static void byteswap_ip_header(struct ip_header *ip_hdr)
    211. 

  211. {
    212. 

  212. 	ip_hdr->length         	= netswap_2_bytes(ip_hdr->length);
    213. 

  213. 	ip_hdr->id             	= netswap_2_bytes(ip_hdr->id);
    214. 

  214. 	ip_hdr->fragment_stuff  = netswap_2_bytes(ip_hdr->fragment_stuff);
    215. 

  215. 	ip_hdr->header_checksum = netswap_2_bytes(ip_hdr->header_checksum);
    216. 

  216. }
    217. 

  217. 

  218. /*
    219. 

  219.  * Use this after checking the IP header checksum.
    220. 

  220.  * A checksum in network order is returned.
    221. 

  221.  */
    222. 

  222. static int checksum_udp(struct udp_header	*udp,
    223. 

  223. 			struct udp_pseudo_header pseudo_hdr)
    224. 

  224. {
    225. 

  225. 	half_word_t *wp;
    226. 

  226. 	byte_t *bp;
    227. 

  227. 	int all, i, udp_bytes, udp_halfwords;
    228. 

  228. 

  229. 	all = - udp->checksum;     /* don't count checksum field */
    230. 

  230. 	wp = (half_word_t *) &pseudo_hdr;
    231. 

  231. 	for (i = 0; i < sizeof(struct udp_pseudo_header) / sizeof(half_word_t); i++)
    232. 

  232. 		all += wp[i];
    233. 

  233. 	udp_bytes = netswap_2_bytes(udp->length);
    234. 

  234. 	udp_halfwords = udp_bytes / 2;
    235. 

  235. 	wp = (half_word_t *) udp;
    236. 

  236. 	for (i = 0; i <= udp_halfwords - 1; i++)
    237. 

  237. 		all += wp[i];
    238. 

  238. 	if ((udp_bytes % 2) == 1) {
    239. 

  239. 		bp = (byte_t *) wp;
    240. 

  240. 		all += bp[udp_bytes - 1];
    241. 

  241. 	}
    242. 

  242. 	return (finish_checksum (all));
    243. 

  243. }
    244. 

  244. 

  245. static boolean_t udp_checksum_ok(struct udp_header		*udp,
    246. 

  246. 				 struct udp_pseudo_header	pseudo_hdr)
    247. 

  247. {
    248. 

  248. 	int net_check;
    249. 

  249. 

  250. 	net_check = udp->checksum;
    251. 

  251. 	return ((net_check == 0) || 
    252. 

  252. 		(checksum_udp(udp, pseudo_hdr) == net_check));
    253. 

  253. }
    254. 

  254. 

  255. static void set_udp_checksum(struct udp_header		*udp,
    256. 

  256. 			     struct udp_pseudo_header	ph)
    257. 

  257. {
    258. 

  258. 	udp->checksum = checksum_udp(udp, ph);
    259. 

  259. }
    260. 

  260. 

  261. /*****************************************/
    262. 

  262. /*       Simple-minded ARP Server        */
    263. 

  263. /*****************************************/
    264. 

  264. 

  265. static boolean_t eq_ip(struct ip_address a, struct ip_address b)
    266. 

  266. {
    267. 

  267. 	int i;
    268. 

  268. 	
    269. 

  269. 	for (i = 0; i < IP_ADDRESS_LENGTH; i++)
    270. 

  270. 		if (a.array[i] != b.array[i])
    271. 

  271. 			return FALSE;
    272. 

  272. 	return TRUE;
    273. 

  273. }
    274. 

  274. 

  275. static foocount = 10;
    276. 

  276. 

  277. void dump_arp_packet(struct ttd_ether_header * e, arp_packet_t p)
    278. 

  278. {
    279. 

  279. 	printf("\neh.dest %x:%x:%x:%x:%x:%x, ",
    280. 

  280. 	       e->dest.array[0],
    281. 

  281. 	       e->dest.array[1],
    282. 

  282. 	       e->dest.array[2],
    283. 

  283. 	       e->dest.array[3],
    284. 

  284. 	       e->dest.array[4],
    285. 

  285. 	       e->dest.array[5]);
    286. 

  286. 	printf("eh.source %x:%x:%x:%x:%x:%x, ",
    287. 

  287. 	       e->source.array[0],
    288. 

  288. 	       e->source.array[1],
    289. 

  289. 	       e->source.array[2],
    290. 

  290. 	       e->source.array[3],
    291. 

  291. 	       e->source.array[4],
    292. 

  292. 	       e->source.array[4]);
    293. 

  293. 	printf("eh.protocol = %x, ", e->protocol);
    294. 

  294. 	printf("arp.hat %x, ", p->hardware_addr_type);
    295. 

  295. 	printf("arp.pat %x, ", p->protocol_addr_type);
    296. 

  296. 	printf("arp.hal %x, ", p->hardware_addr_length);
    297. 

  297. 	printf("arp.pal %x, ", p->protocol_addr_length);
    298. 

  298. 	printf("arp.aop %x, ", p->arp_opcode);
    299. 

  299. 	printf("arp.sha %x:%x:%x:%x:%x:%x",
    300. 

  300. 	       p->ip.source_hardware_addr.array[0],
    301. 

  301. 	       p->ip.source_hardware_addr.array[1],
    302. 

  302. 	       p->ip.source_hardware_addr.array[2],
    303. 

  303. 	       p->ip.source_hardware_addr.array[3],
    304. 

  304. 	       p->ip.source_hardware_addr.array[4],
    305. 

  305. 	       p->ip.source_hardware_addr.array[5]);
    306. 

  306. 	printf("arp.spa %d.%d.%d.%d, ",
    307. 

  307. 	       p->ip.source_protocol_addr.array[0],
    308. 

  308. 	       p->ip.source_protocol_addr.array[1],
    309. 

  309. 	       p->ip.source_protocol_addr.array[2],
    310. 

  310. 	       p->ip.source_protocol_addr.array[3]);
    311. 

  311. 	printf("arp.dha %x:%x:%x:%x:%x:%x",
    312. 

  312. 	       p->ip.dest_hardware_addr.array[0],
    313. 

  313. 	       p->ip.dest_hardware_addr.array[1],
    314. 

  314. 	       p->ip.dest_hardware_addr.array[2],
    315. 

  315. 	       p->ip.dest_hardware_addr.array[3],
    316. 

  316. 	       p->ip.dest_hardware_addr.array[4],
    317. 

  317. 	       p->ip.dest_hardware_addr.array[5]);
    318. 

  318. 	printf("arp.dpa %d.%d.%d.%d, ",
    319. 

  319. 	       p->ip.dest_protocol_addr.array[0],
    320. 

  320. 	       p->ip.dest_protocol_addr.array[1],
    321. 

  321. 	       p->ip.dest_protocol_addr.array[2],
    322. 

  322. 	       p->ip.dest_protocol_addr.array[3]);
    323. 

  323. 

  324. 	if (!foocount--)
    325. 

  325. 		while(1);
    326. 

  326. }
    327. 

  327. 

  328. static void handle_arp_packet(int unit,
    329. 

  329. 			      struct ttd_ether_header * ehp,
    330. 

  330. 			      struct packet_header * pkt)
    331. 

  331. 	
    332. 

  332. {
    333. 

  333. 	arp_packet_t p;
    334. 

  334. 	arpether_packet_t rpkt;
    335. 

  335. 

  336. 	/*
    337. 

  337. 	 * Set to point at the separate arp part of the received message
    338. 

  338. 	 */
    339. 

  339. 	p = skip_pkt_header(pkt);
    340. 

  340. 	
    341. 

  341. 	/* ARP is simple; req is turned into reply and xmitted inline. */
    342. 

  342. 

  343. 	if (p->hardware_addr_type != ARPTYPE_ETHER) {	/* != 0x0100 */
    344. 

  344. 		return;
    345. 

  345. 	}
    346. 

  346. 	if (p->protocol_addr_type != ETHERTYPE_IP) {	/* != 0x0008 */
    347. 

  347. 		return;
    348. 

  348. 	}
    349. 

  349. 	if (p->hardware_addr_length != ETHER_ADDRESS_LENGTH) {	/* != 0x06 */
    350. 

  350. 		return;
    351. 

  351. 	}
    352. 

  352. 	if (p->protocol_addr_length != IP_ADDRESS_LENGTH) {	/* != 0x04 */
    353. 

  353. 		return;
    354. 

  354. 	}
    355. 

  355. 	if (p->arp_opcode != ARPOP_REQUEST) {	/* != 0x0100 */
    356. 

  356. 		return;
    357. 

  357. 	}
    358. 

  358. 	if (!eq_ip(p->ip.dest_protocol_addr, my_ip_addr)) {
    359. 

  359. 		return;
    360. 

  360. 	}
    361. 

  361. 

  362. 	/*
    363. 

  363. 	 * Fix up the reply message:
    364. 

  364. 	 */
    365. 

  365. 

  366. 	rpkt = (arpether_packet_t)ttd_reply_msg;
    367. 

  367. 

  368. 	bzero(rpkt, MIN_PACKET);
    369. 

  369. 

  370. 	rpkt->eh.dest = ehp->source;
    371. 

  371. 	rpkt->eh.source = ttd_host_ether_id;
    372. 

  372. 	rpkt->eh.protocol = ETHERTYPE_ARP;
    373. 

  373. 

  374. 	rpkt->arp.hardware_addr_type = ARPTYPE_ETHER;
    375. 

  375. 	rpkt->arp.protocol_addr_type = ETHERTYPE_IP;
    376. 

  376. 	rpkt->arp.hardware_addr_length = ETHER_ADDRESS_LENGTH;
    377. 

  377. 	rpkt->arp.protocol_addr_length = IP_ADDRESS_LENGTH;
    378. 

  378. 

  379. 	rpkt->arp.ip.dest_protocol_addr = p->ip.source_protocol_addr;
    380. 

  380. 	rpkt->arp.ip.dest_hardware_addr = p->ip.source_hardware_addr;
    381. 

  381. 	rpkt->arp.ip.source_protocol_addr = my_ip_addr;
    382. 

  382. 	rpkt->arp.ip.source_hardware_addr = ttd_host_ether_id;
    383. 

  383. 	rpkt->arp.arp_opcode = ARPOP_REPLY;
    384. 

  384. 

  385. 	/*
    386. 

  386. 	 * Send a reply....
    387. 

  387. 	 */
    388. 

  388. 

  389. 	ttd_send_packet(ttd_device_unit, rpkt, MIN_PACKET);
    390. 

  390. }
    391. 

  391. 

  392. /*****************************************/
    393. 

  393. /*        Bootp Packet Handling          */
    394. 

  394. /*****************************************/
    395. 

  395. 

  396. /*
    397. 

  397.  * Generate a ``random'' transaction id number.  It builds it out of the
    398. 

  398.  * hardware ethernet id.  It's not unique -- XXX
    399. 

  399.  */
    400. 

  400. static uint32 build_xid(void)
    401. 

  401. {
    402. 

  402. 	natural_t ret;
    403. 

  403. 

  404. 	ret = ((ttd_host_ether_id.array[0] <<12) ||
    405. 

  405. 	       (ttd_host_ether_id.array[5] <<8) ||
    406. 

  406. 	       (ttd_host_ether_id.array[1] <<4) ||
    407. 

  407. 	       ttd_host_ether_id.array[4]);
    408. 

  408. 

  409. 	ret ^= ((ttd_host_ether_id.array[2] <<12) ||
    410. 

  410. 		(ttd_host_ether_id.array[3] <<4));
    411. 

  411. 

  412. 	return ret;
    413. 

  413. }
    414. 

  414. 

  415. void dump_ipudpbootp(char * s, sndbootp_t ptr)
    416. 

  416. {
    417. 

  417. 	recbootp_t	p = (recbootp_t)&ptr->ui;
    418. 

  418. 	bootp_t		bp = (bootp_t)p->bpbuf;
    419. 

  419. 

  420. 	printf("%s",s);
    421. 

  421. 

  422. 	if (bp->bp_op == BOOTREQUEST) {
    423. 

  423. 		printf(", bootrequest is ok\n");
    424. 

  424. 		return;
    425. 

  425. 	}else{
    426. 

  426. 		printf("\n");
    427. 

  427. 	}
    428. 

  428. 

  429. 	printf("UDP Header: source %d (%d)\n",p->ui.udp_h.source_port,
    430. 

  430. 	       ((natural_t)&p->ui.udp_h.dest_port-(natural_t)&p->ui.udp_h.source_port));
    431. 

  431. 	printf("dest %d, (%d)\n",p->ui.udp_h.dest_port, 
    432. 

  432. 	       ((natural_t)&p->ui.udp_h.length - (natural_t)&p->ui.udp_h.dest_port));
    433. 

  433. 	printf("length %d, (%d)\n",p->ui.udp_h.length, 
    434. 

  434. 	       ((natural_t)&p->ui.udp_h.checksum - (natural_t)&p->ui.udp_h.length));
    435. 

  435. 	printf("checksum %d, (%d)\n",p->ui.udp_h.checksum,
    436. 

  436. 	       ((natural_t)&bp->bp_op - (natural_t)&p->ui.udp_h.checksum));
    437. 

  437. 	printf("BOOTP Contents: bp_op %d, (%d)\n", bp->bp_op,
    438. 

  438. 	       ((natural_t)&bp->bp_htype - (natural_t)&bp->bp_op));
    439. 

  439. 	printf("bp_htype %d, (%d)\n", bp->bp_htype,
    440. 

  440. 	       ((natural_t)&bp->bp_hlen - (natural_t)&bp->bp_htype));
    441. 

  441. 	printf("bp_hlen %d, (%d)\n", bp->bp_hlen,
    442. 

  442. 	       ((natural_t)&bp->bp_hops - (natural_t)&bp->bp_hlen));
    443. 

  443. 	printf("bp_hops %d, (%d)\n", bp->bp_hops,
    444. 

  444. 	       ((natural_t)&bp->bp_xid - (natural_t)&bp->bp_hops));
    445. 

  445. 	printf("bp_xid %d, (%d)\n", bp->bp_xid,
    446. 

  446. 	       ((natural_t)&bp->bp_secs - (natural_t)&bp->bp_xid));
    447. 

  447. 	printf("bp_secs %d, (%d)\n", bp->bp_secs,
    448. 

  448. 	       ((natural_t)&bp->bp_unused - (natural_t)&bp->bp_secs));
    449. 

  449. 	printf("bp_unused %d, (%d)\n", bp->bp_unused,
    450. 

  450. 	       ((natural_t)&bp->bp_ciaddr - (natural_t)&bp->bp_unused));
    451. 

  451. 	printf("bp_ciaddr %d.%d.%d.%d, (%d)\n",
    452. 

  452. 	       bp->bp_ciaddr.array[0],
    453. 

  453. 	       bp->bp_ciaddr.array[1],
    454. 

  454. 	       bp->bp_ciaddr.array[2],
    455. 

  455. 	       bp->bp_ciaddr.array[3],
    456. 

  456. 	       ((natural_t)&bp->bp_yiaddr - (natural_t)&bp->bp_ciaddr));
    457. 

  457. 	printf("bp_yiaddr %d.%d.%d.%d, (%d)\n",
    458. 

  458. 	       bp->bp_yiaddr.array[0],
    459. 

  459. 	       bp->bp_yiaddr.array[1],
    460. 

  460. 	       bp->bp_yiaddr.array[2],
    461. 

  461. 	       bp->bp_yiaddr.array[3],
    462. 

  462. 	       ((natural_t)&bp->bp_siaddr - (natural_t)&bp->bp_yiaddr));
    463. 

  463. 	printf("bp_siaddr %d.%d.%d.%d, (%d)\n",
    464. 

  464. 	       bp->bp_siaddr.array[0],
    465. 

  465. 	       bp->bp_siaddr.array[1],
    466. 

  466. 	       bp->bp_siaddr.array[2],
    467. 

  467. 	       bp->bp_siaddr.array[3],
    468. 

  468. 	       ((natural_t)&bp->bp_giaddr - (natural_t)&bp->bp_siaddr));
    469. 

  469. 	printf("bp_giaddr %d.%d.%d.%d, (%d)\n",
    470. 

  470. 	       bp->bp_giaddr.array[0],
    471. 

  471. 	       bp->bp_giaddr.array[1],
    472. 

  472. 	       bp->bp_giaddr.array[2],
    473. 

  473. 	       bp->bp_giaddr.array[3],
    474. 

  474. 	       ((natural_t)&bp->bp_chaddr - (natural_t)&bp->bp_giaddr));
    475. 

  475. 	printf("bp_chaddr %x:%x:%x:%x:%x:%x, (%d)\n",
    476. 

  476. 	       bp->bp_chaddr[0],
    477. 

  477. 	       bp->bp_chaddr[1],
    478. 

  478. 	       bp->bp_chaddr[2],
    479. 

  479. 	       bp->bp_chaddr[3],
    480. 

  480. 	       bp->bp_chaddr[4],
    481. 

  481. 	       bp->bp_chaddr[5],
    482. 

  482. 	       ((natural_t)&bp->bp_sname - (natural_t)&bp->bp_chaddr));
    483. 

  483. 

  484. 	while(1);
    485. 

  485. }
    486. 

  486. 

  487. /*
    488. 

  488.  * Builds an ethernet packet that contains a valid bootp
    489. 

  489.  * request.  This consists of a valid ethernet header, valid
    490. 

  490.  * ip header, udp header, and bootp request record.
    491. 

  491.  */
    492. 

  492. static void build_bootp_packet(sndbootp_t buf, int size)
    493. 

  493. {
    494. 

  494. 	bootp_t		bp;
    495. 

  495. 	uint32		tmp;
    496. 

  496. 

  497. 	bp = (bootp_t)buf->bpbuf;
    498. 

  498. 

  499. 	/*
    500. 

  500. 	 * Clean out the buffer.
    501. 

  501. 	 */
    502. 

  502. 	bzero(buf,size);
    503. 

  503. 

  504. 	/*
    505. 

  505. 	 * Set up ethernet header:
    506. 

  506. 	 */
    507. 

  507. 	buf->eh.dest = broadcast;
    508. 

  508. 	buf->eh.source = ttd_host_ether_id;
    509. 

  509. 	buf->eh.protocol = ETHERTYPE_IP;
    510. 

  510. 

  511. 	/*
    512. 

  512. 	 * Set up ip header:
    513. 

  513. 	 */
    514. 

  514. 	buf->ui.ip_h.header_checksum = 0;
    515. 

  515. 	buf->ui.ip_h.id = 1;
    516. 

  516. 	buf->ui.ip_h.fragment_stuff = 0;
    517. 

  517. 

  518. 	/* Don't know about these two!! XXX */
    519. 

  519. 	buf->ui.ip_h.type_of_service = 0;
    520. 

  520. 	buf->ui.ip_h.version = 4;
    521. 

  521. 

  522. 	buf->ui.ip_h.header_words = OUT_IP_HEADER_WORDS;
    523. 

  523. 	buf->ui.ip_h.time_to_live = 0xff;
    524. 

  524. 

  525. 	buf->ui.ip_h.protocol =	PROTOCOL_UDP;
    526. 

  526. 	buf->ui.ip_h.source =	ip_undefined;
    527. 

  527. 	buf->ui.ip_h.dest =	ip_broadcast;
    528. 

  528. 	buf->ui.ip_h.length =	sizeof(struct recbootp);
    529. 

  529. 

  530. 	/* Fix up for network byte order. */
    531. 

  531. 	byteswap_ip_header(&buf->ui.ip_h);
    532. 

  532. 	set_ip_checksum(&buf->ui.ip_h);
    533. 

  533. 

  534. 	/*
    535. 

  535. 	 * Set up the udp header:
    536. 

  536. 	 */
    537. 

  537. 	buf->ui.udp_h.source_port =	netswap_2_bytes(UDP_BOOTPC);
    538. 

  538. 	buf->ui.udp_h.dest_port =	netswap_2_bytes(UDP_BOOTPS);
    539. 

  539. 	buf->ui.udp_h.length =		netswap_2_bytes(sizeof(struct udp_header)+
    540. 

  540. 							sizeof(struct bootp));
    541. 

  541. 	buf->ui.udp_h.checksum =	0;
    542. 

  542. 

  543. 	/*
    544. 

  544. 	 * Set up bootp info:
    545. 

  545. 	 */
    546. 

  546. 	bp->bp_op =		BOOTREQUEST;
    547. 

  547. 	bp->bp_htype =		ETHER_HTYPE;
    548. 

  548. 	bp->bp_hlen =		ETHER_ADDRESS_LENGTH;
    549. 

  549. 	tmp = netswap_4_bytes(build_xid());
    550. 

  550. 	bp->bp_xid[0] =		tmp & 0xf;
    551. 

  551. 	bp->bp_xid[1] =		(tmp & 0xf0) >> 8;
    552. 

  552. 	bp->bp_xid[2] =		(tmp & 0xf00) >> 8;
    553. 

  553. 	bp->bp_xid[3] =		(tmp & 0xf000) >> 8;
    554. 

  554. 	bp->bp_chaddr[0] =	ttd_host_ether_id.array[0];
    555. 

  555. 	bp->bp_chaddr[1] =	ttd_host_ether_id.array[1];
    556. 

  556. 	bp->bp_chaddr[2] =	ttd_host_ether_id.array[2];
    557. 

  557. 	bp->bp_chaddr[3] =	ttd_host_ether_id.array[3];
    558. 

  558. 	bp->bp_chaddr[4] =	ttd_host_ether_id.array[4];
    559. 

  559. 	bp->bp_chaddr[5] =	ttd_host_ether_id.array[5];
    560. 

  560. }
    561. 

  561. 

  562. /*
    563. 

  563.  * Check an incoming message for a valid bootp reply.
    564. 

  564.  */
    565. 

  565. static boolean_t check_bootp_reply(void)
    566. 

  566. {
    567. 

  567. 	recbootp_t			rbootp;
    568. 

  568. 	struct ttd_ether_header *	ehp;
    569. 

  569. 	bootp_t				bp;
    570. 

  570. 	uint32				tmp;
    571. 

  571. 

  572. 	/*
    573. 

  573. 	 * Set up the pointers to point at the separate ether and ip data
    574. 

  574. 	 * in the netkmsg.
    575. 

  575. 	 */
    576. 

  576. 	ehp = (struct ttd_ether_header *)
    577. 

  577. 		&((net_rcv_msg_t)&((ipc_kmsg_t)ttd_request_msg)->ikm_header)->header[0];
    578. 

  578. 	rbootp = (recbootp_t)((natural_t)(&((net_rcv_msg_t)
    579. 

  579. 				      &((ipc_kmsg_t)ttd_request_msg)->ikm_header)->packet[0])
    580. 

  580. 			      +(natural_t)(sizeof(struct packet_header)));
    581. 

  581. 

  582. 	bp = (bootp_t)rbootp->bpbuf;
    583. 

  583. 

  584. #if	DEBUG_ETHER_PACKETS
    585. 

  585. 	printf("cBr.1 %x:%x:%x:%x:%x:%x %x:%x:%x:%x:%x:%x ",
    586. 

  586. 	       ehp->dest.array[0],
    587. 

  587. 	       ehp->dest.array[1],
    588. 

  588. 	       ehp->dest.array[2],
    589. 

  589. 	       ehp->dest.array[3],
    590. 

  590. 	       ehp->dest.array[4],
    591. 

  591. 	       ehp->dest.array[5],
    592. 

  592. 	       ehp->source.array[0],
    593. 

  593. 	       ehp->source.array[1],
    594. 

  594. 	       ehp->source.array[2],
    595. 

  595. 	       ehp->source.array[3],
    596. 

  596. 	       ehp->source.array[4],
    597. 

  597. 	       ehp->source.array[5]);
    598. 

  598. #endif	/* DEBUG_ETHER_PACKETS */
    599. 

  599. 

  600. 	/*
    601. 

  601. 	 * Check the ethernet header for my destination address and
    602. 

  602. 	 * the Ethernet IP protocol.
    603. 

  603. 	 */
    604. 

  604. 	if (!ETHER_ADDRESS_EQ(&ehp->dest, &ttd_host_ether_id))
    605. 

  605. 		return FALSE;
    606. 

  606. 	if (ehp->protocol != ETHERTYPE_IP)
    607. 

  607. 		return FALSE;
    608. 

  608. 	/*
    609. 

  609. 	 * Got a packet for my machine.  Check the IP for datagram packet.
    610. 

  610. 	 */
    611. 

  611. 

  612. 	if (!ip_checksum_ok(&rbootp->ui.ip_h))
    613. 

  613. 		return FALSE;
    614. 

  614. 	byteswap_ip_header(&rbootp->ui.ip_h);
    615. 

  615. 

  616. 	if (rbootp->ui.ip_h.protocol != PROTOCOL_UDP)
    617. 

  617. 		return FALSE;
    618. 

  618. 

  619. 	/*
    620. 

  620. 	 * It's a UDP datagram (maybe :-))
    621. 

  621. 	 * Check for bootp udp ports, udp length, xid, etc...
    622. 

  622. 	 */
    623. 

  623. 

  624. 	if (rbootp->ui.udp_h.source_port != netswap_2_bytes(UDP_BOOTPS))
    625. 

  625. 		return FALSE;
    626. 

  626. 	if (rbootp->ui.udp_h.dest_port != netswap_2_bytes(UDP_BOOTPC))
    627. 

  627. 		return FALSE;
    628. 

  628. 	if (netswap_2_bytes(rbootp->ui.udp_h.length) < 
    629. 

  629. 	    (sizeof(struct udp_header) + sizeof(struct bootp)))
    630. 

  630. 		return FALSE;
    631. 

  631. 

  632. 	if (bp->bp_op != BOOTREPLY)
    633. 

  633. 		return FALSE;
    634. 

  634. 	tmp = netswap_4_bytes(build_xid());
    635. 

  635. 	if ((bp->bp_xid[0] != tmp & 0xf) &&
    636. 

  636. 	    (bp->bp_xid[1] != (tmp & 0xf0) >> 8) &&
    637. 

  637. 	    (bp->bp_xid[2] != (tmp & 0xf00) >> 8) &&
    638. 

  638. 	    (bp->bp_xid[3] != (tmp & 0xf000) >> 8))
    639. 

  639. 		return FALSE;
    640. 

  640. 

  641. 	if (bp->bp_htype != ETHER_HTYPE)
    642. 

  642. 		return FALSE;
    643. 

  643. 	if (bp->bp_hlen != ETHER_ADDRESS_LENGTH)
    644. 

  644. 		return FALSE;
    645. 

  645. 

  646. 	my_ip_addr = bp->bp_yiaddr;
    647. 

  647. 	return TRUE;
    648. 

  648. }
    649. 

  649. 

  650. /*
    651. 

  651.  * Try to get my host ip via the bootp protocol.  This routine
    652. 

  652.  * sends a bootp packet and then waits for a valid bootp return
    653. 

  653.  * call.  The routine returns true upon success, false if no bootp
    654. 

  654.  * server responds within the timeout period.
    655. 

  655.  */
    656. 

  656. static boolean_t do_bootp(void)
    657. 

  657. {
    658. 

  658. 	natural_t max_tries;
    659. 

  659. 	natural_t backoff;
    660. 

  660. 	natural_t recvd;
    661. 

  661. 

  662. 	/*
    663. 

  663. 	 * Only send BOOTPMAX_TRIES bootp queries before giving up.
    664. 

  664. 	 */
    665. 

  665. 	for(max_tries = BOOTPMAX_TRIES, backoff = 4;
    666. 

  666. 	    max_tries;
    667. 

  667. 	    max_tries--, backoff = ((backoff < 60) ? (backoff*2) : 60)) {
    668. 

  668. 

  669. 		build_bootp_packet((sndbootp_t)ttd_request_msg, BOOTPMSG_SIZE);
    670. 

  670. 

  671. 		ttd_send_packet(ttd_device_unit, ttd_request_msg, BOOTPMSG_SIZE);
    672. 

  672. 

  673. 		for(recvd = 0;
    674. 

  674. 		    recvd < backoff;
    675. 

  675. 		    recvd++) {
    676. 

  676. 			/*
    677. 

  677. 			 * Clean up receive buffer and get a message
    678. 

  678. 			 */
    679. 

  679. 			bzero(ttd_request_msg, BOOTPMSG_SIZE);
    680. 

  680. 			ttd_get_packet(ttd_device_unit);
    681. 

  681. 			
    682. 

  682. 			if (check_bootp_reply())
    683. 

  683. 				return TRUE;
    684. 

  684. 		}
    685. 

  685. 	}
    686. 

  686. 	return FALSE;
    687. 

  687. }
    688. 

  688. 

  689. boolean_t ttd_ip_bootp(void)
    690. 

  690. {
    691. 

  691. 	boolean_t ret;
    692. 

  692. 

  693. 	/*
    694. 

  694. 	 * Turn on ttd so that ether drivers work with the polling routines.
    695. 

  695. 	 */
    696. 

  696. 

  697. 	printf("Looking for bootp server...");
    698. 

  698. 	kttd_active = MAX_KTTD_ACTIVE;
    699. 

  699. 	ret = do_bootp();
    700. 

  700. 	kttd_active = MIN_KTTD_ACTIVE;
    701. 

  701. 

  702. 	if(ret) {
    703. 

  703. 		printf("found bootp server, ip address = %d.%d.%d.%d\n",
    704. 

  704. 		    my_ip_addr.array[0],
    705. 

  705. 		    my_ip_addr.array[1],
    706. 

  706. 		    my_ip_addr.array[2],  
    707. 

  707. 		    my_ip_addr.array[3]);
    708. 

  708. 	}else{
    709. 

  709. 		kttd_enabled = FALSE;
    710. 

  710. 		printf("\ncouldn't find a bootp server.\n");
    711. 

  711. 	}
    712. 

  712. 

  713. 	return ret;
    714. 

  714. }
    715. 

  715. 

  716. /***************************************/
    717. 

  717. /*         IP Packet Handling          */
    718. 

  718. /***************************************/
    719. 

  719. 

  720. static void pseudo_header(struct ip_header *ip,
    721. 

  721. 			  struct udp_pseudo_header *pseudo_hdr)
    722. 

  722. {
    723. 

  723. 	pseudo_hdr->source    = ip->source;
    724. 

  724. 	pseudo_hdr->dest      = ip->dest;
    725. 

  725. 	pseudo_hdr->zero      = 0;
    726. 

  726. 	pseudo_hdr->protocol  = ip->protocol;
    727. 

  727. 	/*  pseudo_hdr->udpLength = <set later>;  --  must be in network order */
    728. 

  728. }
    729. 

  729. 

  730. void dump_ether_header(char * mess, struct ttd_ether_header * ehp)
    731. 

  731. {
    732. 

  732. 	printf("%s dhost: %x:%x:%x:%x:%x:%x",
    733. 

  733. 	       mess,
    734. 

  734. 	       ehp->dest.array[0],
    735. 

  735. 	       ehp->dest.array[1],
    736. 

  736. 	       ehp->dest.array[2],
    737. 

  737. 	       ehp->dest.array[3],
    738. 

  738. 	       ehp->dest.array[4],
    739. 

  739. 	       ehp->dest.array[5]);
    740. 

  740. 

  741. 	printf("  shost: %x:%x:%x:%x:%x:%x",
    742. 

  742. 	       ehp->source.array[0],
    743. 

  743. 	       ehp->source.array[1],
    744. 

  744. 	       ehp->source.array[2],
    745. 

  745. 	       ehp->source.array[3],
    746. 

  746. 	       ehp->source.array[4],
    747. 

  747. 	       ehp->source.array[5]);
    748. 

  748. 

  749. 	printf("  type = %x",ehp->protocol);
    750. 

  750. }
    751. 

  751. 

  752. /*
    753. 

  753.  * New routines for kttd:
    754. 

  754.  */
    755. 

  755. 

  756. /*
    757. 

  757.  * poll_request:
    758. 

  758.  *
    759. 

  759.  * Get a packet from the ethernet via polling.
    760. 

  760.  *
    761. 

  761.  */
    762. 

  762. static void kttd_poll_request(void)
    763. 

  763. {
    764. 

  764. 	ttd_get_packet(ttd_device_unit);
    765. 

  765. }
    766. 

  766. 

  767. static boolean_t valid_udp_packet(struct udp_packet	*udp,
    768. 

  768. 				  struct udp_pseudo_header udp_phdr,
    769. 

  769. 				  natural_t		udp_length,
    770. 

  770. 				  vm_offset_t		*ttd_pkt)
    771. 

  771. {
    772. 

  772. 

  773. 	udp_phdr.udp_length = udp->hdr.length;	/* in network order */
    774. 

  774. 

  775. 	if (!udp_checksum_ok(&udp->hdr, udp_phdr))
    776. 

  776. 		return FALSE;
    777. 

  777. 

  778. 	if (udp->hdr.dest_port != TTD_PORT)		/* in network order */
    779. 

  779. 		return FALSE;
    780. 

  780. 

  781. 	if (netswap_2_bytes(udp->hdr.length) > udp_length) {
    782. 

  782. 		if (kttd_debug)
    783. 

  783. 			printf("INVALID UDP Header Length!!!\n");
    784. 

  784. 		return FALSE;
    785. 

  785. 	}
    786. 

  786. 

  787. 	*ttd_pkt = (vm_offset_t)&udp->data[0];
    788. 

  788. 

  789. 	return TRUE;
    790. 

  790. }
    791. 

  791. 

  792. static boolean_t valid_ip_packet(ip_packet_t	*ip,
    793. 

  793. 				 natural_t	ip_len,
    794. 

  794. 				 struct udp_pseudo_header *udp_phdr)
    795. 

  795. {
    796. 

  796. 	/*
    797. 

  797. 	 * Make sure checksum adds up!
    798. 

  798. 	 */
    799. 

  799. 	if (!ip_checksum_ok (&ip->hdr))
    800. 

  800. 		return FALSE;
    801. 

  801. 

  802. 	pseudo_header(&ip->hdr, udp_phdr); /* pseudo-header for UDP */
    803. 

  803. 

  804. 	byteswap_ip_header(&ip->hdr); /* Can't touch header fields before this! */
    805. 

  805. 

  806. 	/*
    807. 

  807. 	 * IP's length is bad, throw packet away...
    808. 

  808. 	 */
    809. 

  809. 	if ((ip->hdr.length > ip_len) || (ip_len > MAX_ETHER_DATA)) {
    810. 

  810. 		byteswap_ip_header(&ip->hdr);
    811. 

  811. 		if (kttd_debug)
    812. 

  812. 			printf("INVALID IP LENGTH!!! 0x%x:0x%x\n",
    813. 

  813. 			       ip->hdr.length, ip_len);
    814. 

  814. 		return FALSE;
    815. 

  815. 	}
    816. 

  816. 	
    817. 

  817. 	/*
    818. 

  818. 	 * TTD packets are type UDP, discard others...
    819. 

  819. 	 */
    820. 

  820. 	if (ip->hdr.protocol != PROTOCOL_UDP) {
    821. 

  821. 		byteswap_ip_header(&ip->hdr);
    822. 

  822. 		return FALSE;
    823. 

  823. 	}
    824. 

  824. 

  825. 	return TRUE;
    826. 

  826. 

  827. }
    828. 

  828. 

  829. static boolean_t valid_ether_packet(struct ttd_ether_header	*ehp,
    830. 

  830. 				    struct packet_header	*pkt,
    831. 

  831. 				    boolean_t handle_arp)
    832. 

  832. {
    833. 

  833. 	/*
    834. 

  834. 	 * ignore broadcast replies
    835. 

  835. 	 */
    836. 

  836. 	if (ETHER_ADDRESS_EQ (&ehp->source, &broadcast)) {
    837. 

  837. 		return FALSE;
    838. 

  838. 	}
    839. 

  839. 

  840. 	/*
    841. 

  841. 	 * If arp packet then check for broadcast request.
    842. 

  842. 	 */
    843. 

  843. 	if ((ehp->protocol == ETHERTYPE_ARP) && handle_arp) {
    844. 

  844. 		handle_arp_packet(ttd_device_unit, ehp, pkt);
    845. 

  845. 		return FALSE;
    846. 

  846. 	}
    847. 

  847. 

  848. 	if (ehp->protocol != ETHERTYPE_IP) {
    849. 

  849. 		return FALSE;
    850. 

  850. 	}
    851. 

  851. 

  852. 	/*
    853. 

  853. 	 * IP packet, means this might be a ttd packet.
    854. 

  854. 	 *
    855. 

  855. 	 * We aren't looking for broadcast ip dest though....
    856. 

  856. 	 */
    857. 

  857. 

  858. 	if (ETHER_ADDRESS_EQ(&ehp->dest, &broadcast))
    859. 

  859. 		return FALSE;
    860. 

  860. 

  861. 	/*
    862. 

  862. 	 * Passes the ethernet header check...
    863. 

  863. 	 */
    864. 

  864. 	return TRUE;
    865. 

  865. }
    866. 

  866. 

  867. /*
    868. 

  868.  * kttd_valid_request(request, handle_arp):
    869. 

  869.  *
    870. 

  870.  *  Given a pointer to an ipc_kmsg, determine whether it is a valid kttd
    871. 

  871.  * request packet.
    872. 

  872.  *
    873. 

  873.  *  Arp packets are handled here handle_arp is TRUE.
    874. 

  874.  *
    875. 

  875.  *  If the packet is a valid KTTD packet, the procedure sets the ttd_data
    876. 

  876.  * paramter to point to the start of the TTD message and returns TRUE.  If
    877. 

  877.  * it is not a valid ttd packet it returns FALSE.
    878. 

  878.  *
    879. 

  879.  */
    880. 

  880. boolean_t kttd_valid_request(ipc_kmsg_t	request,
    881. 

  881. 			     boolean_t	handle_arp,
    882. 

  882. 			     vm_offset_t *ttd_data,
    883. 

  883. 			     natural_t *request_length)
    884. 

  884. {
    885. 

  885. 	struct ttd_ether_header *ehp;
    886. 

  886. 	struct packet_header	*pkt;
    887. 

  887. 

  888. 	ip_packet_t		*ip;
    889. 

  889. 	natural_t		length;
    890. 

  890. 	natural_t		ip_hsize;
    891. 

  891. 

  892. 	struct udp_packet	*udp_pkt;
    893. 

  893. 	struct udp_pseudo_header udp_phdr;
    894. 

  894. #if	1
    895. 

  895. 	int i;
    896. 

  896. 	u_char *ptr;
    897. 

  897. #endif	1
    898. 

  898. 

  899. 	vm_offset_t	ttd_pkt;
    900. 

  900. 

  901. 	/*
    902. 

  902. 	 * Check Ether packet:
    903. 

  903. 	 */
    904. 

  904. 	ehp = (struct ttd_ether_header *)
    905. 

  905. 		&((net_rcv_msg_t)
    906. 

  906. 		  &((ipc_kmsg_t)request)->ikm_header)->header[0];
    907. 

  907. 	pkt = (struct packet_header *)
    908. 

  908. 		&((net_rcv_msg_t)
    909. 

  909. 		  &((ipc_kmsg_t)request)->ikm_header)->packet[0];
    910. 

  910. 

  911. 	if (!valid_ether_packet(ehp, pkt, handle_arp))
    912. 

  912. 		return FALSE;
    913. 

  913. 

  914. 	/*
    915. 

  915. 	 * Check IP Packet:
    916. 

  916. 	 */
    917. 

  917. 	length = pkt->length;
    918. 

  918. 	ip = (ip_packet_t *)skip_pkt_header(pkt);
    919. 

  919. 	
    920. 

  920. 	if (!valid_ip_packet(ip, length, &udp_phdr))
    921. 

  921. 		return FALSE;
    922. 

  922. 

  923. 	/*
    924. 

  924. 	 * Check UDP Packet:
    925. 

  925. 	 */
    926. 

  926. 

  927. 	length -= sizeof(struct ip_header);
    928. 

  928. 	ip_hsize = ip->hdr.header_words * 4;
    929. 

  929. 	udp_pkt = (udp_packet_t) &ip->data[ip_hsize / 2];
    930. 

  930. 

  931. 	if (!valid_udp_packet(udp_pkt, udp_phdr, length, ttd_data)) {
    932. 

  932. 		byteswap_ip_header(&ip->hdr);	
    933. 

  933. 		return FALSE;
    934. 

  934. 	}
    935. 

  935. 

  936. 	/*
    937. 

  937. 	 * Passed all of the tests, it's a TTD packet.
    938. 

  938. 	 */
    939. 

  939. 

  940. 	/* ttd_data was set by valid_udp_packet */
    941. 

  941. 

  942. 	*request_length = (length - sizeof(struct udp_header) -
    943. 

  943. 			   sizeof(struct packet_header));
    944. 

  944. 

  945. #if	DEBUG_ETHER_PACKETS
    946. 

  946. 	dump_ether_header("Ether header: ", ehp);
    947. 

  947. 	printf("\nPacket contents: ");
    948. 

  948. 	ptr = (u_char *)ip;
    949. 

  949. 	for (i = 0; i < 100; i++) {
    950. 

  950. 		printf("%x:",(u_char) *ptr);
    951. 

  951. 		ptr++;
    952. 

  952. 	}
    953. 

  953. 	printf("\n");
    954. 

  954. #endif	/* DEBUG_ETHER_PACKETS */
    955. 

  955. 

  956. 	return TRUE;
    957. 

  957. }
    958. 

  958. 

  959. /*
    960. 

  960.  * kttd_get_request:
    961. 

  961.  *
    962. 

  962.  *  This routines waits for a ttd request packet to arrive on the
    963. 

  963.  * ethernet.  It does a polling input for a packet, and then checks
    964. 

  964.  * the packet for a valid ttd request.  It loops until it receives
    965. 

  965.  * a valid ttd request.
    966. 

  966.  *
    967. 

  967.  * Note:  this routine only called from the synchronous ttd code,
    968. 

  968.  *        so arp requests are handled.
    969. 

  969.  *
    970. 

  970.  * We assume that the ttd driver support has been checked and is
    971. 

  971.  * present.
    972. 

  972.  */
    973. 

  973. boolean_t kttd_get_request(vm_offset_t	*ttd_request,
    974. 

  974. 			   natural_t *request_length)
    975. 

  975. {
    976. 

  976. #if	VERBOSE
    977. 

  977. 	if (kttd_debug)
    978. 

  978. 		printf("kttd_get_request entered.\n");
    979. 

  979. #endif	/* VERBOSE */
    980. 

  980. 

  981. 	/*
    982. 

  982. 	 * clean it out, just to be safe.
    983. 

  983. 	 */
    984. 

  984. 	bzero(ttd_request_msg, MAX_TTD_MSG_SIZE);
    985. 

  985. 

  986. 	for(;;) {
    987. 

  987. 		kttd_poll_request();
    988. 

  988. 

  989. #if	VERBOSE		
    990. 

  990. 		if (kttd_debug)
    991. 

  991. 			printf("-");
    992. 

  992. #endif	/* VERBOSE */
    993. 

  993. 

  994. 		if (kttd_valid_request((ipc_kmsg_t)ttd_request_msg,
    995. 

  995. 				       TRUE,
    996. 

  996. 				       (vm_offset_t *)ttd_request,
    997. 

  997. 				       request_length))
    998. 

  998. 			break;
    999. 

  999. 	}
    1000. 

  1000. 

  1001. 	return TRUE;
    1002. 

  1002. }
    1003. 

  1003. 

  1004. /*
    1005. 

  1005.  * Index into the reply.
    1006. 

  1006.  */
    1007. 

  1007. ttd_reply_t skip_net_headers(char * ptr)
    1008. 

  1008. {
    1009. 

  1009. 	/*
    1010. 

  1010. 	 * Skip ether header.
    1011. 

  1011. 	 */
    1012. 

  1012. 	ptr += sizeof (struct ttd_ether_header);
    1013. 

  1013. 	
    1014. 

  1014. 	/*
    1015. 

  1015. 	 * Skip IP header.
    1016. 

  1016. 	 *
    1017. 

  1017. 	 * This is dangerous!!!  IP header length is assumed to
    1018. 

  1018. 	 * be constant for this to work.  Make sure when we
    1019. 

  1019. 	 * build the reply packet that we are setting the header
    1020. 

  1020. 	 * words field correctly.
    1021. 

  1021. 	 */
    1022. 

  1022. 	ptr += OUT_IP_HEADER_BYTES;
    1023. 

  1023. 

  1024. 	/*
    1025. 

  1025. 	 * Skip UDP header.
    1026. 

  1026. 	 */
    1027. 

  1027. 	ptr += sizeof (struct udp_header);
    1028. 

  1028. 

  1029. 	return (ttd_reply_t)ptr;
    1030. 

  1030. }
    1031. 

  1031. 

  1032. /*
    1033. 

  1033.  * Wrap the old build and finish routines into one build
    1034. 

  1034.  * routine.
    1035. 

  1035.  */
    1036. 

  1036. void complete_and_send_ttd_reply(natural_t kttd_reply_length)
    1037. 

  1037. {
    1038. 

  1038. 	struct ttd_ether_header *req_ether_header;
    1039. 

  1039. 	struct packet_header	*req_ether_pkt;
    1040. 

  1040. 	struct ttd_ether_header	*rpy_ether_header;
    1041. 

  1041. 

  1042. 	struct ip_header	*req_ip_header;
    1043. 

  1043. 

  1044. 	struct udp_header	*req_udp_header;
    1045. 

  1045. 

  1046. 	struct udp_header	*rpy_udp_header;
    1047. 

  1047. 	struct ip_header	*rpy_ip_header;
    1048. 

  1048. 

  1049. 	natural_t		tmp_length;
    1050. 

  1050. 	struct udp_pseudo_header uph;
    1051. 

  1051. 

  1052. 	ipc_kmsg_t		tmp_kmsg;
    1053. 

  1053. 

  1054. 	tmp_kmsg = (ipc_kmsg_t)((kttd_current_kmsg == (ipc_kmsg_t)NULL) ?
    1055. 

  1055. 				ttd_request_msg :
    1056. 

  1056. 				kttd_current_kmsg);
    1057. 

  1057. 

  1058. 	/*
    1059. 

  1059. 	 * Build the ethernet part of the reply.
    1060. 

  1060. 	 */
    1061. 

  1061. 

  1062. 	req_ether_header = (struct ttd_ether_header *)
    1063. 

  1063. 		&((net_rcv_msg_t)&(tmp_kmsg)->ikm_header)->header[0];
    1064. 

  1064. 	req_ether_pkt = (struct packet_header *)
    1065. 

  1065. 		&((net_rcv_msg_t)&(tmp_kmsg)->ikm_header)->packet[0];
    1066. 

  1066. 

  1067. 

  1068. 	/*
    1069. 

  1069. 	 * The ttd_reply_msg is just the ether/ip/udp/ttd, it doesn't
    1070. 

  1070. 	 * have the kmsg header junk that the ttd_request_msg has.
    1071. 

  1071. 	 */
    1072. 

  1072. 	rpy_ether_header = (struct ttd_ether_header *)ttd_reply_msg;
    1073. 

  1073. 

  1074. 	rpy_ether_header->source	= req_ether_header->dest;
    1075. 

  1075. 	rpy_ether_header->dest		= req_ether_header->source;
    1076. 

  1076. 	rpy_ether_header->protocol	= req_ether_header->protocol;
    1077. 

  1077. 

  1078. 	/*
    1079. 

  1079. 	 * Partially build the IP header.
    1080. 

  1080. 	 *
    1081. 

  1081. 	 * Note:  Everything at this point is NOT in network order.
    1082. 

  1082. 	 *        The finish_ttd_build procedure must insert the
    1083. 

  1083. 	 *        correct length, byteswap the reply header and 
    1084. 

  1084. 	 *        generate the checksum and insert it.
    1085. 

  1085. 	 */
    1086. 

  1086. 

  1087. 	req_ip_header = (struct ip_header *)skip_pkt_header(req_ether_pkt);
    1088. 

  1088. 	rpy_ip_header = (struct ip_header *)((natural_t)rpy_ether_header +
    1089. 

  1089. 					     sizeof (struct ttd_ether_header));
    1090. 

  1090. 

  1091. 	rpy_ip_header->header_words	= OUT_IP_HEADER_WORDS;
    1092. 

  1092. 	rpy_ip_header->version		= req_ip_header->version;
    1093. 

  1093. 	rpy_ip_header->type_of_service	= req_ip_header->type_of_service;
    1094. 

  1094. /*	rpy_ip_header->length 		= <set later>; */
    1095. 

  1095. 	rpy_ip_header->fragment_stuff	= 0;
    1096. 

  1096. 	rpy_ip_header->id		= 0;
    1097. 

  1097. /*	rpy_ip_header->header_checksum	= <set later>; */
    1098. 

  1098. 	rpy_ip_header->protocol		= req_ip_header->protocol;
    1099. 

  1099. 	rpy_ip_header->time_to_live	= 255;
    1100. 

  1100. 	rpy_ip_header->source		= req_ip_header->dest;
    1101. 

  1101. 	rpy_ip_header->dest		= req_ip_header->source;
    1102. 

  1102. 

  1103. 	/*
    1104. 

  1104. 	 * Partially build the UDP header.
    1105. 

  1105. 	 *
    1106. 

  1106. 	 * Note:  Same problem here as the IP layer.  We will still need
    1107. 

  1107. 	 *        to set the length in the finish_ttd_build section along
    1108. 

  1108. 	 *        with the checksum (if not using zero).
    1109. 

  1109. 	 */
    1110. 

  1110. 

  1111. 	req_udp_header = (struct udp_header *)((natural_t)req_ip_header +
    1112. 

  1112. 					       ((natural_t)req_ip_header->header_words * 4));
    1113. 

  1113. 	rpy_udp_header = (struct udp_header *)((natural_t)rpy_ip_header +
    1114. 

  1114. 					       OUT_IP_HEADER_BYTES);
    1115. 

  1115. 

  1116. 	rpy_udp_header->source_port	= req_udp_header->dest_port;
    1117. 

  1117. 	rpy_udp_header->dest_port	= req_udp_header->source_port;
    1118. 

  1118. /*	rpy_udp_header->length		= <set later>; */
    1119. 

  1119. /*	rpy_udp_header->checksum	= <set later>; */
    1120. 

  1120. 

  1121. 	/*
    1122. 

  1122. 	 * Sanity check.  Make sure that the calculated ttd_reply_msg
    1123. 

  1123. 	 * is the same one we just came up with!!!
    1124. 

  1124. 	 */
    1125. 

  1125. 

  1126. 	if (kttd_debug && ((natural_t) skip_net_headers(ttd_reply_msg) !=
    1127. 

  1127. 			   ((natural_t)rpy_udp_header + (sizeof(struct udp_header))))) {
    1128. 

  1128. 		printf("TTDComm.c: Woah!!! ttd_reply_msg is skewed!!\n");
    1129. 

  1129. 	}
    1130. 

  1130. 	    
    1131. 

  1131. #if	VERBOSE
    1132. 

  1132. 	if (kttd_debug)
    1133. 

  1133. 		printf("build_partial: ttd_reply should start at: 0x%x, ttd_kmsg 0x%x\n",
    1134. 

  1134. 		       (natural_t)rpy_udp_header + sizeof(struct udp_header),
    1135. 

  1135. 		       ttd_reply_msg);
    1136. 

  1136. #endif	/* VERBOSE */
    1137. 

  1137. 

  1138. 	/*
    1139. 

  1139. 	 * Fix up UDP length and checksum:
    1140. 

  1140. 	 */
    1141. 

  1141. 

  1142. 	tmp_length = kttd_reply_length + sizeof(struct udp_header);
    1143. 

  1143. 	rpy_udp_header->length = netswap_2_bytes(tmp_length);
    1144. 

  1144. 

  1145. 	uph.source = rpy_ip_header->source;
    1146. 

  1146. 	uph.dest = rpy_ip_header->dest;
    1147. 

  1147. 	uph.zero = 0;
    1148. 

  1148. 	uph.protocol = rpy_ip_header->protocol;
    1149. 

  1149. 	uph.udp_length = rpy_udp_header->length;
    1150. 

  1150. 

  1151. 	set_udp_checksum(rpy_udp_header, uph);
    1152. 

  1152. 

  1153. 	/*
    1154. 

  1154. 	 * Fix up IP length and checksum:
    1155. 

  1155. 	 */
    1156. 

  1156. 

  1157. 	tmp_length += OUT_IP_HEADER_BYTES;
    1158. 

  1158. 	rpy_ip_header->length = tmp_length;
    1159. 

  1159. 	byteswap_ip_header(rpy_ip_header);
    1160. 

  1160. 	set_ip_checksum(rpy_ip_header);
    1161. 

  1161. 

  1162. #if	DEBUG_ETHER_PACKETS
    1163. 

  1163. 	if (kttd_debug) {
    1164. 

  1164. 		int i;
    1165. 

  1165. 		u_char * ptr;
    1166. 

  1166. 

  1167. 		ptr = (u_char *)ttd_reply_msg;
    1168. 

  1168. 

  1169. 		for (i = 0; i< 100; i++)
    1170. 

  1170. 			printf("%x: ", *ptr++);
    1171. 

  1171. 

  1172. 		printf("\nlength = %d",tmp_length);
    1173. 

  1173. 

  1174. 	}
    1175. 

  1175. #endif	/* DEBUG_ETHER_PACKETS */
    1176. 

  1176. 

  1177. 	/*
    1178. 

  1178. 	 * We've built it, let's send it off!!!
    1179. 

  1179. 	 */
    1180. 

  1180. 	ttd_send_packet(ttd_device_unit, ttd_reply_msg,
    1181. 

  1181. 			((MIN_PACKET > tmp_length + sizeof(struct ttd_ether_header)) ?
    1182. 

  1182. 			  MIN_PACKET : tmp_length + sizeof(struct ttd_ether_header)));
    1183. 

  1183. }
    1184. 

  1184.