]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Copyright 1994, 1995, 2000 Neil Russell. | |
3 | * (See License) | |
4 | * Copyright 2000, 2001 DENX Software Engineering, Wolfgang Denk, wd@denx.de | |
5 | * Copyright 2011 Comelit Group SpA, | |
6 | * Luca Ceresoli <luca.ceresoli@comelit.it> | |
7 | */ | |
8 | ||
9 | #include <common.h> | |
10 | #include <command.h> | |
11 | #include <net.h> | |
12 | #include "tftp.h" | |
13 | #include "bootp.h" | |
14 | #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP | |
15 | #include <flash.h> | |
16 | #endif | |
17 | ||
18 | /* Well known TFTP port # */ | |
19 | #define WELL_KNOWN_PORT 69 | |
20 | /* Millisecs to timeout for lost pkt */ | |
21 | #define TIMEOUT 5000UL | |
22 | #ifndef CONFIG_NET_RETRY_COUNT | |
23 | /* # of timeouts before giving up */ | |
24 | # define TIMEOUT_COUNT 10 | |
25 | #else | |
26 | # define TIMEOUT_COUNT (CONFIG_NET_RETRY_COUNT * 2) | |
27 | #endif | |
28 | /* Number of "loading" hashes per line (for checking the image size) */ | |
29 | #define HASHES_PER_LINE 65 | |
30 | ||
31 | /* | |
32 | * TFTP operations. | |
33 | */ | |
34 | #define TFTP_RRQ 1 | |
35 | #define TFTP_WRQ 2 | |
36 | #define TFTP_DATA 3 | |
37 | #define TFTP_ACK 4 | |
38 | #define TFTP_ERROR 5 | |
39 | #define TFTP_OACK 6 | |
40 | ||
41 | static ulong TftpTimeoutMSecs = TIMEOUT; | |
42 | static int TftpTimeoutCountMax = TIMEOUT_COUNT; | |
43 | static ulong time_start; /* Record time we started tftp */ | |
44 | ||
45 | /* | |
46 | * These globals govern the timeout behavior when attempting a connection to a | |
47 | * TFTP server. TftpRRQTimeoutMSecs specifies the number of milliseconds to | |
48 | * wait for the server to respond to initial connection. Second global, | |
49 | * TftpRRQTimeoutCountMax, gives the number of such connection retries. | |
50 | * TftpRRQTimeoutCountMax must be non-negative and TftpRRQTimeoutMSecs must be | |
51 | * positive. The globals are meant to be set (and restored) by code needing | |
52 | * non-standard timeout behavior when initiating a TFTP transfer. | |
53 | */ | |
54 | ulong TftpRRQTimeoutMSecs = TIMEOUT; | |
55 | int TftpRRQTimeoutCountMax = TIMEOUT_COUNT; | |
56 | ||
57 | enum { | |
58 | TFTP_ERR_UNDEFINED = 0, | |
59 | TFTP_ERR_FILE_NOT_FOUND = 1, | |
60 | TFTP_ERR_ACCESS_DENIED = 2, | |
61 | TFTP_ERR_DISK_FULL = 3, | |
62 | TFTP_ERR_UNEXPECTED_OPCODE = 4, | |
63 | TFTP_ERR_UNKNOWN_TRANSFER_ID = 5, | |
64 | TFTP_ERR_FILE_ALREADY_EXISTS = 6, | |
65 | }; | |
66 | ||
67 | static IPaddr_t TftpRemoteIP; | |
68 | /* The UDP port at their end */ | |
69 | static int TftpRemotePort; | |
70 | /* The UDP port at our end */ | |
71 | static int TftpOurPort; | |
72 | static int TftpTimeoutCount; | |
73 | /* packet sequence number */ | |
74 | static ulong TftpBlock; | |
75 | /* last packet sequence number received */ | |
76 | static ulong TftpLastBlock; | |
77 | /* count of sequence number wraparounds */ | |
78 | static ulong TftpBlockWrap; | |
79 | /* memory offset due to wrapping */ | |
80 | static ulong TftpBlockWrapOffset; | |
81 | static int TftpState; | |
82 | #ifdef CONFIG_TFTP_TSIZE | |
83 | /* The file size reported by the server */ | |
84 | static int TftpTsize; | |
85 | /* The number of hashes we printed */ | |
86 | static short TftpNumchars; | |
87 | #endif | |
88 | #ifdef CONFIG_CMD_TFTPPUT | |
89 | static int TftpWriting; /* 1 if writing, else 0 */ | |
90 | static int TftpFinalBlock; /* 1 if we have sent the last block */ | |
91 | #else | |
92 | #define TftpWriting 0 | |
93 | #endif | |
94 | ||
95 | #define STATE_SEND_RRQ 1 | |
96 | #define STATE_DATA 2 | |
97 | #define STATE_TOO_LARGE 3 | |
98 | #define STATE_BAD_MAGIC 4 | |
99 | #define STATE_OACK 5 | |
100 | #define STATE_RECV_WRQ 6 | |
101 | #define STATE_SEND_WRQ 7 | |
102 | ||
103 | /* default TFTP block size */ | |
104 | #define TFTP_BLOCK_SIZE 512 | |
105 | /* sequence number is 16 bit */ | |
106 | #define TFTP_SEQUENCE_SIZE ((ulong)(1<<16)) | |
107 | ||
108 | #define DEFAULT_NAME_LEN (8 + 4 + 1) | |
109 | static char default_filename[DEFAULT_NAME_LEN]; | |
110 | ||
111 | #ifndef CONFIG_TFTP_FILE_NAME_MAX_LEN | |
112 | #define MAX_LEN 128 | |
113 | #else | |
114 | #define MAX_LEN CONFIG_TFTP_FILE_NAME_MAX_LEN | |
115 | #endif | |
116 | ||
117 | static char tftp_filename[MAX_LEN]; | |
118 | ||
119 | /* 512 is poor choice for ethernet, MTU is typically 1500. | |
120 | * Minus eth.hdrs thats 1468. Can get 2x better throughput with | |
121 | * almost-MTU block sizes. At least try... fall back to 512 if need be. | |
122 | * (but those using CONFIG_IP_DEFRAG may want to set a larger block in cfg file) | |
123 | */ | |
124 | #ifdef CONFIG_TFTP_BLOCKSIZE | |
125 | #define TFTP_MTU_BLOCKSIZE CONFIG_TFTP_BLOCKSIZE | |
126 | #else | |
127 | #define TFTP_MTU_BLOCKSIZE 1468 | |
128 | #endif | |
129 | ||
130 | static unsigned short TftpBlkSize = TFTP_BLOCK_SIZE; | |
131 | static unsigned short TftpBlkSizeOption = TFTP_MTU_BLOCKSIZE; | |
132 | ||
133 | #ifdef CONFIG_MCAST_TFTP | |
134 | #include <malloc.h> | |
135 | #define MTFTP_BITMAPSIZE 0x1000 | |
136 | static unsigned *Bitmap; | |
137 | static int PrevBitmapHole, Mapsize = MTFTP_BITMAPSIZE; | |
138 | static uchar ProhibitMcast, MasterClient; | |
139 | static uchar Multicast; | |
140 | static int Mcast_port; | |
141 | static ulong TftpEndingBlock; /* can get 'last' block before done..*/ | |
142 | ||
143 | static void parse_multicast_oack(char *pkt, int len); | |
144 | ||
145 | static void | |
146 | mcast_cleanup(void) | |
147 | { | |
148 | if (Mcast_addr) | |
149 | eth_mcast_join(Mcast_addr, 0); | |
150 | if (Bitmap) | |
151 | free(Bitmap); | |
152 | Bitmap = NULL; | |
153 | Mcast_addr = Multicast = Mcast_port = 0; | |
154 | TftpEndingBlock = -1; | |
155 | } | |
156 | ||
157 | #endif /* CONFIG_MCAST_TFTP */ | |
158 | ||
159 | static inline void | |
160 | store_block(int block, uchar *src, unsigned len) | |
161 | { | |
162 | ulong offset = block * TftpBlkSize + TftpBlockWrapOffset; | |
163 | ulong newsize = offset + len; | |
164 | #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP | |
165 | int i, rc = 0; | |
166 | ||
167 | for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) { | |
168 | /* start address in flash? */ | |
169 | if (flash_info[i].flash_id == FLASH_UNKNOWN) | |
170 | continue; | |
171 | if (load_addr + offset >= flash_info[i].start[0]) { | |
172 | rc = 1; | |
173 | break; | |
174 | } | |
175 | } | |
176 | ||
177 | if (rc) { /* Flash is destination for this packet */ | |
178 | rc = flash_write((char *)src, (ulong)(load_addr+offset), len); | |
179 | if (rc) { | |
180 | flash_perror(rc); | |
181 | net_set_state(NETLOOP_FAIL); | |
182 | return; | |
183 | } | |
184 | } else | |
185 | #endif /* CONFIG_SYS_DIRECT_FLASH_TFTP */ | |
186 | { | |
187 | (void)memcpy((void *)(load_addr + offset), src, len); | |
188 | } | |
189 | #ifdef CONFIG_MCAST_TFTP | |
190 | if (Multicast) | |
191 | ext2_set_bit(block, Bitmap); | |
192 | #endif | |
193 | ||
194 | if (NetBootFileXferSize < newsize) | |
195 | NetBootFileXferSize = newsize; | |
196 | } | |
197 | ||
198 | /* Clear our state ready for a new transfer */ | |
199 | static void new_transfer(void) | |
200 | { | |
201 | TftpLastBlock = 0; | |
202 | TftpBlockWrap = 0; | |
203 | TftpBlockWrapOffset = 0; | |
204 | #ifdef CONFIG_CMD_TFTPPUT | |
205 | TftpFinalBlock = 0; | |
206 | #endif | |
207 | } | |
208 | ||
209 | #ifdef CONFIG_CMD_TFTPPUT | |
210 | /** | |
211 | * Load the next block from memory to be sent over tftp. | |
212 | * | |
213 | * @param block Block number to send | |
214 | * @param dst Destination buffer for data | |
215 | * @param len Number of bytes in block (this one and every other) | |
216 | * @return number of bytes loaded | |
217 | */ | |
218 | static int load_block(unsigned block, uchar *dst, unsigned len) | |
219 | { | |
220 | /* We may want to get the final block from the previous set */ | |
221 | ulong offset = ((int)block - 1) * len + TftpBlockWrapOffset; | |
222 | ulong tosend = len; | |
223 | ||
224 | tosend = min(NetBootFileXferSize - offset, tosend); | |
225 | (void)memcpy(dst, (void *)(save_addr + offset), tosend); | |
226 | debug("%s: block=%d, offset=%ld, len=%d, tosend=%ld\n", __func__, | |
227 | block, offset, len, tosend); | |
228 | return tosend; | |
229 | } | |
230 | #endif | |
231 | ||
232 | static void TftpSend(void); | |
233 | static void TftpTimeout(void); | |
234 | ||
235 | /**********************************************************************/ | |
236 | ||
237 | static void show_block_marker(void) | |
238 | { | |
239 | #ifdef CONFIG_TFTP_TSIZE | |
240 | if (TftpTsize) { | |
241 | ulong pos = TftpBlock * TftpBlkSize + TftpBlockWrapOffset; | |
242 | ||
243 | while (TftpNumchars < pos * 50 / TftpTsize) { | |
244 | putc('#'); | |
245 | TftpNumchars++; | |
246 | } | |
247 | } else | |
248 | #endif | |
249 | { | |
250 | if (((TftpBlock - 1) % 10) == 0) | |
251 | putc('#'); | |
252 | else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0) | |
253 | puts("\n\t "); | |
254 | } | |
255 | } | |
256 | ||
257 | /** | |
258 | * restart the current transfer due to an error | |
259 | * | |
260 | * @param msg Message to print for user | |
261 | */ | |
262 | static void restart(const char *msg) | |
263 | { | |
264 | printf("\n%s; starting again\n", msg); | |
265 | #ifdef CONFIG_MCAST_TFTP | |
266 | mcast_cleanup(); | |
267 | #endif | |
268 | NetStartAgain(); | |
269 | } | |
270 | ||
271 | /* | |
272 | * Check if the block number has wrapped, and update progress | |
273 | * | |
274 | * TODO: The egregious use of global variables in this file should be tidied. | |
275 | */ | |
276 | static void update_block_number(void) | |
277 | { | |
278 | /* | |
279 | * RFC1350 specifies that the first data packet will | |
280 | * have sequence number 1. If we receive a sequence | |
281 | * number of 0 this means that there was a wrap | |
282 | * around of the (16 bit) counter. | |
283 | */ | |
284 | if (TftpBlock == 0 && TftpLastBlock != 0) { | |
285 | TftpBlockWrap++; | |
286 | TftpBlockWrapOffset += TftpBlkSize * TFTP_SEQUENCE_SIZE; | |
287 | TftpTimeoutCount = 0; /* we've done well, reset thhe timeout */ | |
288 | } else { | |
289 | show_block_marker(); | |
290 | } | |
291 | } | |
292 | ||
293 | /* The TFTP get or put is complete */ | |
294 | static void tftp_complete(void) | |
295 | { | |
296 | #ifdef CONFIG_TFTP_TSIZE | |
297 | /* Print hash marks for the last packet received */ | |
298 | while (TftpTsize && TftpNumchars < 49) { | |
299 | putc('#'); | |
300 | TftpNumchars++; | |
301 | } | |
302 | puts(" "); | |
303 | print_size(TftpTsize, ""); | |
304 | #endif | |
305 | time_start = get_timer(time_start); | |
306 | if (time_start > 0) { | |
307 | puts("\n\t "); /* Line up with "Loading: " */ | |
308 | print_size(NetBootFileXferSize / | |
309 | time_start * 1000, "/s"); | |
310 | } | |
311 | puts("\ndone\n"); | |
312 | net_set_state(NETLOOP_SUCCESS); | |
313 | } | |
314 | ||
315 | static void | |
316 | TftpSend(void) | |
317 | { | |
318 | uchar *pkt; | |
319 | uchar *xp; | |
320 | int len = 0; | |
321 | ushort *s; | |
322 | ||
323 | #ifdef CONFIG_MCAST_TFTP | |
324 | /* Multicast TFTP.. non-MasterClients do not ACK data. */ | |
325 | if (Multicast | |
326 | && (TftpState == STATE_DATA) | |
327 | && (MasterClient == 0)) | |
328 | return; | |
329 | #endif | |
330 | /* | |
331 | * We will always be sending some sort of packet, so | |
332 | * cobble together the packet headers now. | |
333 | */ | |
334 | pkt = NetTxPacket + NetEthHdrSize() + IP_UDP_HDR_SIZE; | |
335 | ||
336 | switch (TftpState) { | |
337 | case STATE_SEND_RRQ: | |
338 | case STATE_SEND_WRQ: | |
339 | xp = pkt; | |
340 | s = (ushort *)pkt; | |
341 | #ifdef CONFIG_CMD_TFTPPUT | |
342 | *s++ = htons(TftpState == STATE_SEND_RRQ ? TFTP_RRQ : | |
343 | TFTP_WRQ); | |
344 | #else | |
345 | *s++ = htons(TFTP_RRQ); | |
346 | #endif | |
347 | pkt = (uchar *)s; | |
348 | strcpy((char *)pkt, tftp_filename); | |
349 | pkt += strlen(tftp_filename) + 1; | |
350 | strcpy((char *)pkt, "octet"); | |
351 | pkt += 5 /*strlen("octet")*/ + 1; | |
352 | strcpy((char *)pkt, "timeout"); | |
353 | pkt += 7 /*strlen("timeout")*/ + 1; | |
354 | sprintf((char *)pkt, "%lu", TftpTimeoutMSecs / 1000); | |
355 | debug("send option \"timeout %s\"\n", (char *)pkt); | |
356 | pkt += strlen((char *)pkt) + 1; | |
357 | #ifdef CONFIG_TFTP_TSIZE | |
358 | pkt += sprintf((char *)pkt, "tsize%c%lu%c", | |
359 | 0, NetBootFileXferSize, 0); | |
360 | #endif | |
361 | /* try for more effic. blk size */ | |
362 | pkt += sprintf((char *)pkt, "blksize%c%d%c", | |
363 | 0, TftpBlkSizeOption, 0); | |
364 | #ifdef CONFIG_MCAST_TFTP | |
365 | /* Check all preconditions before even trying the option */ | |
366 | if (!ProhibitMcast) { | |
367 | Bitmap = malloc(Mapsize); | |
368 | if (Bitmap && eth_get_dev()->mcast) { | |
369 | free(Bitmap); | |
370 | Bitmap = NULL; | |
371 | pkt += sprintf((char *)pkt, "multicast%c%c", | |
372 | 0, 0); | |
373 | } | |
374 | } | |
375 | #endif /* CONFIG_MCAST_TFTP */ | |
376 | len = pkt - xp; | |
377 | break; | |
378 | ||
379 | case STATE_OACK: | |
380 | #ifdef CONFIG_MCAST_TFTP | |
381 | /* My turn! Start at where I need blocks I missed.*/ | |
382 | if (Multicast) | |
383 | TftpBlock = ext2_find_next_zero_bit(Bitmap, | |
384 | (Mapsize*8), 0); | |
385 | /*..falling..*/ | |
386 | #endif | |
387 | ||
388 | case STATE_RECV_WRQ: | |
389 | case STATE_DATA: | |
390 | xp = pkt; | |
391 | s = (ushort *)pkt; | |
392 | s[0] = htons(TFTP_ACK); | |
393 | s[1] = htons(TftpBlock); | |
394 | pkt = (uchar *)(s + 2); | |
395 | #ifdef CONFIG_CMD_TFTPPUT | |
396 | if (TftpWriting) { | |
397 | int toload = TftpBlkSize; | |
398 | int loaded = load_block(TftpBlock, pkt, toload); | |
399 | ||
400 | s[0] = htons(TFTP_DATA); | |
401 | pkt += loaded; | |
402 | TftpFinalBlock = (loaded < toload); | |
403 | } | |
404 | #endif | |
405 | len = pkt - xp; | |
406 | break; | |
407 | ||
408 | case STATE_TOO_LARGE: | |
409 | xp = pkt; | |
410 | s = (ushort *)pkt; | |
411 | *s++ = htons(TFTP_ERROR); | |
412 | *s++ = htons(3); | |
413 | ||
414 | pkt = (uchar *)s; | |
415 | strcpy((char *)pkt, "File too large"); | |
416 | pkt += 14 /*strlen("File too large")*/ + 1; | |
417 | len = pkt - xp; | |
418 | break; | |
419 | ||
420 | case STATE_BAD_MAGIC: | |
421 | xp = pkt; | |
422 | s = (ushort *)pkt; | |
423 | *s++ = htons(TFTP_ERROR); | |
424 | *s++ = htons(2); | |
425 | pkt = (uchar *)s; | |
426 | strcpy((char *)pkt, "File has bad magic"); | |
427 | pkt += 18 /*strlen("File has bad magic")*/ + 1; | |
428 | len = pkt - xp; | |
429 | break; | |
430 | } | |
431 | ||
432 | NetSendUDPPacket(NetServerEther, TftpRemoteIP, TftpRemotePort, | |
433 | TftpOurPort, len); | |
434 | } | |
435 | ||
436 | #ifdef CONFIG_CMD_TFTPPUT | |
437 | static void icmp_handler(unsigned type, unsigned code, unsigned dest, | |
438 | IPaddr_t sip, unsigned src, uchar *pkt, unsigned len) | |
439 | { | |
440 | if (type == ICMP_NOT_REACH && code == ICMP_NOT_REACH_PORT) { | |
441 | /* Oh dear the other end has gone away */ | |
442 | restart("TFTP server died"); | |
443 | } | |
444 | } | |
445 | #endif | |
446 | ||
447 | static void | |
448 | TftpHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src, | |
449 | unsigned len) | |
450 | { | |
451 | __be16 proto; | |
452 | __be16 *s; | |
453 | int i; | |
454 | ||
455 | if (dest != TftpOurPort) { | |
456 | #ifdef CONFIG_MCAST_TFTP | |
457 | if (Multicast | |
458 | && (!Mcast_port || (dest != Mcast_port))) | |
459 | #endif | |
460 | return; | |
461 | } | |
462 | if (TftpState != STATE_SEND_RRQ && src != TftpRemotePort && | |
463 | TftpState != STATE_RECV_WRQ && TftpState != STATE_SEND_WRQ) | |
464 | return; | |
465 | ||
466 | if (len < 2) | |
467 | return; | |
468 | len -= 2; | |
469 | /* warning: don't use increment (++) in ntohs() macros!! */ | |
470 | s = (__be16 *)pkt; | |
471 | proto = *s++; | |
472 | pkt = (uchar *)s; | |
473 | switch (ntohs(proto)) { | |
474 | ||
475 | case TFTP_RRQ: | |
476 | break; | |
477 | ||
478 | case TFTP_ACK: | |
479 | #ifdef CONFIG_CMD_TFTPPUT | |
480 | if (TftpWriting) { | |
481 | if (TftpFinalBlock) { | |
482 | tftp_complete(); | |
483 | } else { | |
484 | /* | |
485 | * Move to the next block. We want our block | |
486 | * count to wrap just like the other end! | |
487 | */ | |
488 | int block = ntohs(*s); | |
489 | int ack_ok = (TftpBlock == block); | |
490 | ||
491 | TftpBlock = (unsigned short)(block + 1); | |
492 | update_block_number(); | |
493 | if (ack_ok) | |
494 | TftpSend(); /* Send next data block */ | |
495 | } | |
496 | } | |
497 | #endif | |
498 | break; | |
499 | ||
500 | default: | |
501 | break; | |
502 | ||
503 | #ifdef CONFIG_CMD_TFTPSRV | |
504 | case TFTP_WRQ: | |
505 | debug("Got WRQ\n"); | |
506 | TftpRemoteIP = sip; | |
507 | TftpRemotePort = src; | |
508 | TftpOurPort = 1024 + (get_timer(0) % 3072); | |
509 | new_transfer(); | |
510 | TftpSend(); /* Send ACK(0) */ | |
511 | break; | |
512 | #endif | |
513 | ||
514 | case TFTP_OACK: | |
515 | debug("Got OACK: %s %s\n", | |
516 | pkt, | |
517 | pkt + strlen((char *)pkt) + 1); | |
518 | TftpState = STATE_OACK; | |
519 | TftpRemotePort = src; | |
520 | /* | |
521 | * Check for 'blksize' option. | |
522 | * Careful: "i" is signed, "len" is unsigned, thus | |
523 | * something like "len-8" may give a *huge* number | |
524 | */ | |
525 | for (i = 0; i+8 < len; i++) { | |
526 | if (strcmp((char *)pkt+i, "blksize") == 0) { | |
527 | TftpBlkSize = (unsigned short) | |
528 | simple_strtoul((char *)pkt+i+8, NULL, | |
529 | 10); | |
530 | debug("Blocksize ack: %s, %d\n", | |
531 | (char *)pkt+i+8, TftpBlkSize); | |
532 | } | |
533 | #ifdef CONFIG_TFTP_TSIZE | |
534 | if (strcmp((char *)pkt+i, "tsize") == 0) { | |
535 | TftpTsize = simple_strtoul((char *)pkt+i+6, | |
536 | NULL, 10); | |
537 | debug("size = %s, %d\n", | |
538 | (char *)pkt+i+6, TftpTsize); | |
539 | } | |
540 | #endif | |
541 | } | |
542 | #ifdef CONFIG_MCAST_TFTP | |
543 | parse_multicast_oack((char *)pkt, len-1); | |
544 | if ((Multicast) && (!MasterClient)) | |
545 | TftpState = STATE_DATA; /* passive.. */ | |
546 | else | |
547 | #endif | |
548 | #ifdef CONFIG_CMD_TFTPPUT | |
549 | if (TftpWriting) { | |
550 | /* Get ready to send the first block */ | |
551 | TftpState = STATE_DATA; | |
552 | TftpBlock++; | |
553 | } | |
554 | #endif | |
555 | TftpSend(); /* Send ACK or first data block */ | |
556 | break; | |
557 | case TFTP_DATA: | |
558 | if (len < 2) | |
559 | return; | |
560 | len -= 2; | |
561 | TftpBlock = ntohs(*(__be16 *)pkt); | |
562 | ||
563 | update_block_number(); | |
564 | ||
565 | if (TftpState == STATE_SEND_RRQ) | |
566 | debug("Server did not acknowledge timeout option!\n"); | |
567 | ||
568 | if (TftpState == STATE_SEND_RRQ || TftpState == STATE_OACK || | |
569 | TftpState == STATE_RECV_WRQ) { | |
570 | /* first block received */ | |
571 | TftpState = STATE_DATA; | |
572 | TftpRemotePort = src; | |
573 | new_transfer(); | |
574 | ||
575 | #ifdef CONFIG_MCAST_TFTP | |
576 | if (Multicast) { /* start!=1 common if mcast */ | |
577 | TftpLastBlock = TftpBlock - 1; | |
578 | } else | |
579 | #endif | |
580 | if (TftpBlock != 1) { /* Assertion */ | |
581 | printf("\nTFTP error: " | |
582 | "First block is not block 1 (%ld)\n" | |
583 | "Starting again\n\n", | |
584 | TftpBlock); | |
585 | NetStartAgain(); | |
586 | break; | |
587 | } | |
588 | } | |
589 | ||
590 | if (TftpBlock == TftpLastBlock) { | |
591 | /* | |
592 | * Same block again; ignore it. | |
593 | */ | |
594 | break; | |
595 | } | |
596 | ||
597 | TftpLastBlock = TftpBlock; | |
598 | TftpTimeoutCountMax = TIMEOUT_COUNT; | |
599 | NetSetTimeout(TftpTimeoutMSecs, TftpTimeout); | |
600 | ||
601 | store_block(TftpBlock - 1, pkt + 2, len); | |
602 | ||
603 | /* | |
604 | * Acknowledge the block just received, which will prompt | |
605 | * the remote for the next one. | |
606 | */ | |
607 | #ifdef CONFIG_MCAST_TFTP | |
608 | /* if I am the MasterClient, actively calculate what my next | |
609 | * needed block is; else I'm passive; not ACKING | |
610 | */ | |
611 | if (Multicast) { | |
612 | if (len < TftpBlkSize) { | |
613 | TftpEndingBlock = TftpBlock; | |
614 | } else if (MasterClient) { | |
615 | TftpBlock = PrevBitmapHole = | |
616 | ext2_find_next_zero_bit( | |
617 | Bitmap, | |
618 | (Mapsize*8), | |
619 | PrevBitmapHole); | |
620 | if (TftpBlock > ((Mapsize*8) - 1)) { | |
621 | printf("tftpfile too big\n"); | |
622 | /* try to double it and retry */ | |
623 | Mapsize <<= 1; | |
624 | mcast_cleanup(); | |
625 | NetStartAgain(); | |
626 | return; | |
627 | } | |
628 | TftpLastBlock = TftpBlock; | |
629 | } | |
630 | } | |
631 | #endif | |
632 | TftpSend(); | |
633 | ||
634 | #ifdef CONFIG_MCAST_TFTP | |
635 | if (Multicast) { | |
636 | if (MasterClient && (TftpBlock >= TftpEndingBlock)) { | |
637 | puts("\nMulticast tftp done\n"); | |
638 | mcast_cleanup(); | |
639 | net_set_state(NETLOOP_SUCCESS); | |
640 | } | |
641 | } else | |
642 | #endif | |
643 | if (len < TftpBlkSize) | |
644 | tftp_complete(); | |
645 | break; | |
646 | ||
647 | case TFTP_ERROR: | |
648 | printf("\nTFTP error: '%s' (%d)\n", | |
649 | pkt + 2, ntohs(*(__be16 *)pkt)); | |
650 | ||
651 | switch (ntohs(*(__be16 *)pkt)) { | |
652 | case TFTP_ERR_FILE_NOT_FOUND: | |
653 | case TFTP_ERR_ACCESS_DENIED: | |
654 | puts("Not retrying...\n"); | |
655 | eth_halt(); | |
656 | net_set_state(NETLOOP_FAIL); | |
657 | break; | |
658 | case TFTP_ERR_UNDEFINED: | |
659 | case TFTP_ERR_DISK_FULL: | |
660 | case TFTP_ERR_UNEXPECTED_OPCODE: | |
661 | case TFTP_ERR_UNKNOWN_TRANSFER_ID: | |
662 | case TFTP_ERR_FILE_ALREADY_EXISTS: | |
663 | default: | |
664 | puts("Starting again\n\n"); | |
665 | #ifdef CONFIG_MCAST_TFTP | |
666 | mcast_cleanup(); | |
667 | #endif | |
668 | NetStartAgain(); | |
669 | break; | |
670 | } | |
671 | break; | |
672 | } | |
673 | } | |
674 | ||
675 | ||
676 | static void | |
677 | TftpTimeout(void) | |
678 | { | |
679 | if (++TftpTimeoutCount > TftpTimeoutCountMax) { | |
680 | restart("Retry count exceeded"); | |
681 | } else { | |
682 | puts("T "); | |
683 | NetSetTimeout(TftpTimeoutMSecs, TftpTimeout); | |
684 | if (TftpState != STATE_RECV_WRQ) | |
685 | TftpSend(); | |
686 | } | |
687 | } | |
688 | ||
689 | ||
690 | void TftpStart(enum proto_t protocol) | |
691 | { | |
692 | char *ep; /* Environment pointer */ | |
693 | ||
694 | /* | |
695 | * Allow the user to choose TFTP blocksize and timeout. | |
696 | * TFTP protocol has a minimal timeout of 1 second. | |
697 | */ | |
698 | ep = getenv("tftpblocksize"); | |
699 | if (ep != NULL) | |
700 | TftpBlkSizeOption = simple_strtol(ep, NULL, 10); | |
701 | ||
702 | ep = getenv("tftptimeout"); | |
703 | if (ep != NULL) | |
704 | TftpTimeoutMSecs = simple_strtol(ep, NULL, 10); | |
705 | ||
706 | if (TftpTimeoutMSecs < 1000) { | |
707 | printf("TFTP timeout (%ld ms) too low, " | |
708 | "set minimum = 1000 ms\n", | |
709 | TftpTimeoutMSecs); | |
710 | TftpTimeoutMSecs = 1000; | |
711 | } | |
712 | ||
713 | debug("TFTP blocksize = %i, timeout = %ld ms\n", | |
714 | TftpBlkSizeOption, TftpTimeoutMSecs); | |
715 | ||
716 | TftpRemoteIP = NetServerIP; | |
717 | if (BootFile[0] == '\0') { | |
718 | sprintf(default_filename, "%02X%02X%02X%02X.img", | |
719 | NetOurIP & 0xFF, | |
720 | (NetOurIP >> 8) & 0xFF, | |
721 | (NetOurIP >> 16) & 0xFF, | |
722 | (NetOurIP >> 24) & 0xFF); | |
723 | ||
724 | strncpy(tftp_filename, default_filename, MAX_LEN); | |
725 | tftp_filename[MAX_LEN-1] = 0; | |
726 | ||
727 | printf("*** Warning: no boot file name; using '%s'\n", | |
728 | tftp_filename); | |
729 | } else { | |
730 | char *p = strchr(BootFile, ':'); | |
731 | ||
732 | if (p == NULL) { | |
733 | strncpy(tftp_filename, BootFile, MAX_LEN); | |
734 | tftp_filename[MAX_LEN-1] = 0; | |
735 | } else { | |
736 | TftpRemoteIP = string_to_ip(BootFile); | |
737 | strncpy(tftp_filename, p + 1, MAX_LEN); | |
738 | tftp_filename[MAX_LEN-1] = 0; | |
739 | } | |
740 | } | |
741 | ||
742 | printf("Using %s device\n", eth_get_name()); | |
743 | printf("TFTP %s server %pI4; our IP address is %pI4", | |
744 | #ifdef CONFIG_CMD_TFTPPUT | |
745 | protocol == TFTPPUT ? "to" : "from", | |
746 | #else | |
747 | "from", | |
748 | #endif | |
749 | &TftpRemoteIP, &NetOurIP); | |
750 | ||
751 | /* Check if we need to send across this subnet */ | |
752 | if (NetOurGatewayIP && NetOurSubnetMask) { | |
753 | IPaddr_t OurNet = NetOurIP & NetOurSubnetMask; | |
754 | IPaddr_t RemoteNet = TftpRemoteIP & NetOurSubnetMask; | |
755 | ||
756 | if (OurNet != RemoteNet) | |
757 | printf("; sending through gateway %pI4", | |
758 | &NetOurGatewayIP); | |
759 | } | |
760 | putc('\n'); | |
761 | ||
762 | printf("Filename '%s'.", tftp_filename); | |
763 | ||
764 | if (NetBootFileSize) { | |
765 | printf(" Size is 0x%x Bytes = ", NetBootFileSize<<9); | |
766 | print_size(NetBootFileSize<<9, ""); | |
767 | } | |
768 | ||
769 | putc('\n'); | |
770 | #ifdef CONFIG_CMD_TFTPPUT | |
771 | TftpWriting = (protocol == TFTPPUT); | |
772 | if (TftpWriting) { | |
773 | printf("Save address: 0x%lx\n", save_addr); | |
774 | printf("Save size: 0x%lx\n", save_size); | |
775 | NetBootFileXferSize = save_size; | |
776 | puts("Saving: *\b"); | |
777 | TftpState = STATE_SEND_WRQ; | |
778 | new_transfer(); | |
779 | } else | |
780 | #endif | |
781 | { | |
782 | printf("Load address: 0x%lx\n", load_addr); | |
783 | puts("Loading: *\b"); | |
784 | TftpState = STATE_SEND_RRQ; | |
785 | } | |
786 | ||
787 | time_start = get_timer(0); | |
788 | TftpTimeoutCountMax = TftpRRQTimeoutCountMax; | |
789 | ||
790 | NetSetTimeout(TftpTimeoutMSecs, TftpTimeout); | |
791 | net_set_udp_handler(TftpHandler); | |
792 | #ifdef CONFIG_CMD_TFTPPUT | |
793 | net_set_icmp_handler(icmp_handler); | |
794 | #endif | |
795 | TftpRemotePort = WELL_KNOWN_PORT; | |
796 | TftpTimeoutCount = 0; | |
797 | /* Use a pseudo-random port unless a specific port is set */ | |
798 | TftpOurPort = 1024 + (get_timer(0) % 3072); | |
799 | ||
800 | #ifdef CONFIG_TFTP_PORT | |
801 | ep = getenv("tftpdstp"); | |
802 | if (ep != NULL) | |
803 | TftpRemotePort = simple_strtol(ep, NULL, 10); | |
804 | ep = getenv("tftpsrcp"); | |
805 | if (ep != NULL) | |
806 | TftpOurPort = simple_strtol(ep, NULL, 10); | |
807 | #endif | |
808 | TftpBlock = 0; | |
809 | ||
810 | /* zero out server ether in case the server ip has changed */ | |
811 | memset(NetServerEther, 0, 6); | |
812 | /* Revert TftpBlkSize to dflt */ | |
813 | TftpBlkSize = TFTP_BLOCK_SIZE; | |
814 | #ifdef CONFIG_MCAST_TFTP | |
815 | mcast_cleanup(); | |
816 | #endif | |
817 | #ifdef CONFIG_TFTP_TSIZE | |
818 | TftpTsize = 0; | |
819 | TftpNumchars = 0; | |
820 | #endif | |
821 | ||
822 | TftpSend(); | |
823 | } | |
824 | ||
825 | #ifdef CONFIG_CMD_TFTPSRV | |
826 | void | |
827 | TftpStartServer(void) | |
828 | { | |
829 | tftp_filename[0] = 0; | |
830 | ||
831 | printf("Using %s device\n", eth_get_name()); | |
832 | printf("Listening for TFTP transfer on %pI4\n", &NetOurIP); | |
833 | printf("Load address: 0x%lx\n", load_addr); | |
834 | ||
835 | puts("Loading: *\b"); | |
836 | ||
837 | TftpTimeoutCountMax = TIMEOUT_COUNT; | |
838 | TftpTimeoutCount = 0; | |
839 | TftpTimeoutMSecs = TIMEOUT; | |
840 | NetSetTimeout(TftpTimeoutMSecs, TftpTimeout); | |
841 | ||
842 | /* Revert TftpBlkSize to dflt */ | |
843 | TftpBlkSize = TFTP_BLOCK_SIZE; | |
844 | TftpBlock = 0; | |
845 | TftpOurPort = WELL_KNOWN_PORT; | |
846 | ||
847 | #ifdef CONFIG_TFTP_TSIZE | |
848 | TftpTsize = 0; | |
849 | TftpNumchars = 0; | |
850 | #endif | |
851 | ||
852 | TftpState = STATE_RECV_WRQ; | |
853 | net_set_udp_handler(TftpHandler); | |
854 | ||
855 | /* zero out server ether in case the server ip has changed */ | |
856 | memset(NetServerEther, 0, 6); | |
857 | } | |
858 | #endif /* CONFIG_CMD_TFTPSRV */ | |
859 | ||
860 | #ifdef CONFIG_MCAST_TFTP | |
861 | /* Credits: atftp project. | |
862 | */ | |
863 | ||
864 | /* pick up BcastAddr, Port, and whether I am [now] the master-client. * | |
865 | * Frame: | |
866 | * +-------+-----------+---+-------~~-------+---+ | |
867 | * | opc | multicast | 0 | addr, port, mc | 0 | | |
868 | * +-------+-----------+---+-------~~-------+---+ | |
869 | * The multicast addr/port becomes what I listen to, and if 'mc' is '1' then | |
870 | * I am the new master-client so must send ACKs to DataBlocks. If I am not | |
871 | * master-client, I'm a passive client, gathering what DataBlocks I may and | |
872 | * making note of which ones I got in my bitmask. | |
873 | * In theory, I never go from master->passive.. | |
874 | * .. this comes in with pkt already pointing just past opc | |
875 | */ | |
876 | static void parse_multicast_oack(char *pkt, int len) | |
877 | { | |
878 | int i; | |
879 | IPaddr_t addr; | |
880 | char *mc_adr, *port, *mc; | |
881 | ||
882 | mc_adr = port = mc = NULL; | |
883 | /* march along looking for 'multicast\0', which has to start at least | |
884 | * 14 bytes back from the end. | |
885 | */ | |
886 | for (i = 0; i < len-14; i++) | |
887 | if (strcmp(pkt+i, "multicast") == 0) | |
888 | break; | |
889 | if (i >= (len-14)) /* non-Multicast OACK, ign. */ | |
890 | return; | |
891 | ||
892 | i += 10; /* strlen multicast */ | |
893 | mc_adr = pkt+i; | |
894 | for (; i < len; i++) { | |
895 | if (*(pkt+i) == ',') { | |
896 | *(pkt+i) = '\0'; | |
897 | if (port) { | |
898 | mc = pkt+i+1; | |
899 | break; | |
900 | } else { | |
901 | port = pkt+i+1; | |
902 | } | |
903 | } | |
904 | } | |
905 | if (!port || !mc_adr || !mc) | |
906 | return; | |
907 | if (Multicast && MasterClient) { | |
908 | printf("I got a OACK as master Client, WRONG!\n"); | |
909 | return; | |
910 | } | |
911 | /* ..I now accept packets destined for this MCAST addr, port */ | |
912 | if (!Multicast) { | |
913 | if (Bitmap) { | |
914 | printf("Internal failure! no mcast.\n"); | |
915 | free(Bitmap); | |
916 | Bitmap = NULL; | |
917 | ProhibitMcast = 1; | |
918 | return ; | |
919 | } | |
920 | /* I malloc instead of pre-declare; so that if the file ends | |
921 | * up being too big for this bitmap I can retry | |
922 | */ | |
923 | Bitmap = malloc(Mapsize); | |
924 | if (!Bitmap) { | |
925 | printf("No Bitmap, no multicast. Sorry.\n"); | |
926 | ProhibitMcast = 1; | |
927 | return; | |
928 | } | |
929 | memset(Bitmap, 0, Mapsize); | |
930 | PrevBitmapHole = 0; | |
931 | Multicast = 1; | |
932 | } | |
933 | addr = string_to_ip(mc_adr); | |
934 | if (Mcast_addr != addr) { | |
935 | if (Mcast_addr) | |
936 | eth_mcast_join(Mcast_addr, 0); | |
937 | Mcast_addr = addr; | |
938 | if (eth_mcast_join(Mcast_addr, 1)) { | |
939 | printf("Fail to set mcast, revert to TFTP\n"); | |
940 | ProhibitMcast = 1; | |
941 | mcast_cleanup(); | |
942 | NetStartAgain(); | |
943 | } | |
944 | } | |
945 | MasterClient = (unsigned char)simple_strtoul((char *)mc, NULL, 10); | |
946 | Mcast_port = (unsigned short)simple_strtoul(port, NULL, 10); | |
947 | printf("Multicast: %s:%d [%d]\n", mc_adr, Mcast_port, MasterClient); | |
948 | return; | |
949 | } | |
950 | ||
951 | #endif /* Multicast TFTP */ |