]> git.ipfire.org Git - thirdparty/u-boot.git/blob - net/nfs.c
projects / thirdparty / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge patch series "net fixes prior lwip"
[thirdparty/u-boot.git] / net / nfs.c
1 /*
2 * NFS support driver - based on etherboot and U-BOOT's tftp.c
3 *
4 * Masami Komiya <mkomiya@sonare.it> 2004
5 *
6 */
7
8 /* NOTE: the NFS code is heavily inspired by the NetBSD netboot code (read:
9 * large portions are copied verbatim) as distributed in OSKit 0.97. A few
10 * changes were necessary to adapt the code to Etherboot and to fix several
11 * inconsistencies. Also the RPC message preparation is done "by hand" to
12 * avoid adding netsprintf() which I find hard to understand and use. */
13
14 /* NOTE 2: Etherboot does not care about things beyond the kernel image, so
15 * it loads the kernel image off the boot server (ARP_SERVER) and does not
16 * access the client root disk (root-path in dhcpd.conf), which would use
17 * ARP_ROOTSERVER. The root disk is something the operating system we are
18 * about to load needs to use. This is different from the OSKit 0.97 logic. */
19
20 /* NOTE 3: Symlink handling introduced by Anselm M Hoffmeister, 2003-July-14
21 * If a symlink is encountered, it is followed as far as possible (recursion
22 * possible, maximum 16 steps). There is no clearing of ".."'s inside the
23 * path, so please DON'T DO THAT. thx. */
24
25 /* NOTE 4: NFSv3 support added by Guillaume GARDET, 2016-June-20.
26 * NFSv2 is still used by default. But if server does not support NFSv2, then
27 * NFSv3 is used, if available on NFS server. */
28
29 /* NOTE 5: NFSv1 support added by Christian Gmeiner, Thomas Rienoessl,
30 * September 27, 2018. As of now, NFSv3 is the default choice. If the server
31 * does not support NFSv3, we fall back to versions 2 or 1. */
32
33 #include <common.h>
34 #include <command.h>
35 #include <display_options.h>
36 #ifdef CONFIG_SYS_DIRECT_FLASH_NFS
37 #include <flash.h>
38 #endif
39 #include <image.h>
40 #include <log.h>
41 #include <net.h>
42 #include <malloc.h>
43 #include <mapmem.h>
44 #include "nfs.h"
45 #include "bootp.h"
46 #include <time.h>
47
48 #define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
49 #define NFS_RETRY_COUNT 30
50
51 #define NFS_RPC_ERR 1
52 #define NFS_RPC_DROP 124
53
54 static int fs_mounted;
55 static unsigned long rpc_id;
56 static int nfs_offset = -1;
57 static int nfs_len;
58 static const ulong nfs_timeout = CONFIG_NFS_TIMEOUT;
59
60 static char dirfh[NFS_FHSIZE]; /* NFSv2 / NFSv3 file handle of directory */
61 static char filefh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle */
62 static unsigned int filefh3_length; /* (variable) length of filefh when NFSv3 */
63
64 static enum net_loop_state nfs_download_state;
65 static struct in_addr nfs_server_ip;
66 static int nfs_server_mount_port;
67 static int nfs_server_port;
68 static int nfs_our_port;
69 static int nfs_timeout_count;
70 static int nfs_state;
71 #define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
72 #define STATE_PRCLOOKUP_PROG_NFS_REQ 2
73 #define STATE_MOUNT_REQ 3
74 #define STATE_UMOUNT_REQ 4
75 #define STATE_LOOKUP_REQ 5
76 #define STATE_READ_REQ 6
77 #define STATE_READLINK_REQ 7
78
79 static char *nfs_filename;
80 static char *nfs_path;
81 static char nfs_path_buff[2048];
82
83 enum nfs_version {
84 NFS_UNKOWN = 0,
85 NFS_V1 = 1,
86 NFS_V2 = 2,
87 NFS_V3 = 3,
88 };
89
90 static enum nfs_version choosen_nfs_version = NFS_V3;
91 static inline int store_block(uchar *src, unsigned offset, unsigned len)
92 {
93 ulong newsize = offset + len;
94 #ifdef CONFIG_SYS_DIRECT_FLASH_NFS
95 int i, rc = 0;
96
97 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
98 /* start address in flash? */
99 if (image_load_addr + offset >= flash_info[i].start[0]) {
100 rc = 1;
101 break;
102 }
103 }
104
105 if (rc) { /* Flash is destination for this packet */
106 rc = flash_write((uchar *)src, (ulong)image_load_addr + offset,
107 len);
108 if (rc) {
109 flash_perror(rc);
110 return -1;
111 }
112 } else
113 #endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
114 {
115 void *ptr = map_sysmem(image_load_addr + offset, len);
116
117 memcpy(ptr, src, len);
118 unmap_sysmem(ptr);
119 }
120
121 if (net_boot_file_size < (offset + len))
122 net_boot_file_size = newsize;
123 return 0;
124 }
125
126 static char *basename(char *path)
127 {
128 char *fname;
129
130 fname = path + strlen(path) - 1;
131 while (fname >= path) {
132 if (*fname == '/') {
133 fname++;
134 break;
135 }
136 fname--;
137 }
138 return fname;
139 }
140
141 static char *dirname(char *path)
142 {
143 char *fname;
144
145 fname = basename(path);
146 --fname;
147 *fname = '\0';
148 return path;
149 }
150
151 /**************************************************************************
152 RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
153 **************************************************************************/
154 static uint32_t *rpc_add_credentials(uint32_t *p)
155 {
156 /* Here's the executive summary on authentication requirements of the
157 * various NFS server implementations: Linux accepts both AUTH_NONE
158 * and AUTH_UNIX authentication (also accepts an empty hostname field
159 * in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
160 * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
161 * scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
162 * it (if the BOOTP/DHCP reply didn't give one, just use an empty
163 * hostname). */
164
165 /* Provide an AUTH_UNIX credential. */
166 *p++ = htonl(1); /* AUTH_UNIX */
167 *p++ = htonl(20); /* auth length */
168 *p++ = 0; /* stamp */
169 *p++ = 0; /* hostname string */
170 *p++ = 0; /* uid */
171 *p++ = 0; /* gid */
172 *p++ = 0; /* auxiliary gid list */
173
174 /* Provide an AUTH_NONE verifier. */
175 *p++ = 0; /* AUTH_NONE */
176 *p++ = 0; /* auth length */
177
178 return p;
179 }
180
181 /**************************************************************************
182 RPC_LOOKUP - Lookup RPC Port numbers
183 **************************************************************************/
184 static void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
185 {
186 struct rpc_t rpc_pkt;
187 unsigned long id;
188 uint32_t *p;
189 int pktlen;
190 int sport;
191
192 id = ++rpc_id;
193 rpc_pkt.u.call.id = htonl(id);
194 rpc_pkt.u.call.type = htonl(MSG_CALL);
195 rpc_pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
196 rpc_pkt.u.call.prog = htonl(rpc_prog);
197 switch (rpc_prog) {
198 case PROG_NFS:
199 switch (choosen_nfs_version) {
200 case NFS_V1:
201 case NFS_V2:
202 rpc_pkt.u.call.vers = htonl(2);
203 break;
204
205 case NFS_V3:
206 rpc_pkt.u.call.vers = htonl(3);
207 break;
208
209 case NFS_UNKOWN:
210 /* nothing to do */
211 break;
212 }
213 break;
214 case PROG_MOUNT:
215 switch (choosen_nfs_version) {
216 case NFS_V1:
217 rpc_pkt.u.call.vers = htonl(1);
218 break;
219
220 case NFS_V2:
221 rpc_pkt.u.call.vers = htonl(2);
222 break;
223
224 case NFS_V3:
225 rpc_pkt.u.call.vers = htonl(3);
226 break;
227
228 case NFS_UNKOWN:
229 /* nothing to do */
230 break;
231 }
232 break;
233 case PROG_PORTMAP:
234 default:
235 rpc_pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
236 }
237 rpc_pkt.u.call.proc = htonl(rpc_proc);
238 p = rpc_pkt.u.call.data;
239
240 if (datalen)
241 memcpy(p, data, datalen * sizeof(uint32_t));
242
243 pktlen = (char *)p + datalen * sizeof(uint32_t) - (char *)&rpc_pkt;
244
245 memcpy((char *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE,
246 &rpc_pkt.u.data[0], pktlen);
247
248 if (rpc_prog == PROG_PORTMAP)
249 sport = SUNRPC_PORT;
250 else if (rpc_prog == PROG_MOUNT)
251 sport = nfs_server_mount_port;
252 else
253 sport = nfs_server_port;
254
255 net_send_udp_packet(net_server_ethaddr, nfs_server_ip, sport,
256 nfs_our_port, pktlen);
257 }
258
259 /**************************************************************************
260 RPC_LOOKUP - Lookup RPC Port numbers
261 **************************************************************************/
262 static void rpc_lookup_req(int prog, int ver)
263 {
264 uint32_t data[16];
265
266 data[0] = 0; data[1] = 0; /* auth credential */
267 data[2] = 0; data[3] = 0; /* auth verifier */
268 data[4] = htonl(prog);
269 data[5] = htonl(ver);
270 data[6] = htonl(17); /* IP_UDP */
271 data[7] = 0;
272 rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
273 }
274
275 /**************************************************************************
276 NFS_MOUNT - Mount an NFS Filesystem
277 **************************************************************************/
278 static void nfs_mount_req(char *path)
279 {
280 uint32_t data[1024];
281 uint32_t *p;
282 int len;
283 int pathlen;
284
285 pathlen = strlen(path);
286
287 p = &(data[0]);
288 p = rpc_add_credentials(p);
289
290 *p++ = htonl(pathlen);
291 if (pathlen & 3)
292 *(p + pathlen / 4) = 0;
293 memcpy(p, path, pathlen);
294 p += (pathlen + 3) / 4;
295
296 len = (uint32_t *)p - (uint32_t *)&(data[0]);
297
298 rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len);
299 }
300
301 /**************************************************************************
302 NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
303 **************************************************************************/
304 static void nfs_umountall_req(void)
305 {
306 uint32_t data[1024];
307 uint32_t *p;
308 int len;
309
310 if ((nfs_server_mount_port == -1) || (!fs_mounted))
311 /* Nothing mounted, nothing to umount */
312 return;
313
314 p = &(data[0]);
315 p = rpc_add_credentials(p);
316
317 len = (uint32_t *)p - (uint32_t *)&(data[0]);
318
319 rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
320 }
321
322 /***************************************************************************
323 * NFS_READLINK (AH 2003-07-14)
324 * This procedure is called when read of the first block fails -
325 * this probably happens when it's a directory or a symlink
326 * In case of successful readlink(), the dirname is manipulated,
327 * so that inside the nfs() function a recursion can be done.
328 **************************************************************************/
329 static void nfs_readlink_req(void)
330 {
331 uint32_t data[1024];
332 uint32_t *p;
333 int len;
334
335 p = &(data[0]);
336 p = rpc_add_credentials(p);
337
338 if (choosen_nfs_version != NFS_V3) {
339 memcpy(p, filefh, NFS_FHSIZE);
340 p += (NFS_FHSIZE / 4);
341 } else { /* NFS_V3 */
342 *p++ = htonl(filefh3_length);
343 memcpy(p, filefh, filefh3_length);
344 p += (filefh3_length / 4);
345 }
346
347 len = (uint32_t *)p - (uint32_t *)&(data[0]);
348
349 rpc_req(PROG_NFS, NFS_READLINK, data, len);
350 }
351
352 /**************************************************************************
353 NFS_LOOKUP - Lookup Pathname
354 **************************************************************************/
355 static void nfs_lookup_req(char *fname)
356 {
357 uint32_t data[1024];
358 uint32_t *p;
359 int len;
360 int fnamelen;
361
362 fnamelen = strlen(fname);
363
364 p = &(data[0]);
365 p = rpc_add_credentials(p);
366
367 if (choosen_nfs_version != NFS_V3) {
368 memcpy(p, dirfh, NFS_FHSIZE);
369 p += (NFS_FHSIZE / 4);
370 *p++ = htonl(fnamelen);
371 if (fnamelen & 3)
372 *(p + fnamelen / 4) = 0;
373 memcpy(p, fname, fnamelen);
374 p += (fnamelen + 3) / 4;
375
376 len = (uint32_t *)p - (uint32_t *)&(data[0]);
377
378 rpc_req(PROG_NFS, NFS_LOOKUP, data, len);
379 } else { /* NFS_V3 */
380 *p++ = htonl(NFS_FHSIZE); /* Dir handle length */
381 memcpy(p, dirfh, NFS_FHSIZE);
382 p += (NFS_FHSIZE / 4);
383 *p++ = htonl(fnamelen);
384 if (fnamelen & 3)
385 *(p + fnamelen / 4) = 0;
386 memcpy(p, fname, fnamelen);
387 p += (fnamelen + 3) / 4;
388
389 len = (uint32_t *)p - (uint32_t *)&(data[0]);
390
391 rpc_req(PROG_NFS, NFS3PROC_LOOKUP, data, len);
392 }
393 }
394
395 /**************************************************************************
396 NFS_READ - Read File on NFS Server
397 **************************************************************************/
398 static void nfs_read_req(int offset, int readlen)
399 {
400 uint32_t data[1024];
401 uint32_t *p;
402 int len;
403
404 p = &(data[0]);
405 p = rpc_add_credentials(p);
406
407 if (choosen_nfs_version != NFS_V3) {
408 memcpy(p, filefh, NFS_FHSIZE);
409 p += (NFS_FHSIZE / 4);
410 *p++ = htonl(offset);
411 *p++ = htonl(readlen);
412 *p++ = 0;
413 } else { /* NFS_V3 */
414 *p++ = htonl(filefh3_length);
415 memcpy(p, filefh, filefh3_length);
416 p += (filefh3_length / 4);
417 *p++ = htonl(0); /* offset is 64-bit long, so fill with 0 */
418 *p++ = htonl(offset);
419 *p++ = htonl(readlen);
420 *p++ = 0;
421 }
422
423 len = (uint32_t *)p - (uint32_t *)&(data[0]);
424
425 rpc_req(PROG_NFS, NFS_READ, data, len);
426 }
427
428 /**************************************************************************
429 RPC request dispatcher
430 **************************************************************************/
431 static void nfs_send(void)
432 {
433 debug("%s\n", __func__);
434
435 switch (nfs_state) {
436 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
437 if (choosen_nfs_version != NFS_V3)
438 rpc_lookup_req(PROG_MOUNT, 1);
439 else /* NFS_V3 */
440 rpc_lookup_req(PROG_MOUNT, 3);
441 break;
442 case STATE_PRCLOOKUP_PROG_NFS_REQ:
443 if (choosen_nfs_version != NFS_V3)
444 rpc_lookup_req(PROG_NFS, 2);
445 else /* NFS_V3 */
446 rpc_lookup_req(PROG_NFS, 3);
447 break;
448 case STATE_MOUNT_REQ:
449 nfs_mount_req(nfs_path);
450 break;
451 case STATE_UMOUNT_REQ:
452 nfs_umountall_req();
453 break;
454 case STATE_LOOKUP_REQ:
455 nfs_lookup_req(nfs_filename);
456 break;
457 case STATE_READ_REQ:
458 nfs_read_req(nfs_offset, nfs_len);
459 break;
460 case STATE_READLINK_REQ:
461 nfs_readlink_req();
462 break;
463 }
464 }
465
466 /**************************************************************************
467 Handlers for the reply from server
468 **************************************************************************/
469
470 static int rpc_handle_error(struct rpc_t *rpc_pkt)
471 {
472 if (rpc_pkt->u.reply.rstatus ||
473 rpc_pkt->u.reply.verifier ||
474 rpc_pkt->u.reply.astatus ||
475 rpc_pkt->u.reply.data[0]) {
476 switch (ntohl(rpc_pkt->u.reply.astatus)) {
477 case NFS_RPC_SUCCESS: /* Not an error */
478 break;
479 case NFS_RPC_PROG_MISMATCH: {
480 /* Remote can't support NFS version */
481 const int min = ntohl(rpc_pkt->u.reply.data[0]);
482 const int max = ntohl(rpc_pkt->u.reply.data[1]);
483
484 if (max < NFS_V1 || max > NFS_V3 || min > NFS_V3) {
485 puts("*** ERROR: NFS version not supported");
486 debug(": Requested: V%d, accepted: min V%d - max V%d\n",
487 choosen_nfs_version,
488 ntohl(rpc_pkt->u.reply.data[0]),
489 ntohl(rpc_pkt->u.reply.data[1]));
490 puts("\n");
491 choosen_nfs_version = NFS_UNKOWN;
492 break;
493 }
494
495 debug("*** Warning: NFS version not supported: Requested: V%d, accepted: min V%d - max V%d\n",
496 choosen_nfs_version,
497 ntohl(rpc_pkt->u.reply.data[0]),
498 ntohl(rpc_pkt->u.reply.data[1]));
499 debug("Will retry with NFSv%d\n", min);
500 choosen_nfs_version = min;
501 return -NFS_RPC_PROG_MISMATCH;
502 }
503 case NFS_RPC_PROG_UNAVAIL:
504 case NFS_RPC_PROC_UNAVAIL:
505 case NFS_RPC_GARBAGE_ARGS:
506 case NFS_RPC_SYSTEM_ERR:
507 default: /* Unknown error on 'accept state' flag */
508 debug("*** ERROR: accept state error (%d)\n",
509 ntohl(rpc_pkt->u.reply.astatus));
510 break;
511 }
512 return -1;
513 }
514
515 return 0;
516 }
517
518 static int rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
519 {
520 struct rpc_t rpc_pkt;
521
522 memcpy(&rpc_pkt.u.data[0], pkt, len);
523
524 debug("%s\n", __func__);
525
526 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
527 return -NFS_RPC_ERR;
528 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
529 return -NFS_RPC_DROP;
530
531 if (rpc_pkt.u.reply.rstatus ||
532 rpc_pkt.u.reply.verifier ||
533 rpc_pkt.u.reply.astatus)
534 return -1;
535
536 switch (prog) {
537 case PROG_MOUNT:
538 nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]);
539 break;
540 case PROG_NFS:
541 nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]);
542 break;
543 }
544
545 return 0;
546 }
547
548 static int nfs_mount_reply(uchar *pkt, unsigned len)
549 {
550 struct rpc_t rpc_pkt;
551 int ret;
552
553 debug("%s\n", __func__);
554
555 memcpy(&rpc_pkt.u.data[0], pkt, len);
556
557 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
558 return -NFS_RPC_ERR;
559 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
560 return -NFS_RPC_DROP;
561
562 ret = rpc_handle_error(&rpc_pkt);
563 if (ret)
564 return ret;
565
566 fs_mounted = 1;
567 /* NFSv2 and NFSv3 use same structure */
568 memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
569
570 return 0;
571 }
572
573 static int nfs_umountall_reply(uchar *pkt, unsigned len)
574 {
575 struct rpc_t rpc_pkt;
576
577 debug("%s\n", __func__);
578
579 memcpy(&rpc_pkt.u.data[0], pkt, len);
580
581 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
582 return -NFS_RPC_ERR;
583 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
584 return -NFS_RPC_DROP;
585
586 if (rpc_pkt.u.reply.rstatus ||
587 rpc_pkt.u.reply.verifier ||
588 rpc_pkt.u.reply.astatus)
589 return -1;
590
591 fs_mounted = 0;
592 memset(dirfh, 0, sizeof(dirfh));
593
594 return 0;
595 }
596
597 static int nfs_lookup_reply(uchar *pkt, unsigned len)
598 {
599 struct rpc_t rpc_pkt;
600 int ret;
601
602 debug("%s\n", __func__);
603
604 memcpy(&rpc_pkt.u.data[0], pkt, len);
605
606 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
607 return -NFS_RPC_ERR;
608 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
609 return -NFS_RPC_DROP;
610
611 ret = rpc_handle_error(&rpc_pkt);
612 if (ret)
613 return ret;
614
615 if (choosen_nfs_version != NFS_V3) {
616 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + NFS_FHSIZE) > len)
617 return -NFS_RPC_DROP;
618 memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
619 } else { /* NFS_V3 */
620 filefh3_length = ntohl(rpc_pkt.u.reply.data[1]);
621 if (filefh3_length > NFS3_FHSIZE)
622 filefh3_length = NFS3_FHSIZE;
623 memcpy(filefh, rpc_pkt.u.reply.data + 2, filefh3_length);
624 }
625
626 return 0;
627 }
628
629 static int nfs3_get_attributes_offset(uint32_t *data)
630 {
631 if (data[1]) {
632 /* 'attributes_follow' flag is TRUE,
633 * so we have attributes on 21 dwords */
634 /* Skip unused values :
635 type; 32 bits value,
636 mode; 32 bits value,
637 nlink; 32 bits value,
638 uid; 32 bits value,
639 gid; 32 bits value,
640 size; 64 bits value,
641 used; 64 bits value,
642 rdev; 64 bits value,
643 fsid; 64 bits value,
644 fileid; 64 bits value,
645 atime; 64 bits value,
646 mtime; 64 bits value,
647 ctime; 64 bits value,
648 */
649 return 22;
650 } else {
651 /* 'attributes_follow' flag is FALSE,
652 * so we don't have any attributes */
653 return 1;
654 }
655 }
656
657 static int nfs_readlink_reply(uchar *pkt, unsigned len)
658 {
659 struct rpc_t rpc_pkt;
660 int rlen;
661 int nfsv3_data_offset = 0;
662
663 debug("%s\n", __func__);
664
665 memcpy((unsigned char *)&rpc_pkt, pkt, len);
666
667 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
668 return -NFS_RPC_ERR;
669 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
670 return -NFS_RPC_DROP;
671
672 if (rpc_pkt.u.reply.rstatus ||
673 rpc_pkt.u.reply.verifier ||
674 rpc_pkt.u.reply.astatus ||
675 rpc_pkt.u.reply.data[0])
676 return -1;
677
678 if (choosen_nfs_version == NFS_V3) {
679 nfsv3_data_offset =
680 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
681 }
682
683 /* new path length */
684 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
685
686 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
687 return -NFS_RPC_DROP;
688
689 if (*((char *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset])) != '/') {
690 int pathlen;
691
692 strcat(nfs_path, "/");
693 pathlen = strlen(nfs_path);
694 memcpy(nfs_path + pathlen,
695 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
696 rlen);
697 nfs_path[pathlen + rlen] = 0;
698 } else {
699 memcpy(nfs_path,
700 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
701 rlen);
702 nfs_path[rlen] = 0;
703 }
704 return 0;
705 }
706
707 static int nfs_read_reply(uchar *pkt, unsigned len)
708 {
709 struct rpc_t rpc_pkt;
710 int rlen;
711 uchar *data_ptr;
712
713 debug("%s\n", __func__);
714
715 memcpy(&rpc_pkt.u.data[0], pkt, sizeof(rpc_pkt.u.reply));
716
717 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
718 return -NFS_RPC_ERR;
719 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
720 return -NFS_RPC_DROP;
721
722 if (rpc_pkt.u.reply.rstatus ||
723 rpc_pkt.u.reply.verifier ||
724 rpc_pkt.u.reply.astatus ||
725 rpc_pkt.u.reply.data[0]) {
726 if (rpc_pkt.u.reply.rstatus)
727 return -9999;
728 if (rpc_pkt.u.reply.astatus)
729 return -9999;
730 return -ntohl(rpc_pkt.u.reply.data[0]);
731 }
732
733 if ((nfs_offset != 0) && !((nfs_offset) %
734 (NFS_READ_SIZE / 2 * 10 * HASHES_PER_LINE)))
735 puts("\n\t ");
736 if (!(nfs_offset % ((NFS_READ_SIZE / 2) * 10)))
737 putc('#');
738
739 if (choosen_nfs_version != NFS_V3) {
740 rlen = ntohl(rpc_pkt.u.reply.data[18]);
741 data_ptr = (uchar *)&(rpc_pkt.u.reply.data[19]);
742 } else { /* NFS_V3 */
743 int nfsv3_data_offset =
744 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
745
746 /* count value */
747 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
748 /* Skip unused values :
749 EOF: 32 bits value,
750 data_size: 32 bits value,
751 */
752 data_ptr = (uchar *)
753 &(rpc_pkt.u.reply.data[4 + nfsv3_data_offset]);
754 }
755
756 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
757 return -9999;
758
759 if (store_block(data_ptr, nfs_offset, rlen))
760 return -9999;
761
762 return rlen;
763 }
764
765 /**************************************************************************
766 Interfaces of U-BOOT
767 **************************************************************************/
768 static void nfs_timeout_handler(void)
769 {
770 if (++nfs_timeout_count > NFS_RETRY_COUNT) {
771 puts("\nRetry count exceeded; starting again\n");
772 net_start_again();
773 } else {
774 puts("T ");
775 net_set_timeout_handler(nfs_timeout +
776 nfs_timeout * nfs_timeout_count,
777 nfs_timeout_handler);
778 nfs_send();
779 }
780 }
781
782 static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip,
783 unsigned src, unsigned len)
784 {
785 int rlen;
786 int reply;
787
788 debug("%s\n", __func__);
789
790 if (len > sizeof(struct rpc_t))
791 return;
792
793 if (dest != nfs_our_port)
794 return;
795
796 switch (nfs_state) {
797 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
798 if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP)
799 break;
800 nfs_state = STATE_PRCLOOKUP_PROG_NFS_REQ;
801 nfs_send();
802 break;
803
804 case STATE_PRCLOOKUP_PROG_NFS_REQ:
805 if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
806 break;
807 nfs_state = STATE_MOUNT_REQ;
808 nfs_send();
809 break;
810
811 case STATE_MOUNT_REQ:
812 reply = nfs_mount_reply(pkt, len);
813 if (reply == -NFS_RPC_DROP) {
814 break;
815 } else if (reply == -NFS_RPC_ERR) {
816 puts("*** ERROR: Cannot mount\n");
817 /* just to be sure... */
818 nfs_state = STATE_UMOUNT_REQ;
819 nfs_send();
820 } else if (reply == -NFS_RPC_PROG_MISMATCH &&
821 choosen_nfs_version != NFS_UNKOWN) {
822 nfs_state = STATE_MOUNT_REQ;
823 nfs_send();
824 } else {
825 nfs_state = STATE_LOOKUP_REQ;
826 nfs_send();
827 }
828 break;
829
830 case STATE_UMOUNT_REQ:
831 reply = nfs_umountall_reply(pkt, len);
832 if (reply == -NFS_RPC_DROP) {
833 break;
834 } else if (reply == -NFS_RPC_ERR) {
835 debug("*** ERROR: Cannot umount\n");
836 net_set_state(NETLOOP_FAIL);
837 } else {
838 puts("\ndone\n");
839 net_set_state(nfs_download_state);
840 }
841 break;
842
843 case STATE_LOOKUP_REQ:
844 reply = nfs_lookup_reply(pkt, len);
845 if (reply == -NFS_RPC_DROP) {
846 break;
847 } else if (reply == -NFS_RPC_ERR) {
848 puts("*** ERROR: File lookup fail\n");
849 nfs_state = STATE_UMOUNT_REQ;
850 nfs_send();
851 } else if (reply == -NFS_RPC_PROG_MISMATCH &&
852 choosen_nfs_version != NFS_UNKOWN) {
853 /* umount */
854 nfs_state = STATE_UMOUNT_REQ;
855 nfs_send();
856 /* And retry with another supported version */
857 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
858 nfs_send();
859 } else {
860 nfs_state = STATE_READ_REQ;
861 nfs_offset = 0;
862 nfs_len = NFS_READ_SIZE;
863 nfs_send();
864 }
865 break;
866
867 case STATE_READLINK_REQ:
868 reply = nfs_readlink_reply(pkt, len);
869 if (reply == -NFS_RPC_DROP) {
870 break;
871 } else if (reply == -NFS_RPC_ERR) {
872 puts("*** ERROR: Symlink fail\n");
873 nfs_state = STATE_UMOUNT_REQ;
874 nfs_send();
875 } else {
876 debug("Symlink --> %s\n", nfs_path);
877 nfs_filename = basename(nfs_path);
878 nfs_path = dirname(nfs_path);
879
880 nfs_state = STATE_MOUNT_REQ;
881 nfs_send();
882 }
883 break;
884
885 case STATE_READ_REQ:
886 rlen = nfs_read_reply(pkt, len);
887 if (rlen == -NFS_RPC_DROP)
888 break;
889 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
890 if (rlen > 0) {
891 nfs_offset += rlen;
892 nfs_send();
893 } else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
894 /* symbolic link */
895 nfs_state = STATE_READLINK_REQ;
896 nfs_send();
897 } else {
898 if (!rlen)
899 nfs_download_state = NETLOOP_SUCCESS;
900 if (rlen < 0)
901 debug("NFS READ error (%d)\n", rlen);
902 nfs_state = STATE_UMOUNT_REQ;
903 nfs_send();
904 }
905 break;
906 }
907 }
908
909
910 void nfs_start(void)
911 {
912 debug("%s\n", __func__);
913 nfs_download_state = NETLOOP_FAIL;
914
915 nfs_server_ip = net_server_ip;
916 nfs_path = (char *)nfs_path_buff;
917
918 if (nfs_path == NULL) {
919 net_set_state(NETLOOP_FAIL);
920 printf("*** ERROR: Fail allocate memory\n");
921 return;
922 }
923
924 if (!net_parse_bootfile(&nfs_server_ip, nfs_path,
925 sizeof(nfs_path_buff))) {
926 sprintf(nfs_path, "/nfsroot/%02X%02X%02X%02X.img",
927 net_ip.s_addr & 0xFF,
928 (net_ip.s_addr >> 8) & 0xFF,
929 (net_ip.s_addr >> 16) & 0xFF,
930 (net_ip.s_addr >> 24) & 0xFF);
931
932 printf("*** Warning: no boot file name; using '%s'\n",
933 nfs_path);
934 }
935
936 nfs_filename = basename(nfs_path);
937 nfs_path = dirname(nfs_path);
938
939 printf("Using %s device\n", eth_get_name());
940
941 printf("File transfer via NFS from server %pI4; our IP address is %pI4",
942 &nfs_server_ip, &net_ip);
943
944 /* Check if we need to send across this subnet */
945 if (net_gateway.s_addr && net_netmask.s_addr) {
946 struct in_addr our_net;
947 struct in_addr server_net;
948
949 our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
950 server_net.s_addr = nfs_server_ip.s_addr & net_netmask.s_addr;
951 if (our_net.s_addr != server_net.s_addr)
952 printf("; sending through gateway %pI4",
953 &net_gateway);
954 }
955 printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
956
957 if (net_boot_file_expected_size_in_blocks) {
958 printf(" Size is 0x%x Bytes = ",
959 net_boot_file_expected_size_in_blocks << 9);
960 print_size(net_boot_file_expected_size_in_blocks << 9, "");
961 }
962 printf("\nLoad address: 0x%lx\nLoading: *\b", image_load_addr);
963
964 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
965 net_set_udp_handler(nfs_handler);
966
967 nfs_timeout_count = 0;
968 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
969
970 /*nfs_our_port = 4096 + (get_ticks() % 3072);*/
971 /*FIX ME !!!*/
972 nfs_our_port = 1000;
973
974 /* zero out server ether in case the server ip has changed */
975 memset(net_server_ethaddr, 0, 6);
976
977 nfs_send();
978 }
"Das U-Boot" Source Tree