2 * NFS support driver - based on etherboot and U-BOOT's tftp.c
4 * Masami Komiya <mkomiya@sonare.it> 2004
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. */
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. */
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. */
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. */
38 #define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
39 #define NFS_RETRY_COUNT 30
40 #ifndef CONFIG_NFS_TIMEOUT
41 # define NFS_TIMEOUT 2000UL
43 # define NFS_TIMEOUT CONFIG_NFS_TIMEOUT
47 #define NFS_RPC_DROP 124
49 static int fs_mounted;
50 static unsigned long rpc_id;
51 static int nfs_offset = -1;
53 static ulong nfs_timeout = NFS_TIMEOUT;
55 static char dirfh[NFS_FHSIZE]; /* NFSv2 / NFSv3 file handle of directory */
56 static char filefh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle */
57 static int filefh3_length; /* (variable) length of filefh when NFSv3 */
59 static enum net_loop_state nfs_download_state;
60 static struct in_addr nfs_server_ip;
61 static int nfs_server_mount_port;
62 static int nfs_server_port;
63 static int nfs_our_port;
64 static int nfs_timeout_count;
66 #define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
67 #define STATE_PRCLOOKUP_PROG_NFS_REQ 2
68 #define STATE_MOUNT_REQ 3
69 #define STATE_UMOUNT_REQ 4
70 #define STATE_LOOKUP_REQ 5
71 #define STATE_READ_REQ 6
72 #define STATE_READLINK_REQ 7
74 static char *nfs_filename;
75 static char *nfs_path;
76 static char nfs_path_buff[2048];
79 #define NFSV3_FLAG 1 << 1
80 static char supported_nfs_versions = NFSV2_FLAG | NFSV3_FLAG;
82 static inline int store_block(uchar *src, unsigned offset, unsigned len)
84 ulong newsize = offset + len;
85 #ifdef CONFIG_SYS_DIRECT_FLASH_NFS
88 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
89 /* start address in flash? */
90 if (load_addr + offset >= flash_info[i].start[0]) {
96 if (rc) { /* Flash is destination for this packet */
97 rc = flash_write((uchar *)src, (ulong)(load_addr+offset), len);
103 #endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
105 void *ptr = map_sysmem(load_addr + offset, len);
107 memcpy(ptr, src, len);
111 if (net_boot_file_size < (offset + len))
112 net_boot_file_size = newsize;
116 static char *basename(char *path)
120 fname = path + strlen(path) - 1;
121 while (fname >= path) {
131 static char *dirname(char *path)
135 fname = basename(path);
141 /**************************************************************************
142 RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
143 **************************************************************************/
144 static uint32_t *rpc_add_credentials(uint32_t *p)
146 /* Here's the executive summary on authentication requirements of the
147 * various NFS server implementations: Linux accepts both AUTH_NONE
148 * and AUTH_UNIX authentication (also accepts an empty hostname field
149 * in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
150 * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
151 * scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
152 * it (if the BOOTP/DHCP reply didn't give one, just use an empty
155 /* Provide an AUTH_UNIX credential. */
156 *p++ = htonl(1); /* AUTH_UNIX */
157 *p++ = htonl(20); /* auth length */
158 *p++ = 0; /* stamp */
159 *p++ = 0; /* hostname string */
162 *p++ = 0; /* auxiliary gid list */
164 /* Provide an AUTH_NONE verifier. */
165 *p++ = 0; /* AUTH_NONE */
166 *p++ = 0; /* auth length */
171 /**************************************************************************
172 RPC_LOOKUP - Lookup RPC Port numbers
173 **************************************************************************/
174 static void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
176 struct rpc_t rpc_pkt;
183 rpc_pkt.u.call.id = htonl(id);
184 rpc_pkt.u.call.type = htonl(MSG_CALL);
185 rpc_pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
186 rpc_pkt.u.call.prog = htonl(rpc_prog);
189 if (supported_nfs_versions & NFSV2_FLAG)
190 rpc_pkt.u.call.vers = htonl(2); /* NFS v2 */
191 else /* NFSV3_FLAG */
192 rpc_pkt.u.call.vers = htonl(3); /* NFS v3 */
197 rpc_pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
199 rpc_pkt.u.call.proc = htonl(rpc_proc);
200 p = rpc_pkt.u.call.data;
203 memcpy(p, data, datalen * sizeof(uint32_t));
205 pktlen = (char *)p + datalen * sizeof(uint32_t) - (char *)&rpc_pkt;
207 memcpy((char *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE,
208 &rpc_pkt.u.data[0], pktlen);
210 if (rpc_prog == PROG_PORTMAP)
212 else if (rpc_prog == PROG_MOUNT)
213 sport = nfs_server_mount_port;
215 sport = nfs_server_port;
217 net_send_udp_packet(net_server_ethaddr, nfs_server_ip, sport,
218 nfs_our_port, pktlen);
221 /**************************************************************************
222 RPC_LOOKUP - Lookup RPC Port numbers
223 **************************************************************************/
224 static void rpc_lookup_req(int prog, int ver)
228 data[0] = 0; data[1] = 0; /* auth credential */
229 data[2] = 0; data[3] = 0; /* auth verifier */
230 data[4] = htonl(prog);
231 data[5] = htonl(ver);
232 data[6] = htonl(17); /* IP_UDP */
234 rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
237 /**************************************************************************
238 NFS_MOUNT - Mount an NFS Filesystem
239 **************************************************************************/
240 static void nfs_mount_req(char *path)
247 pathlen = strlen(path);
250 p = rpc_add_credentials(p);
252 *p++ = htonl(pathlen);
254 *(p + pathlen / 4) = 0;
255 memcpy(p, path, pathlen);
256 p += (pathlen + 3) / 4;
258 len = (uint32_t *)p - (uint32_t *)&(data[0]);
260 rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len);
263 /**************************************************************************
264 NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
265 **************************************************************************/
266 static void nfs_umountall_req(void)
272 if ((nfs_server_mount_port == -1) || (!fs_mounted))
273 /* Nothing mounted, nothing to umount */
277 p = rpc_add_credentials(p);
279 len = (uint32_t *)p - (uint32_t *)&(data[0]);
281 rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
284 /***************************************************************************
285 * NFS_READLINK (AH 2003-07-14)
286 * This procedure is called when read of the first block fails -
287 * this probably happens when it's a directory or a symlink
288 * In case of successful readlink(), the dirname is manipulated,
289 * so that inside the nfs() function a recursion can be done.
290 **************************************************************************/
291 static void nfs_readlink_req(void)
298 p = rpc_add_credentials(p);
300 if (supported_nfs_versions & NFSV2_FLAG) {
301 memcpy(p, filefh, NFS_FHSIZE);
302 p += (NFS_FHSIZE / 4);
303 } else { /* NFSV3_FLAG */
304 *p++ = htonl(filefh3_length);
305 memcpy(p, filefh, filefh3_length);
306 p += (filefh3_length / 4);
309 len = (uint32_t *)p - (uint32_t *)&(data[0]);
311 rpc_req(PROG_NFS, NFS_READLINK, data, len);
314 /**************************************************************************
315 NFS_LOOKUP - Lookup Pathname
316 **************************************************************************/
317 static void nfs_lookup_req(char *fname)
324 fnamelen = strlen(fname);
327 p = rpc_add_credentials(p);
329 if (supported_nfs_versions & NFSV2_FLAG) {
330 memcpy(p, dirfh, NFS_FHSIZE);
331 p += (NFS_FHSIZE / 4);
332 *p++ = htonl(fnamelen);
334 *(p + fnamelen / 4) = 0;
335 memcpy(p, fname, fnamelen);
336 p += (fnamelen + 3) / 4;
338 len = (uint32_t *)p - (uint32_t *)&(data[0]);
340 rpc_req(PROG_NFS, NFS_LOOKUP, data, len);
341 } else { /* NFSV3_FLAG */
342 *p++ = htonl(NFS_FHSIZE); /* Dir handle length */
343 memcpy(p, dirfh, NFS_FHSIZE);
344 p += (NFS_FHSIZE / 4);
345 *p++ = htonl(fnamelen);
347 *(p + fnamelen / 4) = 0;
348 memcpy(p, fname, fnamelen);
349 p += (fnamelen + 3) / 4;
351 len = (uint32_t *)p - (uint32_t *)&(data[0]);
353 rpc_req(PROG_NFS, NFS3PROC_LOOKUP, data, len);
357 /**************************************************************************
358 NFS_READ - Read File on NFS Server
359 **************************************************************************/
360 static void nfs_read_req(int offset, int readlen)
367 p = rpc_add_credentials(p);
369 if (supported_nfs_versions & NFSV2_FLAG) {
370 memcpy(p, filefh, NFS_FHSIZE);
371 p += (NFS_FHSIZE / 4);
372 *p++ = htonl(offset);
373 *p++ = htonl(readlen);
375 } else { /* NFSV3_FLAG */
376 *p++ = htonl(filefh3_length);
377 memcpy(p, filefh, filefh3_length);
378 p += (filefh3_length / 4);
379 *p++ = htonl(0); /* offset is 64-bit long, so fill with 0 */
380 *p++ = htonl(offset);
381 *p++ = htonl(readlen);
385 len = (uint32_t *)p - (uint32_t *)&(data[0]);
387 rpc_req(PROG_NFS, NFS_READ, data, len);
390 /**************************************************************************
391 RPC request dispatcher
392 **************************************************************************/
393 static void nfs_send(void)
395 debug("%s\n", __func__);
398 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
399 if (supported_nfs_versions & NFSV2_FLAG)
400 rpc_lookup_req(PROG_MOUNT, 1);
401 else /* NFSV3_FLAG */
402 rpc_lookup_req(PROG_MOUNT, 3);
404 case STATE_PRCLOOKUP_PROG_NFS_REQ:
405 if (supported_nfs_versions & NFSV2_FLAG)
406 rpc_lookup_req(PROG_NFS, 2);
407 else /* NFSV3_FLAG */
408 rpc_lookup_req(PROG_NFS, 3);
410 case STATE_MOUNT_REQ:
411 nfs_mount_req(nfs_path);
413 case STATE_UMOUNT_REQ:
416 case STATE_LOOKUP_REQ:
417 nfs_lookup_req(nfs_filename);
420 nfs_read_req(nfs_offset, nfs_len);
422 case STATE_READLINK_REQ:
428 /**************************************************************************
429 Handlers for the reply from server
430 **************************************************************************/
432 static int rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
434 struct rpc_t rpc_pkt;
436 memcpy(&rpc_pkt.u.data[0], pkt, len);
438 debug("%s\n", __func__);
440 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
442 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
443 return -NFS_RPC_DROP;
445 if (rpc_pkt.u.reply.rstatus ||
446 rpc_pkt.u.reply.verifier ||
447 rpc_pkt.u.reply.astatus)
452 nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]);
455 nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]);
462 static int nfs_mount_reply(uchar *pkt, unsigned len)
464 struct rpc_t rpc_pkt;
466 debug("%s\n", __func__);
468 memcpy(&rpc_pkt.u.data[0], pkt, len);
470 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
472 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
473 return -NFS_RPC_DROP;
475 if (rpc_pkt.u.reply.rstatus ||
476 rpc_pkt.u.reply.verifier ||
477 rpc_pkt.u.reply.astatus ||
478 rpc_pkt.u.reply.data[0])
482 /* NFSv2 and NFSv3 use same structure */
483 memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
488 static int nfs_umountall_reply(uchar *pkt, unsigned len)
490 struct rpc_t rpc_pkt;
492 debug("%s\n", __func__);
494 memcpy(&rpc_pkt.u.data[0], pkt, len);
496 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
498 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
499 return -NFS_RPC_DROP;
501 if (rpc_pkt.u.reply.rstatus ||
502 rpc_pkt.u.reply.verifier ||
503 rpc_pkt.u.reply.astatus)
507 memset(dirfh, 0, sizeof(dirfh));
512 static int nfs_lookup_reply(uchar *pkt, unsigned len)
514 struct rpc_t rpc_pkt;
516 debug("%s\n", __func__);
518 memcpy(&rpc_pkt.u.data[0], pkt, len);
520 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
522 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
523 return -NFS_RPC_DROP;
525 if (rpc_pkt.u.reply.rstatus ||
526 rpc_pkt.u.reply.verifier ||
527 rpc_pkt.u.reply.astatus ||
528 rpc_pkt.u.reply.data[0]) {
529 switch (ntohl(rpc_pkt.u.reply.astatus)) {
530 case NFS_RPC_SUCCESS: /* Not an error */
532 case NFS_RPC_PROG_MISMATCH:
533 /* Remote can't support NFS version */
534 switch (ntohl(rpc_pkt.u.reply.data[0])) {
535 /* Minimal supported NFS version */
537 debug("*** Warning: NFS version not supported: Requested: V%d, accepted: min V%d - max V%d\n",
538 (supported_nfs_versions & NFSV2_FLAG) ?
540 ntohl(rpc_pkt.u.reply.data[0]),
541 ntohl(rpc_pkt.u.reply.data[1]));
542 debug("Will retry with NFSv3\n");
543 /* Clear NFSV2_FLAG from supported versions */
544 supported_nfs_versions &= ~NFSV2_FLAG;
545 return -NFS_RPC_PROG_MISMATCH;
548 puts("*** ERROR: NFS version not supported");
549 debug(": Requested: V%d, accepted: min V%d - max V%d\n",
550 (supported_nfs_versions & NFSV2_FLAG) ?
552 ntohl(rpc_pkt.u.reply.data[0]),
553 ntohl(rpc_pkt.u.reply.data[1]));
557 case NFS_RPC_PROG_UNAVAIL:
558 case NFS_RPC_PROC_UNAVAIL:
559 case NFS_RPC_GARBAGE_ARGS:
560 case NFS_RPC_SYSTEM_ERR:
561 default: /* Unknown error on 'accept state' flag */
562 debug("*** ERROR: accept state error (%d)\n",
563 ntohl(rpc_pkt.u.reply.astatus));
569 if (supported_nfs_versions & NFSV2_FLAG) {
570 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + NFS_FHSIZE) > len)
571 return -NFS_RPC_DROP;
572 memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
573 } else { /* NFSV3_FLAG */
574 filefh3_length = ntohl(rpc_pkt.u.reply.data[1]);
575 if (filefh3_length > NFS3_FHSIZE)
576 filefh3_length = NFS3_FHSIZE;
577 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + filefh3_length) > len)
578 return -NFS_RPC_DROP;
579 memcpy(filefh, rpc_pkt.u.reply.data + 2, filefh3_length);
585 static int nfs3_get_attributes_offset(uint32_t *data)
588 /* 'attributes_follow' flag is TRUE,
589 * so we have attributes on 21 dwords */
590 /* Skip unused values :
593 nlink; 32 bits value,
600 fileid; 64 bits value,
601 atime; 64 bits value,
602 mtime; 64 bits value,
603 ctime; 64 bits value,
607 /* 'attributes_follow' flag is FALSE,
608 * so we don't have any attributes */
613 static int nfs_readlink_reply(uchar *pkt, unsigned len)
615 struct rpc_t rpc_pkt;
617 int nfsv3_data_offset = 0;
619 debug("%s\n", __func__);
621 memcpy((unsigned char *)&rpc_pkt, pkt, len);
623 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
625 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
626 return -NFS_RPC_DROP;
628 if (rpc_pkt.u.reply.rstatus ||
629 rpc_pkt.u.reply.verifier ||
630 rpc_pkt.u.reply.astatus ||
631 rpc_pkt.u.reply.data[0])
634 if (!(supported_nfs_versions & NFSV2_FLAG)) { /* NFSV3_FLAG */
636 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
639 /* new path length */
640 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
642 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
643 return -NFS_RPC_DROP;
645 if (*((char *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset])) != '/') {
648 strcat(nfs_path, "/");
649 pathlen = strlen(nfs_path);
650 memcpy(nfs_path + pathlen,
651 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
653 nfs_path[pathlen + rlen] = 0;
656 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
663 static int nfs_read_reply(uchar *pkt, unsigned len)
665 struct rpc_t rpc_pkt;
669 debug("%s\n", __func__);
671 memcpy(&rpc_pkt.u.data[0], pkt, sizeof(rpc_pkt.u.reply));
673 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
675 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
676 return -NFS_RPC_DROP;
678 if (rpc_pkt.u.reply.rstatus ||
679 rpc_pkt.u.reply.verifier ||
680 rpc_pkt.u.reply.astatus ||
681 rpc_pkt.u.reply.data[0]) {
682 if (rpc_pkt.u.reply.rstatus)
684 if (rpc_pkt.u.reply.astatus)
686 return -ntohl(rpc_pkt.u.reply.data[0]);
689 if ((nfs_offset != 0) && !((nfs_offset) %
690 (NFS_READ_SIZE / 2 * 10 * HASHES_PER_LINE)))
692 if (!(nfs_offset % ((NFS_READ_SIZE / 2) * 10)))
695 if (supported_nfs_versions & NFSV2_FLAG) {
696 rlen = ntohl(rpc_pkt.u.reply.data[18]);
697 data_ptr = (uchar *)&(rpc_pkt.u.reply.data[19]);
698 } else { /* NFSV3_FLAG */
699 int nfsv3_data_offset =
700 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
703 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
704 /* Skip unused values :
706 data_size: 32 bits value,
709 &(rpc_pkt.u.reply.data[4 + nfsv3_data_offset]);
712 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
715 if (store_block(data_ptr, nfs_offset, rlen))
721 /**************************************************************************
723 **************************************************************************/
724 static void nfs_timeout_handler(void)
726 if (++nfs_timeout_count > NFS_RETRY_COUNT) {
727 puts("\nRetry count exceeded; starting again\n");
731 net_set_timeout_handler(nfs_timeout +
732 NFS_TIMEOUT * nfs_timeout_count,
733 nfs_timeout_handler);
738 static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip,
739 unsigned src, unsigned len)
744 debug("%s\n", __func__);
746 if (len > sizeof(struct rpc_t))
749 if (dest != nfs_our_port)
753 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
754 if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP)
756 nfs_state = STATE_PRCLOOKUP_PROG_NFS_REQ;
760 case STATE_PRCLOOKUP_PROG_NFS_REQ:
761 if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
763 nfs_state = STATE_MOUNT_REQ;
767 case STATE_MOUNT_REQ:
768 reply = nfs_mount_reply(pkt, len);
769 if (reply == -NFS_RPC_DROP) {
771 } else if (reply == -NFS_RPC_ERR) {
772 puts("*** ERROR: Cannot mount\n");
773 /* just to be sure... */
774 nfs_state = STATE_UMOUNT_REQ;
777 nfs_state = STATE_LOOKUP_REQ;
782 case STATE_UMOUNT_REQ:
783 reply = nfs_umountall_reply(pkt, len);
784 if (reply == -NFS_RPC_DROP) {
786 } else if (reply == -NFS_RPC_ERR) {
787 debug("*** ERROR: Cannot umount\n");
788 net_set_state(NETLOOP_FAIL);
791 net_set_state(nfs_download_state);
795 case STATE_LOOKUP_REQ:
796 reply = nfs_lookup_reply(pkt, len);
797 if (reply == -NFS_RPC_DROP) {
799 } else if (reply == -NFS_RPC_ERR) {
800 puts("*** ERROR: File lookup fail\n");
801 nfs_state = STATE_UMOUNT_REQ;
803 } else if (reply == -NFS_RPC_PROG_MISMATCH &&
804 supported_nfs_versions != 0) {
806 nfs_state = STATE_UMOUNT_REQ;
808 /* And retry with another supported version */
809 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
812 nfs_state = STATE_READ_REQ;
814 nfs_len = NFS_READ_SIZE;
819 case STATE_READLINK_REQ:
820 reply = nfs_readlink_reply(pkt, len);
821 if (reply == -NFS_RPC_DROP) {
823 } else if (reply == -NFS_RPC_ERR) {
824 puts("*** ERROR: Symlink fail\n");
825 nfs_state = STATE_UMOUNT_REQ;
828 debug("Symlink --> %s\n", nfs_path);
829 nfs_filename = basename(nfs_path);
830 nfs_path = dirname(nfs_path);
832 nfs_state = STATE_MOUNT_REQ;
838 rlen = nfs_read_reply(pkt, len);
839 if (rlen == -NFS_RPC_DROP)
841 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
845 } else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
847 nfs_state = STATE_READLINK_REQ;
851 nfs_download_state = NETLOOP_SUCCESS;
853 debug("NFS READ error (%d)\n", rlen);
854 nfs_state = STATE_UMOUNT_REQ;
864 debug("%s\n", __func__);
865 nfs_download_state = NETLOOP_FAIL;
867 nfs_server_ip = net_server_ip;
868 nfs_path = (char *)nfs_path_buff;
870 if (nfs_path == NULL) {
871 net_set_state(NETLOOP_FAIL);
872 printf("*** ERROR: Fail allocate memory\n");
876 if (!net_parse_bootfile(&nfs_server_ip, nfs_path,
877 sizeof(nfs_path_buff))) {
878 sprintf(nfs_path, "/nfsroot/%02X%02X%02X%02X.img",
879 net_ip.s_addr & 0xFF,
880 (net_ip.s_addr >> 8) & 0xFF,
881 (net_ip.s_addr >> 16) & 0xFF,
882 (net_ip.s_addr >> 24) & 0xFF);
884 printf("*** Warning: no boot file name; using '%s'\n",
888 nfs_filename = basename(nfs_path);
889 nfs_path = dirname(nfs_path);
891 printf("Using %s device\n", eth_get_name());
893 printf("File transfer via NFS from server %pI4; our IP address is %pI4",
894 &nfs_server_ip, &net_ip);
896 /* Check if we need to send across this subnet */
897 if (net_gateway.s_addr && net_netmask.s_addr) {
898 struct in_addr our_net;
899 struct in_addr server_net;
901 our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
902 server_net.s_addr = nfs_server_ip.s_addr & net_netmask.s_addr;
903 if (our_net.s_addr != server_net.s_addr)
904 printf("; sending through gateway %pI4",
907 printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
909 if (net_boot_file_expected_size_in_blocks) {
910 printf(" Size is 0x%x Bytes = ",
911 net_boot_file_expected_size_in_blocks << 9);
912 print_size(net_boot_file_expected_size_in_blocks << 9, "");
914 printf("\nLoad address: 0x%lx\nLoading: *\b", load_addr);
916 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
917 net_set_udp_handler(nfs_handler);
919 nfs_timeout_count = 0;
920 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
922 /*nfs_our_port = 4096 + (get_ticks() % 3072);*/
926 /* zero out server ether in case the server ip has changed */
927 memset(net_server_ethaddr, 0, 6);