![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tftp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / netboot|
Return to tftp.c CVS log | Up to [Net/2] / Net2 / arch / i386 / netboot |
1.1 root 1: /* netboot
2: *
3: * tftp.c,v
4: * Revision 1.1 1993/07/08 16:04:12 brezak
5: * Diskless boot prom code from Jim McKim ([email protected])
6: *
7: * Revision 1.3 1993/06/30 20:14:16 mckim
8: * Added BOOTP support.
9: *
10: * Revision 1.2 1993/05/28 20:01:31 mckim
11: * Fixed various StartProg() problems.
12: *
13: * Revision 1.1.1.1 1993/05/28 11:41:07 mckim
14: * Initial version.
15: *
16: *
17: * source in this file came from
18: * the Mach ethernet boot written by Leendert van Doorn.
19: *
20: * Trivial File Transfer Protocol (see RFC 783).
21: *
22: * Copyright (c) 1992 by Leendert van Doorn
23: */
24: #include "proto.h"
25: #include "assert.h"
26: #include "param.h"
27: #include "packet.h"
28: #include "ether.h"
29: #include "inet.h"
30: #include "tftp.h"
31: #include "arp.h"
32:
33: ipaddr_t tftp_server; /* IP address of TFTP server */
34: ipaddr_t tftp_gateway;
35: static char tftp_file_name[100];
36: static short block; /* current block */
37: static int ctid, stid; /* UDP client and server TID (network order) */
38:
39: extern u_long work_area_org;
40:
41: /*
42: * Print IP address in a readable form
43: */
44: void
45: IpPrintAddr(ipaddr_t addr) {
46: inetaddr_t ip;
47:
48: ip.a = addr;
49: printf("%d.%d.%d.%d", ip.s.a0, ip.s.a1, ip.s.a2, ip.s.a3);
50: }
51:
52: /*
53: * Generic TFTP error routine
54: */
55: static void
56: TftpFail(ipaddr_t fromaddr, ipaddr_t toaddr, char *filename, char *reason) {
57: printf("Tftp of file '%s' from ", filename);
58: IpPrintAddr(fromaddr);
59: printf(" failed, %s\n", reason);
60: }
61:
62: /*
63: * One complement check sum
64: */
65: static u_short
66: InChecksum(char *cp, u_long count) {
67: u_short *sp;
68: u_long sum, oneword = 0x00010000;
69:
70: for (sum = 0, sp = (u_short *)cp, count >>= 1; count--; ) {
71: sum += *sp++;
72: if (sum >= oneword) {
73: /* wrap carry into low bit */
74: sum -= oneword;
75: sum++;
76: }
77: }
78: return ~sum;
79: }
80:
81: /*
82: * Setup the standard IP header fields for a destination,
83: * and send packet (possibly using the gateway).
84: */
85: void
86: IpSend(packet_t *pkt, ipaddr_t dst, ipaddr_t gateway) {
87: iphdr_t *ip;
88: u_char edst[ETH_ADDRSIZE];
89: static int ipid = 0;
90: #if TRACE > 0
91: DUMP_STRUCT("IpSend: pkt (front)", pkt, 100);
92: #endif
93: pkt->pkt_offset -= sizeof(iphdr_t);
94: pkt->pkt_len += sizeof(iphdr_t);
95: ip = (iphdr_t *) pkt->pkt_offset;
96: ip->ip_vhl = (IP_VERSION << 4) | (sizeof(*ip) >> 2);
97: ip->ip_tos = 0;
98: ip->ip_len = htons(pkt->pkt_len);
99: ip->ip_id = ipid++;
100: ip->ip_off = 0;
101: ip->ip_ttl = IP_FRAGTTL;
102: ip->ip_p = IP_PROTO_UDP;
103: ip->ip_src = ip_myaddr ? ip_myaddr : IP_ANYADDR;
104: ip->ip_dst = dst;
105: ip->ip_sum = 0;
106: ip->ip_sum = InChecksum((char *)ip, sizeof(*ip));
107: #if 0
108: /* DUMP_STRUCT("pkt (after)", pkt, 100); */
109: DUMP_STRUCT("ip", ip, sizeof(iphdr_t)+pkt->pkt_len);
110: #endif
111: if (ArpResolve(pkt, gateway ? gateway : dst, edst)) {
112: EtherSend(pkt, ETHTYPE_IP, edst);
113: PktRelease(pkt);
114: }
115: }
116:
117: /*
118: * States which TFTP can be in
119: */
120: enum TftpPacketStatus {
121: TFTP_RECD_GOOD_PACKET,
122: TFTP_RECD_BAD_PACKET,
123: TFTP_RECD_SERVER_ABORT,
124: };
125:
126: /*
127: * Pseudo header to compute UDP checksum
128: */
129: struct pseudoheader {
130: ipaddr_t ph_src;
131: ipaddr_t ph_dst;
132: u_char ph_zero;
133: u_char ph_prot;
134: u_short ph_length;
135: };
136:
137: /*
138: * Determine whether this IP packet is the TFTP data packet
139: * we were expecting. When a broadcast TFTP request was made
140: * we'll set the TFTP server address as well.
141: */
142: static enum TftpPacketStatus
143: TftpDigestPacket(packet_t *pkt, char *rbuf, u_long *rlen) {
144: iphdr_t *ip;
145: udphdr_t *up;
146: tftphdr_t *tp;
147: struct pseudoheader ph;
148: u_short oldsum, sum;
149: u_short udplength;
150:
151: /* check for minimum size tftp packet */
152: if (pkt->pkt_len < (sizeof(ethhdr_t) + sizeof(iphdr_t) +
153: sizeof(udphdr_t) + sizeof(tftphdr_t))) {
154: #if 0
155: printe("TftpDigestPacket: bad packet size %d\n", pkt->pkt_len);
156: #endif
157: return TFTP_RECD_BAD_PACKET;
158: }
159:
160: /* IP related checks */
161: ip = (iphdr_t *) (pkt->pkt_offset + sizeof(ethhdr_t));
162: if (tftp_server != IP_BCASTADDR && ip->ip_src != tftp_server) {
163: #if 0
164: printe("TftpDigestPacket: incorrect ip source address 0x%x\n", ip->ip_src);
165: #endif
166: return TFTP_RECD_BAD_PACKET;
167: }
168: if (ntohs(ip->ip_len) <
169: sizeof(iphdr_t) + sizeof(udphdr_t) + sizeof(tftphdr_t)) {
170: #if 0
171: printe("TftpDigestPacket: bad ip length %d\n", ip->ip_len);
172: #endif
173: return TFTP_RECD_BAD_PACKET;
174: }
175: if (ip->ip_p != IP_PROTO_UDP) {
176: #if 0
177: printe("TftpDigestPacket: wrong ip protocol type 0x%x\n", ip->ip_p);
178: #endif
179: return TFTP_RECD_BAD_PACKET;
180: }
181: if (ip_myaddr && ip->ip_dst != ip_myaddr) {
182: #if 0
183: printe("TftpDigestPacket: incorrect ip destination address %x\n", ip->ip_dst);
184: #endif
185: return TFTP_RECD_BAD_PACKET;
186: }
187:
188: /* UDP related checks */
189: up = (udphdr_t *) ((char *)ip + sizeof(iphdr_t));
190: if (block && up->uh_sport != stid) {
191: #if 0
192: printe("TftpDigestPacket: wrong udp source port 0x%x\n", up->uh_sport);
193: #endif
194: return TFTP_RECD_BAD_PACKET;
195: }
196: *rlen = ntohs(up->uh_len) - sizeof(udphdr_t) - sizeof(tftphdr_t);
197: if (up->uh_dport != ctid) {
198: #if 0
199: printe("TftpDigestPacket: wrong udp destination port 0x%x\n", up->uh_dport);
200: #endif
201: return TFTP_RECD_BAD_PACKET;
202: }
203:
204: /* compute UDP checksum if any */
205: oldsum = up->uh_sum;
206: if (oldsum) {
207: udplength = ntohs(up->uh_len);
208: /*
209: * zero the byte past the last data byte because the
210: * checksum will be over an even number of bytes.
211: */
212: if (udplength & 01)
213: ((char *)up)[udplength] = '\0';
214:
215: /* set up the pseudo-header */
216: ph.ph_src = ip->ip_src;
217: ph.ph_dst = ip->ip_dst;
218: ph.ph_zero = 0;
219: ph.ph_prot = ip->ip_p;
220: ph.ph_length = htons(udplength);
221:
222: up->uh_sum = ~InChecksum((char *)&ph, sizeof(ph));
223: sum = InChecksum((char *)up, (u_long)((udplength + 1) & ~1));
224: up->uh_sum = oldsum; /* put original back */
225: if (oldsum == (u_short) -1)
226: oldsum = 0;
227: if (sum != oldsum) {
228: #if 0
229: printe("TftpDigestPacket: Bad checksum %x != %x, length %d from ",
230: sum, oldsum, udplength);
231: IpPrintAddr(ip->ip_src);
232: printe("\n");
233: #endif
234: return TFTP_RECD_BAD_PACKET;
235: }
236: }
237:
238: /* TFTP related checks */
239: tp = (tftphdr_t *) ((char *)up + sizeof(udphdr_t));
240: switch (ntohs(tp->th_op)) {
241: case TFTP_ERROR:
242: printf("Diagnostic from server: error #%d, %s\n",
243: ntohs(tp->th_code), &tp->th_msg);
244: return TFTP_RECD_SERVER_ABORT;
245: case TFTP_DATA:
246: break;
247: default:
248: #if 0
249: printe("TftpDigestPacket: incorrect tftp packet type 0x%x\n", tp->th_op);
250: #endif
251: return TFTP_RECD_BAD_PACKET;
252: }
253:
254: /* reject old packets */
255: if (ntohs(tp->th_block) != block + 1) {
256: #if 0
257: printe("TftpDigestPacket: bad block no. %d\n", tp->th_block);
258: #endif
259: return TFTP_RECD_BAD_PACKET;
260: }
261:
262: /* some TFTP related check */
263: if (block == 0) {
264: stid = up->uh_sport;
265: /* in case of a broadcast, remember server address */
266: if (tftp_server == IP_BCASTADDR) {
267: tftp_server = ip->ip_src;
268: #if 0
269: printe("Found TFTP server at ");
270: IpPrintAddr(tftp_server);
271: printe("\n");
272: #endif
273: }
274: }
275: if (stid != up->uh_sport) {
276: #if 0
277: printe("TftpDigestPacket: incorrect udp source port 0x%x\n", up->uh_sport);
278: #endif
279: return TFTP_RECD_BAD_PACKET;
280: }
281:
282: bcopy(&tp->th_data, rbuf, *rlen);
283:
284: /* advance to next block */
285: block++;
286: return TFTP_RECD_GOOD_PACKET;
287: }
288:
289: enum TftpStatus {
290: TFTP_SUCCESS,
291: TFTP_FAILURE,
292: };
293:
294: static enum TftpStatus
295: Tftp(char *rbuf, u_long *rlen) {
296: u_long time, current, timeout;
297: int retry, quit;
298: enum TftpStatus rc = TFTP_FAILURE;
299:
300: *rlen = 0;
301: timeout = 4; /* four seconds */
302: for (retry=0, quit=0; ++retry < NRETRIES && !quit; ) {
303: /*
304: * Send out a TFTP request. On the first block (actually
305: * zero) we send out a read request. Every other block we
306: * just acknowledge.
307: */
308: packet_t *pkt;
309: ethhdr_t *ep;
310: udphdr_t *up;
311: tftphdr_t *tp;
312: #if TRACE > 0
313: printe("Tftp: block %d, try #%d\n", block, retry);
314: #endif
315: pkt = PktAlloc(sizeof(ethhdr_t) + sizeof(iphdr_t));
316: up = (udphdr_t *) pkt->pkt_offset;
317: tp = (tftphdr_t *) (pkt->pkt_offset + sizeof(udphdr_t));
318: if (block == 0) { /* <RRQ> | <filename> | 0 | "octet" | 0 */
319: char *cp, *p;
320:
321: tp->th_op = htons(TFTP_RRQ);
322: cp = tp->th_stuff;
323: for (p = tftp_file_name; *p; )
324: *cp++ = *p++;
325: *cp++ = '\0';
326: *cp++ = 'o';
327: *cp++ = 'c';
328: *cp++ = 't';
329: *cp++ = 'e';
330: *cp++ = 't';
331: *cp++ = '\0';
332: pkt->pkt_len = sizeof(udphdr_t) + (cp - (char *)tp);
333: } else { /* else <ACK> | <block> */
334: tp->th_op = htons(TFTP_ACK);
335: tp->th_block = htons(block);
336: #if 0
337: printe("ack block %x %x\n", tp->th_block, block);
338: #endif
339: pkt->pkt_len = sizeof(udphdr_t) + sizeof(tftphdr_t);
340: }
341: up->uh_sport = ctid;
342: up->uh_dport = stid;
343: up->uh_sum = 0;
344: up->uh_len = htons(pkt->pkt_len);
345: #if 0
346: DUMP_STRUCT("tftphdr_t", tp, sizeof(tftphdr_t));
347: DUMP_STRUCT("udphdr_t", up, sizeof(udphdr_t));
348: printe("Tftp: ");
349: #endif
350: IpSend(pkt, tftp_server, tftp_gateway);
351:
352: /*
353: * Receive TFTP data or ARP packets
354: */
355: time = timer() + timeout;
356: do {
357: pkt = EtherReceive();
358: if (pkt) {
359: static int spin = 0;
360: ep = (ethhdr_t *) pkt->pkt_offset;
361: #if 0
362: DUMP_STRUCT("ethhdr_t", ep, sizeof(ethhdr_t));
363: #endif
364: switch (ntohs(ep->eth_proto)) {
365: case ETHTYPE_ARP:
366: ArpInput(pkt);
367: break;
368: case ETHTYPE_IP:
369: switch (TftpDigestPacket(pkt, rbuf, rlen)) {
370: case TFTP_RECD_GOOD_PACKET:
371: if (block % 8 == 0)
372: printf("%c\b", "-\\|/"[spin++ % 4]);
373: #if 0
374: DUMP_STRUCT("good tftp packet", pkt, 100);
375: printe("TBD - copy tftp packet #%d, len %d to buffer\n", block, *rlen);
376: #endif
377: rc = TFTP_SUCCESS;
378: quit = 1;
379: break;
380: case TFTP_RECD_SERVER_ABORT:
381: TftpFail(tftp_server, ip_myaddr, tftp_file_name, "aborted by server");
382:
383: rc = TFTP_FAILURE;
384: quit = 1;
385: break;
386: default:
387: /* for anything else, retry */
388: #if 0
389: printe("Tftp: bogus IP packet rec'd, still waiting\n");
390: #endif
391: break;
392: }
393: break;
394: default:
395: #if 0
396: printe("Tftp: undesired ethernet packet (type 0x%x) rec'd, still waiting\n",
397: ep->eth_proto);
398: #endif
399: break;
400: }
401: PktRelease(pkt);
402: }
403: current = timer();
404: HandleKbdAttn();
405: } while (current < time && !quit);
406:
407: #if 0
408: /* TBD - move */
409: eth_reset();
410: #endif
411:
412: if (current >= time)
413: timeout <<= 1;
414: }
415:
416: if (retry > NRETRIES) {
417: TftpFail(tftp_server, ip_myaddr, tftp_file_name, "timed Out");
418: }
419: return rc;
420: }
421:
422: static int tftp_at_eof = 1;
423: static u_long tftp_unread_bytes_in_buffer = 0;
424:
425: void
426: SetTftpParms(ipaddr_t server, ipaddr_t gateway, char *file_name) {
427: block = 0;
428: strncpy(tftp_file_name, file_name, MAX_FILE_NAME_LEN);
429: tftp_server = server;
430: tftp_at_eof = 0;
431: tftp_unread_bytes_in_buffer = 0;
432: stid = htons(IP_PORT_TFTP);
433: ctid = htons(rand());
434: printf("Attempting to tftp file '%s'", tftp_file_name);
435: if (tftp_server != IP_BCASTADDR) {
436: printf(" from server ");
437: IpPrintAddr(tftp_server);
438: } else
439: printf(" using IP broadcast");
440: tftp_gateway = gateway;
441: if (tftp_gateway) {
442: printf(" using gateway ");
443: IpPrintAddr(tftp_gateway);
444: }
445: printf("\n");
446: }
447:
448: u_long
449: Read(void *result, u_long n_req) {
450: static u_long bufp = 0;
451: static char buf[PKT_DATASIZE];
452: u_long length;
453: u_long n_recd = 0;
454: while (n_req && !tftp_at_eof) {
455: if (tftp_unread_bytes_in_buffer) {
456: *((char *)result)++ = buf[bufp++];
457: n_req--;
458: n_recd++;
459: tftp_unread_bytes_in_buffer--;
460: } else {
461: switch (Tftp(buf, &length)) {
462: case TFTP_SUCCESS:
463: tftp_unread_bytes_in_buffer = length;
464: bufp = 0;
465: if (length < SEGSIZE)
466: tftp_at_eof = 1;
467: break;
468: default:
469: /* anything else should cause this to abend */
470: tftp_unread_bytes_in_buffer = 0;
471: tftp_at_eof = 1;
472: break;
473: }
474: }
475: }
476: return n_recd;
477: }
478:
479: u_long
480: PhysRead(u_long addr, u_long n_req) {
481: u_long n_recd = 0;
482: while (n_req) {
483: char buf[512];
484: u_long nd = n_req<sizeof(buf) ? n_req : sizeof(buf);
485: u_long nr = Read(buf, nd);
486: if (nr == 0) {
487: /* problem, incomplete read */
488: break;
489: }
490: PhysBcopy(LA(buf), addr, nr);
491: n_req -= nr;
492: n_recd += nr;
493: addr += nr;
494: }
495: return n_recd;
496: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.