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 #include <common.h>
30 #include <command.h>
31 #include <net.h>
32 #include <malloc.h>
33 #include <mapmem.h>
34 #include "nfs.h"
35 #include "bootp.h"
36 #include <time.h>
37
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
42 #else
43 # define NFS_TIMEOUT CONFIG_NFS_TIMEOUT
44 #endif
45
46 #define NFS_RPC_ERR 1
47 #define NFS_RPC_DROP 124
48
49 static int fs_mounted;
50 static unsigned long rpc_id;
51 static int nfs_offset = -1;
52 static int nfs_len;
53 static ulong nfs_timeout = NFS_TIMEOUT;
54
55 static char dirfh[NFS_FHSIZE]; /* NFSv2 / NFSv3 file handle of directory */
56 static char filefh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle */
57 static unsigned int filefh3_length; /* (variable) length of filefh when NFSv3 */
58
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;
65 static int nfs_state;
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
73
74 static char *nfs_filename;
75 static char *nfs_path;
76 static char nfs_path_buff[2048];
77
78 #define NFSV2_FLAG 1
79 #define NFSV3_FLAG 1 << 1
80 static char supported_nfs_versions = NFSV2_FLAG | NFSV3_FLAG;
81
store_block(uchar * src,unsigned offset,unsigned len)82 static inline int store_block(uchar *src, unsigned offset, unsigned len)
83 {
84 ulong newsize = offset + len;
85 #ifdef CONFIG_SYS_DIRECT_FLASH_NFS
86 int i, rc = 0;
87
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]) {
91 rc = 1;
92 break;
93 }
94 }
95
96 if (rc) { /* Flash is destination for this packet */
97 rc = flash_write((uchar *)src, (ulong)(load_addr+offset), len);
98 if (rc) {
99 flash_perror(rc);
100 return -1;
101 }
102 } else
103 #endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
104 {
105 void *ptr = map_sysmem(load_addr + offset, len);
106
107 memcpy(ptr, src, len);
108 unmap_sysmem(ptr);
109 }
110
111 if (net_boot_file_size < (offset + len))
112 net_boot_file_size = newsize;
113 return 0;
114 }
115
basename(char * path)116 static char *basename(char *path)
117 {
118 char *fname;
119
120 fname = path + strlen(path) - 1;
121 while (fname >= path) {
122 if (*fname == '/') {
123 fname++;
124 break;
125 }
126 fname--;
127 }
128 return fname;
129 }
130
dirname(char * path)131 static char *dirname(char *path)
132 {
133 char *fname;
134
135 fname = basename(path);
136 --fname;
137 *fname = '\0';
138 return path;
139 }
140
141 /**************************************************************************
142 RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
143 **************************************************************************/
rpc_add_credentials(uint32_t * p)144 static uint32_t *rpc_add_credentials(uint32_t *p)
145 {
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
153 * hostname). */
154
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 */
160 *p++ = 0; /* uid */
161 *p++ = 0; /* gid */
162 *p++ = 0; /* auxiliary gid list */
163
164 /* Provide an AUTH_NONE verifier. */
165 *p++ = 0; /* AUTH_NONE */
166 *p++ = 0; /* auth length */
167
168 return p;
169 }
170
171 /**************************************************************************
172 RPC_LOOKUP - Lookup RPC Port numbers
173 **************************************************************************/
rpc_req(int rpc_prog,int rpc_proc,uint32_t * data,int datalen)174 static void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
175 {
176 struct rpc_t rpc_pkt;
177 unsigned long id;
178 uint32_t *p;
179 int pktlen;
180 int sport;
181
182 id = ++rpc_id;
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);
187 switch (rpc_prog) {
188 case PROG_NFS:
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 */
193 break;
194 case PROG_PORTMAP:
195 case PROG_MOUNT:
196 default:
197 rpc_pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
198 }
199 rpc_pkt.u.call.proc = htonl(rpc_proc);
200 p = rpc_pkt.u.call.data;
201
202 if (datalen)
203 memcpy(p, data, datalen * sizeof(uint32_t));
204
205 pktlen = (char *)p + datalen * sizeof(uint32_t) - (char *)&rpc_pkt;
206
207 memcpy((char *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE,
208 &rpc_pkt.u.data[0], pktlen);
209
210 if (rpc_prog == PROG_PORTMAP)
211 sport = SUNRPC_PORT;
212 else if (rpc_prog == PROG_MOUNT)
213 sport = nfs_server_mount_port;
214 else
215 sport = nfs_server_port;
216
217 net_send_udp_packet(net_server_ethaddr, nfs_server_ip, sport,
218 nfs_our_port, pktlen);
219 }
220
221 /**************************************************************************
222 RPC_LOOKUP - Lookup RPC Port numbers
223 **************************************************************************/
rpc_lookup_req(int prog,int ver)224 static void rpc_lookup_req(int prog, int ver)
225 {
226 uint32_t data[16];
227
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 */
233 data[7] = 0;
234 rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
235 }
236
237 /**************************************************************************
238 NFS_MOUNT - Mount an NFS Filesystem
239 **************************************************************************/
nfs_mount_req(char * path)240 static void nfs_mount_req(char *path)
241 {
242 uint32_t data[1024];
243 uint32_t *p;
244 int len;
245 int pathlen;
246
247 pathlen = strlen(path);
248
249 p = &(data[0]);
250 p = rpc_add_credentials(p);
251
252 *p++ = htonl(pathlen);
253 if (pathlen & 3)
254 *(p + pathlen / 4) = 0;
255 memcpy(p, path, pathlen);
256 p += (pathlen + 3) / 4;
257
258 len = (uint32_t *)p - (uint32_t *)&(data[0]);
259
260 rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len);
261 }
262
263 /**************************************************************************
264 NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
265 **************************************************************************/
nfs_umountall_req(void)266 static void nfs_umountall_req(void)
267 {
268 uint32_t data[1024];
269 uint32_t *p;
270 int len;
271
272 if ((nfs_server_mount_port == -1) || (!fs_mounted))
273 /* Nothing mounted, nothing to umount */
274 return;
275
276 p = &(data[0]);
277 p = rpc_add_credentials(p);
278
279 len = (uint32_t *)p - (uint32_t *)&(data[0]);
280
281 rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
282 }
283
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 **************************************************************************/
nfs_readlink_req(void)291 static void nfs_readlink_req(void)
292 {
293 uint32_t data[1024];
294 uint32_t *p;
295 int len;
296
297 p = &(data[0]);
298 p = rpc_add_credentials(p);
299
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);
307 }
308
309 len = (uint32_t *)p - (uint32_t *)&(data[0]);
310
311 rpc_req(PROG_NFS, NFS_READLINK, data, len);
312 }
313
314 /**************************************************************************
315 NFS_LOOKUP - Lookup Pathname
316 **************************************************************************/
nfs_lookup_req(char * fname)317 static void nfs_lookup_req(char *fname)
318 {
319 uint32_t data[1024];
320 uint32_t *p;
321 int len;
322 int fnamelen;
323
324 fnamelen = strlen(fname);
325
326 p = &(data[0]);
327 p = rpc_add_credentials(p);
328
329 if (supported_nfs_versions & NFSV2_FLAG) {
330 memcpy(p, dirfh, NFS_FHSIZE);
331 p += (NFS_FHSIZE / 4);
332 *p++ = htonl(fnamelen);
333 if (fnamelen & 3)
334 *(p + fnamelen / 4) = 0;
335 memcpy(p, fname, fnamelen);
336 p += (fnamelen + 3) / 4;
337
338 len = (uint32_t *)p - (uint32_t *)&(data[0]);
339
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);
346 if (fnamelen & 3)
347 *(p + fnamelen / 4) = 0;
348 memcpy(p, fname, fnamelen);
349 p += (fnamelen + 3) / 4;
350
351 len = (uint32_t *)p - (uint32_t *)&(data[0]);
352
353 rpc_req(PROG_NFS, NFS3PROC_LOOKUP, data, len);
354 }
355 }
356
357 /**************************************************************************
358 NFS_READ - Read File on NFS Server
359 **************************************************************************/
nfs_read_req(int offset,int readlen)360 static void nfs_read_req(int offset, int readlen)
361 {
362 uint32_t data[1024];
363 uint32_t *p;
364 int len;
365
366 p = &(data[0]);
367 p = rpc_add_credentials(p);
368
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);
374 *p++ = 0;
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);
382 *p++ = 0;
383 }
384
385 len = (uint32_t *)p - (uint32_t *)&(data[0]);
386
387 rpc_req(PROG_NFS, NFS_READ, data, len);
388 }
389
390 /**************************************************************************
391 RPC request dispatcher
392 **************************************************************************/
nfs_send(void)393 static void nfs_send(void)
394 {
395 debug("%s\n", __func__);
396
397 switch (nfs_state) {
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);
403 break;
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);
409 break;
410 case STATE_MOUNT_REQ:
411 nfs_mount_req(nfs_path);
412 break;
413 case STATE_UMOUNT_REQ:
414 nfs_umountall_req();
415 break;
416 case STATE_LOOKUP_REQ:
417 nfs_lookup_req(nfs_filename);
418 break;
419 case STATE_READ_REQ:
420 nfs_read_req(nfs_offset, nfs_len);
421 break;
422 case STATE_READLINK_REQ:
423 nfs_readlink_req();
424 break;
425 }
426 }
427
428 /**************************************************************************
429 Handlers for the reply from server
430 **************************************************************************/
431
rpc_lookup_reply(int prog,uchar * pkt,unsigned len)432 static int rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
433 {
434 struct rpc_t rpc_pkt;
435
436 memcpy(&rpc_pkt.u.data[0], pkt, len);
437
438 debug("%s\n", __func__);
439
440 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
441 return -NFS_RPC_ERR;
442 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
443 return -NFS_RPC_DROP;
444
445 if (rpc_pkt.u.reply.rstatus ||
446 rpc_pkt.u.reply.verifier ||
447 rpc_pkt.u.reply.astatus)
448 return -1;
449
450 switch (prog) {
451 case PROG_MOUNT:
452 nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]);
453 break;
454 case PROG_NFS:
455 nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]);
456 break;
457 }
458
459 return 0;
460 }
461
nfs_mount_reply(uchar * pkt,unsigned len)462 static int nfs_mount_reply(uchar *pkt, unsigned len)
463 {
464 struct rpc_t rpc_pkt;
465
466 debug("%s\n", __func__);
467
468 memcpy(&rpc_pkt.u.data[0], pkt, len);
469
470 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
471 return -NFS_RPC_ERR;
472 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
473 return -NFS_RPC_DROP;
474
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])
479 return -1;
480
481 fs_mounted = 1;
482 /* NFSv2 and NFSv3 use same structure */
483 memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
484
485 return 0;
486 }
487
nfs_umountall_reply(uchar * pkt,unsigned len)488 static int nfs_umountall_reply(uchar *pkt, unsigned len)
489 {
490 struct rpc_t rpc_pkt;
491
492 debug("%s\n", __func__);
493
494 memcpy(&rpc_pkt.u.data[0], pkt, len);
495
496 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
497 return -NFS_RPC_ERR;
498 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
499 return -NFS_RPC_DROP;
500
501 if (rpc_pkt.u.reply.rstatus ||
502 rpc_pkt.u.reply.verifier ||
503 rpc_pkt.u.reply.astatus)
504 return -1;
505
506 fs_mounted = 0;
507 memset(dirfh, 0, sizeof(dirfh));
508
509 return 0;
510 }
511
nfs_lookup_reply(uchar * pkt,unsigned len)512 static int nfs_lookup_reply(uchar *pkt, unsigned len)
513 {
514 struct rpc_t rpc_pkt;
515
516 debug("%s\n", __func__);
517
518 memcpy(&rpc_pkt.u.data[0], pkt, len);
519
520 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
521 return -NFS_RPC_ERR;
522 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
523 return -NFS_RPC_DROP;
524
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 */
531 break;
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 */
536 case 3:
537 debug("*** Warning: NFS version not supported: Requested: V%d, accepted: min V%d - max V%d\n",
538 (supported_nfs_versions & NFSV2_FLAG) ?
539 2 : 3,
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;
546 case 4:
547 default:
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) ?
551 2 : 3,
552 ntohl(rpc_pkt.u.reply.data[0]),
553 ntohl(rpc_pkt.u.reply.data[1]));
554 puts("\n");
555 }
556 break;
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));
564 break;
565 }
566 return -1;
567 }
568
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 memcpy(filefh, rpc_pkt.u.reply.data + 2, filefh3_length);
578 }
579
580 return 0;
581 }
582
nfs3_get_attributes_offset(uint32_t * data)583 static int nfs3_get_attributes_offset(uint32_t *data)
584 {
585 if (data[1]) {
586 /* 'attributes_follow' flag is TRUE,
587 * so we have attributes on 21 dwords */
588 /* Skip unused values :
589 type; 32 bits value,
590 mode; 32 bits value,
591 nlink; 32 bits value,
592 uid; 32 bits value,
593 gid; 32 bits value,
594 size; 64 bits value,
595 used; 64 bits value,
596 rdev; 64 bits value,
597 fsid; 64 bits value,
598 fileid; 64 bits value,
599 atime; 64 bits value,
600 mtime; 64 bits value,
601 ctime; 64 bits value,
602 */
603 return 22;
604 } else {
605 /* 'attributes_follow' flag is FALSE,
606 * so we don't have any attributes */
607 return 1;
608 }
609 }
610
nfs_readlink_reply(uchar * pkt,unsigned len)611 static int nfs_readlink_reply(uchar *pkt, unsigned len)
612 {
613 struct rpc_t rpc_pkt;
614 int rlen;
615 int nfsv3_data_offset = 0;
616
617 debug("%s\n", __func__);
618
619 memcpy((unsigned char *)&rpc_pkt, pkt, len);
620
621 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
622 return -NFS_RPC_ERR;
623 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
624 return -NFS_RPC_DROP;
625
626 if (rpc_pkt.u.reply.rstatus ||
627 rpc_pkt.u.reply.verifier ||
628 rpc_pkt.u.reply.astatus ||
629 rpc_pkt.u.reply.data[0])
630 return -1;
631
632 if (!(supported_nfs_versions & NFSV2_FLAG)) { /* NFSV3_FLAG */
633 nfsv3_data_offset =
634 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
635 }
636
637 /* new path length */
638 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
639
640 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
641 return -NFS_RPC_DROP;
642
643 if (*((char *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset])) != '/') {
644 int pathlen;
645
646 strcat(nfs_path, "/");
647 pathlen = strlen(nfs_path);
648 memcpy(nfs_path + pathlen,
649 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
650 rlen);
651 nfs_path[pathlen + rlen] = 0;
652 } else {
653 memcpy(nfs_path,
654 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
655 rlen);
656 nfs_path[rlen] = 0;
657 }
658 return 0;
659 }
660
nfs_read_reply(uchar * pkt,unsigned len)661 static int nfs_read_reply(uchar *pkt, unsigned len)
662 {
663 struct rpc_t rpc_pkt;
664 int rlen;
665 uchar *data_ptr;
666
667 debug("%s\n", __func__);
668
669 memcpy(&rpc_pkt.u.data[0], pkt, sizeof(rpc_pkt.u.reply));
670
671 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
672 return -NFS_RPC_ERR;
673 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
674 return -NFS_RPC_DROP;
675
676 if (rpc_pkt.u.reply.rstatus ||
677 rpc_pkt.u.reply.verifier ||
678 rpc_pkt.u.reply.astatus ||
679 rpc_pkt.u.reply.data[0]) {
680 if (rpc_pkt.u.reply.rstatus)
681 return -9999;
682 if (rpc_pkt.u.reply.astatus)
683 return -9999;
684 return -ntohl(rpc_pkt.u.reply.data[0]);
685 }
686
687 if ((nfs_offset != 0) && !((nfs_offset) %
688 (NFS_READ_SIZE / 2 * 10 * HASHES_PER_LINE)))
689 puts("\n\t ");
690 if (!(nfs_offset % ((NFS_READ_SIZE / 2) * 10)))
691 putc('#');
692
693 if (supported_nfs_versions & NFSV2_FLAG) {
694 rlen = ntohl(rpc_pkt.u.reply.data[18]);
695 data_ptr = (uchar *)&(rpc_pkt.u.reply.data[19]);
696 } else { /* NFSV3_FLAG */
697 int nfsv3_data_offset =
698 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
699
700 /* count value */
701 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
702 /* Skip unused values :
703 EOF: 32 bits value,
704 data_size: 32 bits value,
705 */
706 data_ptr = (uchar *)
707 &(rpc_pkt.u.reply.data[4 + nfsv3_data_offset]);
708 }
709
710 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
711 return -9999;
712
713 if (store_block(data_ptr, nfs_offset, rlen))
714 return -9999;
715
716 return rlen;
717 }
718
719 /**************************************************************************
720 Interfaces of U-BOOT
721 **************************************************************************/
nfs_timeout_handler(void)722 static void nfs_timeout_handler(void)
723 {
724 if (++nfs_timeout_count > NFS_RETRY_COUNT) {
725 puts("\nRetry count exceeded; starting again\n");
726 net_start_again();
727 } else {
728 puts("T ");
729 net_set_timeout_handler(nfs_timeout +
730 NFS_TIMEOUT * nfs_timeout_count,
731 nfs_timeout_handler);
732 nfs_send();
733 }
734 }
735
nfs_handler(uchar * pkt,unsigned dest,struct in_addr sip,unsigned src,unsigned len)736 static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip,
737 unsigned src, unsigned len)
738 {
739 int rlen;
740 int reply;
741
742 debug("%s\n", __func__);
743
744 if (len > sizeof(struct rpc_t))
745 return;
746
747 if (dest != nfs_our_port)
748 return;
749
750 switch (nfs_state) {
751 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
752 if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP)
753 break;
754 nfs_state = STATE_PRCLOOKUP_PROG_NFS_REQ;
755 nfs_send();
756 break;
757
758 case STATE_PRCLOOKUP_PROG_NFS_REQ:
759 if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
760 break;
761 nfs_state = STATE_MOUNT_REQ;
762 nfs_send();
763 break;
764
765 case STATE_MOUNT_REQ:
766 reply = nfs_mount_reply(pkt, len);
767 if (reply == -NFS_RPC_DROP) {
768 break;
769 } else if (reply == -NFS_RPC_ERR) {
770 puts("*** ERROR: Cannot mount\n");
771 /* just to be sure... */
772 nfs_state = STATE_UMOUNT_REQ;
773 nfs_send();
774 } else {
775 nfs_state = STATE_LOOKUP_REQ;
776 nfs_send();
777 }
778 break;
779
780 case STATE_UMOUNT_REQ:
781 reply = nfs_umountall_reply(pkt, len);
782 if (reply == -NFS_RPC_DROP) {
783 break;
784 } else if (reply == -NFS_RPC_ERR) {
785 debug("*** ERROR: Cannot umount\n");
786 net_set_state(NETLOOP_FAIL);
787 } else {
788 puts("\ndone\n");
789 net_set_state(nfs_download_state);
790 }
791 break;
792
793 case STATE_LOOKUP_REQ:
794 reply = nfs_lookup_reply(pkt, len);
795 if (reply == -NFS_RPC_DROP) {
796 break;
797 } else if (reply == -NFS_RPC_ERR) {
798 puts("*** ERROR: File lookup fail\n");
799 nfs_state = STATE_UMOUNT_REQ;
800 nfs_send();
801 } else if (reply == -NFS_RPC_PROG_MISMATCH &&
802 supported_nfs_versions != 0) {
803 /* umount */
804 nfs_state = STATE_UMOUNT_REQ;
805 nfs_send();
806 /* And retry with another supported version */
807 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
808 nfs_send();
809 } else {
810 nfs_state = STATE_READ_REQ;
811 nfs_offset = 0;
812 nfs_len = NFS_READ_SIZE;
813 nfs_send();
814 }
815 break;
816
817 case STATE_READLINK_REQ:
818 reply = nfs_readlink_reply(pkt, len);
819 if (reply == -NFS_RPC_DROP) {
820 break;
821 } else if (reply == -NFS_RPC_ERR) {
822 puts("*** ERROR: Symlink fail\n");
823 nfs_state = STATE_UMOUNT_REQ;
824 nfs_send();
825 } else {
826 debug("Symlink --> %s\n", nfs_path);
827 nfs_filename = basename(nfs_path);
828 nfs_path = dirname(nfs_path);
829
830 nfs_state = STATE_MOUNT_REQ;
831 nfs_send();
832 }
833 break;
834
835 case STATE_READ_REQ:
836 rlen = nfs_read_reply(pkt, len);
837 if (rlen == -NFS_RPC_DROP)
838 break;
839 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
840 if (rlen > 0) {
841 nfs_offset += rlen;
842 nfs_send();
843 } else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
844 /* symbolic link */
845 nfs_state = STATE_READLINK_REQ;
846 nfs_send();
847 } else {
848 if (!rlen)
849 nfs_download_state = NETLOOP_SUCCESS;
850 if (rlen < 0)
851 debug("NFS READ error (%d)\n", rlen);
852 nfs_state = STATE_UMOUNT_REQ;
853 nfs_send();
854 }
855 break;
856 }
857 }
858
859
nfs_start(void)860 void nfs_start(void)
861 {
862 debug("%s\n", __func__);
863 nfs_download_state = NETLOOP_FAIL;
864
865 nfs_server_ip = net_server_ip;
866 nfs_path = (char *)nfs_path_buff;
867
868 if (nfs_path == NULL) {
869 net_set_state(NETLOOP_FAIL);
870 printf("*** ERROR: Fail allocate memory\n");
871 return;
872 }
873
874 if (!net_parse_bootfile(&nfs_server_ip, nfs_path,
875 sizeof(nfs_path_buff))) {
876 sprintf(nfs_path, "/nfsroot/%02X%02X%02X%02X.img",
877 net_ip.s_addr & 0xFF,
878 (net_ip.s_addr >> 8) & 0xFF,
879 (net_ip.s_addr >> 16) & 0xFF,
880 (net_ip.s_addr >> 24) & 0xFF);
881
882 printf("*** Warning: no boot file name; using '%s'\n",
883 nfs_path);
884 }
885
886 nfs_filename = basename(nfs_path);
887 nfs_path = dirname(nfs_path);
888
889 printf("Using %s device\n", eth_get_name());
890
891 printf("File transfer via NFS from server %pI4; our IP address is %pI4",
892 &nfs_server_ip, &net_ip);
893
894 /* Check if we need to send across this subnet */
895 if (net_gateway.s_addr && net_netmask.s_addr) {
896 struct in_addr our_net;
897 struct in_addr server_net;
898
899 our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
900 server_net.s_addr = nfs_server_ip.s_addr & net_netmask.s_addr;
901 if (our_net.s_addr != server_net.s_addr)
902 printf("; sending through gateway %pI4",
903 &net_gateway);
904 }
905 printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
906
907 if (net_boot_file_expected_size_in_blocks) {
908 printf(" Size is 0x%x Bytes = ",
909 net_boot_file_expected_size_in_blocks << 9);
910 print_size(net_boot_file_expected_size_in_blocks << 9, "");
911 }
912 printf("\nLoad address: 0x%lx\nLoading: *\b", load_addr);
913
914 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
915 net_set_udp_handler(nfs_handler);
916
917 nfs_timeout_count = 0;
918 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
919
920 /*nfs_our_port = 4096 + (get_ticks() % 3072);*/
921 /*FIX ME !!!*/
922 nfs_our_port = 1000;
923
924 /* zero out server ether in case the server ip has changed */
925 memset(net_server_ethaddr, 0, 6);
926
927 nfs_send();
928 }
929