blob: b5b482c3f3cefce41f22e8e596194f4e21b469a3 [file] [log] [blame]
wdenkcbd8a352004-02-24 02:00:03 +00001/*
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#include <common.h>
26#include <command.h>
27#include <net.h>
28#include <malloc.h>
29#include "nfs.h"
30#include "bootp.h"
31
wdenkcbd8a352004-02-24 02:00:03 +000032#define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
Hiroshi Itofe891ec2008-01-31 18:35:04 +090033#define NFS_RETRY_COUNT 30
Bartlomiej Sieka49f3bdb2008-10-01 15:26:28 +020034#define NFS_TIMEOUT 2000UL
wdenkcbd8a352004-02-24 02:00:03 +000035
36static int fs_mounted = 0;
wdenkc3f9d492004-03-14 00:59:59 +000037static unsigned long rpc_id = 0;
wdenkcbd8a352004-02-24 02:00:03 +000038static int nfs_offset = -1;
39static int nfs_len;
40
41static char dirfh[NFS_FHSIZE]; /* file handle of directory */
42static char filefh[NFS_FHSIZE]; /* file handle of kernel image */
43
Wolfgang Denk23a7a322005-08-06 01:11:12 +020044static int NfsDownloadState;
wdenkcbd8a352004-02-24 02:00:03 +000045static IPaddr_t NfsServerIP;
46static int NfsSrvMountPort;
47static int NfsSrvNfsPort;
48static int NfsOurPort;
49static int NfsTimeoutCount;
50static int NfsState;
51#define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
52#define STATE_PRCLOOKUP_PROG_NFS_REQ 2
53#define STATE_MOUNT_REQ 3
54#define STATE_UMOUNT_REQ 4
55#define STATE_LOOKUP_REQ 5
56#define STATE_READ_REQ 6
57#define STATE_READLINK_REQ 7
58
59static char default_filename[64];
60static char *nfs_filename;
61static char *nfs_path;
62static char nfs_path_buff[2048];
63
Wolfgang Denk23a7a322005-08-06 01:11:12 +020064static __inline__ int
wdenkcbd8a352004-02-24 02:00:03 +000065store_block (uchar * src, unsigned offset, unsigned len)
66{
wdenka084f7d2004-02-24 22:33:21 +000067 ulong newsize = offset + len;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020068#ifdef CONFIG_SYS_DIRECT_FLASH_NFS
wdenkcbd8a352004-02-24 02:00:03 +000069 int i, rc = 0;
70
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020071 for (i=0; i<CONFIG_SYS_MAX_FLASH_BANKS; i++) {
wdenkcbd8a352004-02-24 02:00:03 +000072 /* start address in flash? */
73 if (load_addr + offset >= flash_info[i].start[0]) {
74 rc = 1;
75 break;
76 }
77 }
78
79 if (rc) { /* Flash is destination for this packet */
80 rc = flash_write ((uchar *)src, (ulong)(load_addr+offset), len);
81 if (rc) {
82 flash_perror (rc);
Wolfgang Denk23a7a322005-08-06 01:11:12 +020083 return -1;
wdenkcbd8a352004-02-24 02:00:03 +000084 }
85 } else
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020086#endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
wdenkcbd8a352004-02-24 02:00:03 +000087 {
88 (void)memcpy ((void *)(load_addr + offset), src, len);
89 }
wdenka084f7d2004-02-24 22:33:21 +000090
91 if (NetBootFileXferSize < (offset+len))
92 NetBootFileXferSize = newsize;
Wolfgang Denk23a7a322005-08-06 01:11:12 +020093 return 0;
wdenkcbd8a352004-02-24 02:00:03 +000094}
95
96static char*
97basename (char *path)
98{
99 char *fname;
100
101 fname = path + strlen(path) - 1;
102 while (fname >= path) {
103 if (*fname == '/') {
104 fname++;
105 break;
106 }
107 fname--;
108 }
109 return fname;
110}
111
112static char*
113dirname (char *path)
114{
115 char *fname;
116
117 fname = basename (path);
118 --fname;
119 *fname = '\0';
120 return path;
121}
122
123/**************************************************************************
wdenkcbd8a352004-02-24 02:00:03 +0000124RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
125**************************************************************************/
126static long *rpc_add_credentials (long *p)
127{
128 int hl;
129 int hostnamelen;
130 char hostname[256];
131
132 strcpy (hostname, "");
133 hostnamelen=strlen (hostname);
134
135 /* Here's the executive summary on authentication requirements of the
136 * various NFS server implementations: Linux accepts both AUTH_NONE
137 * and AUTH_UNIX authentication (also accepts an empty hostname field
138 * in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
139 * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
140 * scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
141 * it (if the BOOTP/DHCP reply didn't give one, just use an empty
142 * hostname). */
143
144 hl = (hostnamelen + 3) & ~3;
145
146 /* Provide an AUTH_UNIX credential. */
147 *p++ = htonl(1); /* AUTH_UNIX */
148 *p++ = htonl(hl+20); /* auth length */
149 *p++ = htonl(0); /* stamp */
150 *p++ = htonl(hostnamelen); /* hostname string */
151 if (hostnamelen & 3) {
152 *(p + hostnamelen / 4) = 0; /* add zero padding */
153 }
154 memcpy (p, hostname, hostnamelen);
155 p += hl / 4;
156 *p++ = 0; /* uid */
157 *p++ = 0; /* gid */
158 *p++ = 0; /* auxiliary gid list */
159
160 /* Provide an AUTH_NONE verifier. */
161 *p++ = 0; /* AUTH_NONE */
162 *p++ = 0; /* auth length */
163
164 return p;
165}
166
167/**************************************************************************
168RPC_LOOKUP - Lookup RPC Port numbers
169**************************************************************************/
170static void
171rpc_req (int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
172{
173 struct rpc_t pkt;
174 unsigned long id;
175 uint32_t *p;
176 int pktlen;
177 int sport;
178
wdenkc3f9d492004-03-14 00:59:59 +0000179 id = ++rpc_id;
wdenkcbd8a352004-02-24 02:00:03 +0000180 pkt.u.call.id = htonl(id);
181 pkt.u.call.type = htonl(MSG_CALL);
182 pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
183 pkt.u.call.prog = htonl(rpc_prog);
184 pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
185 pkt.u.call.proc = htonl(rpc_proc);
186 p = (uint32_t *)&(pkt.u.call.data);
187
188 if (datalen)
189 memcpy ((char *)p, (char *)data, datalen*sizeof(uint32_t));
190
191 pktlen = (char *)p + datalen*sizeof(uint32_t) - (char *)&pkt;
192
wdenka3d991b2004-04-15 21:48:45 +0000193 memcpy ((char *)NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE, (char *)&pkt, pktlen);
wdenkcbd8a352004-02-24 02:00:03 +0000194
195 if (rpc_prog == PROG_PORTMAP)
196 sport = SUNRPC_PORT;
197 else if (rpc_prog == PROG_MOUNT)
198 sport = NfsSrvMountPort;
199 else
200 sport = NfsSrvNfsPort;
201
202 NetSendUDPPacket (NetServerEther, NfsServerIP, sport, NfsOurPort, pktlen);
203}
204
205/**************************************************************************
206RPC_LOOKUP - Lookup RPC Port numbers
207**************************************************************************/
208static void
209rpc_lookup_req (int prog, int ver)
210{
211 uint32_t data[16];
212
213 data[0] = 0; data[1] = 0; /* auth credential */
214 data[2] = 0; data[3] = 0; /* auth verifier */
215 data[4] = htonl(prog);
216 data[5] = htonl(ver);
217 data[6] = htonl(17); /* IP_UDP */
218 data[7] = 0;
219
220 rpc_req (PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
221}
222
223/**************************************************************************
224NFS_MOUNT - Mount an NFS Filesystem
225**************************************************************************/
226static void
227nfs_mount_req (char *path)
228{
229 uint32_t data[1024];
230 uint32_t *p;
231 int len;
232 int pathlen;
233
234 pathlen = strlen (path);
235
236 p = &(data[0]);
237 p = (uint32_t *)rpc_add_credentials((long *)p);
238
239 *p++ = htonl(pathlen);
240 if (pathlen & 3) *(p + pathlen / 4) = 0;
241 memcpy (p, path, pathlen);
242 p += (pathlen + 3) / 4;
243
244 len = (uint32_t *)p - (uint32_t *)&(data[0]);
245
246 rpc_req (PROG_MOUNT, MOUNT_ADDENTRY, data, len);
247}
248
249/**************************************************************************
250NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
251**************************************************************************/
252static void
253nfs_umountall_req (void)
254{
255 uint32_t data[1024];
256 uint32_t *p;
257 int len;
258
259 if ((NfsSrvMountPort == -1) || (!fs_mounted)) {
260 /* Nothing mounted, nothing to umount */
261 return;
262 }
263
264 p = &(data[0]);
265 p = (uint32_t *)rpc_add_credentials ((long *)p);
266
267 len = (uint32_t *)p - (uint32_t *)&(data[0]);
268
269 rpc_req (PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
270}
271
272/***************************************************************************
273 * NFS_READLINK (AH 2003-07-14)
274 * This procedure is called when read of the first block fails -
275 * this probably happens when it's a directory or a symlink
276 * In case of successful readlink(), the dirname is manipulated,
277 * so that inside the nfs() function a recursion can be done.
278 **************************************************************************/
279static void
280nfs_readlink_req (void)
281{
282 uint32_t data[1024];
283 uint32_t *p;
284 int len;
285
286 p = &(data[0]);
287 p = (uint32_t *)rpc_add_credentials ((long *)p);
288
289 memcpy (p, filefh, NFS_FHSIZE);
290 p += (NFS_FHSIZE / 4);
291
292 len = (uint32_t *)p - (uint32_t *)&(data[0]);
293
294 rpc_req (PROG_NFS, NFS_READLINK, data, len);
295}
296
297/**************************************************************************
298NFS_LOOKUP - Lookup Pathname
299**************************************************************************/
300static void
301nfs_lookup_req (char *fname)
302{
303 uint32_t data[1024];
304 uint32_t *p;
305 int len;
306 int fnamelen;
307
308 fnamelen = strlen (fname);
309
310 p = &(data[0]);
311 p = (uint32_t *)rpc_add_credentials ((long *)p);
312
313 memcpy (p, dirfh, NFS_FHSIZE);
314 p += (NFS_FHSIZE / 4);
315 *p++ = htonl(fnamelen);
316 if (fnamelen & 3) *(p + fnamelen / 4) = 0;
317 memcpy (p, fname, fnamelen);
318 p += (fnamelen + 3) / 4;
319
320 len = (uint32_t *)p - (uint32_t *)&(data[0]);
321
322 rpc_req (PROG_NFS, NFS_LOOKUP, data, len);
323}
324
325/**************************************************************************
326NFS_READ - Read File on NFS Server
327**************************************************************************/
328static void
329nfs_read_req (int offset, int readlen)
330{
331 uint32_t data[1024];
332 uint32_t *p;
333 int len;
334
335 p = &(data[0]);
336 p = (uint32_t *)rpc_add_credentials ((long *)p);
337
338 memcpy (p, filefh, NFS_FHSIZE);
339 p += (NFS_FHSIZE / 4);
340 *p++ = htonl(offset);
341 *p++ = htonl(readlen);
342 *p++ = 0;
343
344 len = (uint32_t *)p - (uint32_t *)&(data[0]);
345
346 rpc_req (PROG_NFS, NFS_READ, data, len);
347}
348
349/**************************************************************************
350RPC request dispatcher
351**************************************************************************/
352
353static void
354NfsSend (void)
355{
Robin Getz0ebf04c2009-07-23 03:01:03 -0400356 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000357
358 switch (NfsState) {
359 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
360 rpc_lookup_req (PROG_MOUNT, 1);
361 break;
362 case STATE_PRCLOOKUP_PROG_NFS_REQ:
363 rpc_lookup_req (PROG_NFS, 2);
364 break;
365 case STATE_MOUNT_REQ:
366 nfs_mount_req (nfs_path);
367 break;
368 case STATE_UMOUNT_REQ:
369 nfs_umountall_req ();
370 break;
371 case STATE_LOOKUP_REQ:
372 nfs_lookup_req (nfs_filename);
373 break;
374 case STATE_READ_REQ:
375 nfs_read_req (nfs_offset, nfs_len);
376 break;
377 case STATE_READLINK_REQ:
378 nfs_readlink_req ();
379 break;
380 }
381}
382
383/**************************************************************************
384Handlers for the reply from server
385**************************************************************************/
386
387static int
388rpc_lookup_reply (int prog, uchar *pkt, unsigned len)
389{
390 struct rpc_t rpc_pkt;
391
392 memcpy ((unsigned char *)&rpc_pkt, pkt, len);
393
Robin Getz0ebf04c2009-07-23 03:01:03 -0400394 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000395
wdenkc3f9d492004-03-14 00:59:59 +0000396 if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
397 return -1;
398
wdenkcbd8a352004-02-24 02:00:03 +0000399 if (rpc_pkt.u.reply.rstatus ||
400 rpc_pkt.u.reply.verifier ||
wdenkcbd8a352004-02-24 02:00:03 +0000401 rpc_pkt.u.reply.astatus) {
wdenkc3f9d492004-03-14 00:59:59 +0000402 return -1;
wdenkcbd8a352004-02-24 02:00:03 +0000403 }
404
405 switch (prog) {
406 case PROG_MOUNT:
407 NfsSrvMountPort = ntohl(rpc_pkt.u.reply.data[0]);
408 break;
409 case PROG_NFS:
410 NfsSrvNfsPort = ntohl(rpc_pkt.u.reply.data[0]);
411 break;
412 }
413
414 return 0;
415}
416
417static int
418nfs_mount_reply (uchar *pkt, unsigned len)
419{
420 struct rpc_t rpc_pkt;
421
Robin Getz0ebf04c2009-07-23 03:01:03 -0400422 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000423
424 memcpy ((unsigned char *)&rpc_pkt, pkt, len);
425
wdenkc3f9d492004-03-14 00:59:59 +0000426 if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
427 return -1;
428
wdenkcbd8a352004-02-24 02:00:03 +0000429 if (rpc_pkt.u.reply.rstatus ||
430 rpc_pkt.u.reply.verifier ||
431 rpc_pkt.u.reply.astatus ||
432 rpc_pkt.u.reply.data[0]) {
433 return -1;
434 }
435
436 fs_mounted = 1;
437 memcpy (dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
438
439 return 0;
440}
441
442static int
443nfs_umountall_reply (uchar *pkt, unsigned len)
444{
445 struct rpc_t rpc_pkt;
446
Robin Getz0ebf04c2009-07-23 03:01:03 -0400447 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000448
449 memcpy ((unsigned char *)&rpc_pkt, pkt, len);
450
wdenkc3f9d492004-03-14 00:59:59 +0000451 if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
452 return -1;
453
wdenkcbd8a352004-02-24 02:00:03 +0000454 if (rpc_pkt.u.reply.rstatus ||
455 rpc_pkt.u.reply.verifier ||
456 rpc_pkt.u.reply.astatus) {
457 return -1;
458 }
459
460 fs_mounted = 0;
461 memset (dirfh, 0, sizeof(dirfh));
462
463 return 0;
464}
465
466static int
467nfs_lookup_reply (uchar *pkt, unsigned len)
468{
469 struct rpc_t rpc_pkt;
470
Robin Getz0ebf04c2009-07-23 03:01:03 -0400471 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000472
473 memcpy ((unsigned char *)&rpc_pkt, pkt, len);
474
wdenkc3f9d492004-03-14 00:59:59 +0000475 if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
476 return -1;
477
wdenkcbd8a352004-02-24 02:00:03 +0000478 if (rpc_pkt.u.reply.rstatus ||
479 rpc_pkt.u.reply.verifier ||
480 rpc_pkt.u.reply.astatus ||
481 rpc_pkt.u.reply.data[0]) {
482 return -1;
483 }
484
485 memcpy (filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
486
487 return 0;
488}
489
490static int
491nfs_readlink_reply (uchar *pkt, unsigned len)
492{
493 struct rpc_t rpc_pkt;
494 int rlen;
495
Robin Getz0ebf04c2009-07-23 03:01:03 -0400496 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000497
498 memcpy ((unsigned char *)&rpc_pkt, pkt, len);
499
wdenkc3f9d492004-03-14 00:59:59 +0000500 if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
501 return -1;
502
wdenkcbd8a352004-02-24 02:00:03 +0000503 if (rpc_pkt.u.reply.rstatus ||
504 rpc_pkt.u.reply.verifier ||
505 rpc_pkt.u.reply.astatus ||
506 rpc_pkt.u.reply.data[0]) {
507 return -1;
508 }
509
510 rlen = ntohl (rpc_pkt.u.reply.data[1]); /* new path length */
511
512 if (*((char *)&(rpc_pkt.u.reply.data[2])) != '/') {
513 int pathlen;
514 strcat (nfs_path, "/");
515 pathlen = strlen(nfs_path);
516 memcpy (nfs_path+pathlen, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen);
Ed Swarthoutf64ef9b2009-11-19 02:47:28 -0600517 nfs_path[pathlen + rlen] = 0;
wdenkcbd8a352004-02-24 02:00:03 +0000518 } else {
519 memcpy (nfs_path, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen);
520 nfs_path[rlen] = 0;
521 }
522 return 0;
523}
524
525static int
526nfs_read_reply (uchar *pkt, unsigned len)
527{
528 struct rpc_t rpc_pkt;
529 int rlen;
530
Robin Getz0ebf04c2009-07-23 03:01:03 -0400531 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000532
wdenk11dadd52004-02-27 00:07:27 +0000533 memcpy ((uchar *)&rpc_pkt, pkt, sizeof(rpc_pkt.u.reply));
wdenkcbd8a352004-02-24 02:00:03 +0000534
wdenkc3f9d492004-03-14 00:59:59 +0000535 if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
536 return -1;
537
wdenkcbd8a352004-02-24 02:00:03 +0000538 if (rpc_pkt.u.reply.rstatus ||
539 rpc_pkt.u.reply.verifier ||
540 rpc_pkt.u.reply.astatus ||
541 rpc_pkt.u.reply.data[0]) {
542 if (rpc_pkt.u.reply.rstatus) {
543 return -9999;
544 }
545 if (rpc_pkt.u.reply.astatus) {
546 return -9999;
547 }
548 return -ntohl(rpc_pkt.u.reply.data[0]);;
549 }
550
551 if ((nfs_offset!=0) && !((nfs_offset) % (NFS_READ_SIZE/2*10*HASHES_PER_LINE))) {
552 puts ("\n\t ");
553 }
554 if (!(nfs_offset % ((NFS_READ_SIZE/2)*10))) {
555 putc ('#');
556 }
557
558 rlen = ntohl(rpc_pkt.u.reply.data[18]);
Wolfgang Denk23a7a322005-08-06 01:11:12 +0200559 if ( store_block ((uchar *)pkt+sizeof(rpc_pkt.u.reply), nfs_offset, rlen) )
560 return -9999;
wdenkcbd8a352004-02-24 02:00:03 +0000561
562 return rlen;
563}
564
565/**************************************************************************
566Interfaces of U-BOOT
567**************************************************************************/
568
569static void
wdenka5725fa2004-09-28 21:51:42 +0000570NfsTimeout (void)
571{
Evan Samanasaabb8cb2009-11-09 20:08:36 -0600572 if ( ++NfsTimeoutCount > NFS_RETRY_COUNT ) {
573 puts ("\nRetry count exceeded; starting again\n");
574 NetStartAgain ();
575 } else {
576 puts("T ");
577 NetSetTimeout (NFS_TIMEOUT, NfsTimeout);
Hiroshi Itofe891ec2008-01-31 18:35:04 +0900578 NfsSend ();
Hiroshi Itofe891ec2008-01-31 18:35:04 +0900579 }
wdenka5725fa2004-09-28 21:51:42 +0000580}
581
582static void
Luca Ceresoli03eb1292011-04-18 06:19:50 +0000583NfsHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +0000584{
585 int rlen;
586
Robin Getz0ebf04c2009-07-23 03:01:03 -0400587 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000588
589 if (dest != NfsOurPort) return;
590
591 switch (NfsState) {
592 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
593 rpc_lookup_reply (PROG_MOUNT, pkt, len);
594 NfsState = STATE_PRCLOOKUP_PROG_NFS_REQ;
595 NfsSend ();
596 break;
597
598 case STATE_PRCLOOKUP_PROG_NFS_REQ:
599 rpc_lookup_reply (PROG_NFS, pkt, len);
600 NfsState = STATE_MOUNT_REQ;
601 NfsSend ();
602 break;
603
604 case STATE_MOUNT_REQ:
605 if (nfs_mount_reply(pkt, len)) {
606 puts ("*** ERROR: Cannot mount\n");
607 /* just to be sure... */
608 NfsState = STATE_UMOUNT_REQ;
609 NfsSend ();
610 } else {
611 NfsState = STATE_LOOKUP_REQ;
612 NfsSend ();
613 }
614 break;
615
616 case STATE_UMOUNT_REQ:
617 if (nfs_umountall_reply(pkt, len)) {
618 puts ("*** ERROR: Cannot umount\n");
619 NetState = NETLOOP_FAIL;
620 } else {
wdenka084f7d2004-02-24 22:33:21 +0000621 puts ("\ndone\n");
Wolfgang Denk23a7a322005-08-06 01:11:12 +0200622 NetState = NfsDownloadState;
wdenkcbd8a352004-02-24 02:00:03 +0000623 }
624 break;
625
626 case STATE_LOOKUP_REQ:
627 if (nfs_lookup_reply(pkt, len)) {
628 puts ("*** ERROR: File lookup fail\n");
629 NfsState = STATE_UMOUNT_REQ;
630 NfsSend ();
631 } else {
632 NfsState = STATE_READ_REQ;
633 nfs_offset = 0;
634 nfs_len = NFS_READ_SIZE;
635 NfsSend ();
636 }
637 break;
638
639 case STATE_READLINK_REQ:
640 if (nfs_readlink_reply(pkt, len)) {
641 puts ("*** ERROR: Symlink fail\n");
642 NfsState = STATE_UMOUNT_REQ;
643 NfsSend ();
644 } else {
Robin Getz0ebf04c2009-07-23 03:01:03 -0400645 debug("Symlink --> %s\n", nfs_path);
wdenkcbd8a352004-02-24 02:00:03 +0000646 nfs_filename = basename (nfs_path);
647 nfs_path = dirname (nfs_path);
648
649 NfsState = STATE_MOUNT_REQ;
650 NfsSend ();
651 }
652 break;
653
654 case STATE_READ_REQ:
655 rlen = nfs_read_reply (pkt, len);
Bartlomiej Sieka49f3bdb2008-10-01 15:26:28 +0200656 NetSetTimeout (NFS_TIMEOUT, NfsTimeout);
wdenkcbd8a352004-02-24 02:00:03 +0000657 if (rlen > 0) {
658 nfs_offset += rlen;
659 NfsSend ();
660 }
661 else if ((rlen == -NFSERR_ISDIR)||(rlen == -NFSERR_INVAL)) {
662 /* symbolic link */
663 NfsState = STATE_READLINK_REQ;
664 NfsSend ();
665 } else {
Wolfgang Denk23a7a322005-08-06 01:11:12 +0200666 if ( ! rlen ) NfsDownloadState = NETLOOP_SUCCESS;
wdenkcbd8a352004-02-24 02:00:03 +0000667 NfsState = STATE_UMOUNT_REQ;
668 NfsSend ();
669 }
670 break;
671 }
672}
673
wdenkcbd8a352004-02-24 02:00:03 +0000674
675void
676NfsStart (void)
677{
Robin Getz0ebf04c2009-07-23 03:01:03 -0400678 debug("%s\n", __func__);
Wolfgang Denk23a7a322005-08-06 01:11:12 +0200679 NfsDownloadState = NETLOOP_FAIL;
wdenkcbd8a352004-02-24 02:00:03 +0000680
681 NfsServerIP = NetServerIP;
682 nfs_path = (char *)nfs_path_buff;
683
684 if (nfs_path == NULL) {
685 NetState = NETLOOP_FAIL;
686 puts ("*** ERROR: Fail allocate memory\n");
687 return;
688 }
689
690 if (BootFile[0] == '\0') {
Matthias Weisserea45cb02011-12-03 03:29:44 +0000691 sprintf(default_filename, "/nfsroot/%02X%02X%02X%02X.img",
Wolfgang Denkc43352c2005-08-04 01:09:44 +0200692 NetOurIP & 0xFF,
693 (NetOurIP >> 8) & 0xFF,
694 (NetOurIP >> 16) & 0xFF,
695 (NetOurIP >> 24) & 0xFF );
wdenkcbd8a352004-02-24 02:00:03 +0000696 strcpy (nfs_path, default_filename);
697
698 printf ("*** Warning: no boot file name; using '%s'\n",
699 nfs_path);
700 } else {
701 char *p=BootFile;
702
703 p = strchr (p, ':');
704
705 if (p != NULL) {
706 NfsServerIP = string_to_ip (BootFile);
707 ++p;
708 strcpy (nfs_path, p);
709 } else {
710 strcpy (nfs_path, BootFile);
711 }
712 }
713
714 nfs_filename = basename (nfs_path);
715 nfs_path = dirname (nfs_path);
716
wdenkcbd8a352004-02-24 02:00:03 +0000717 printf ("Using %s device\n", eth_get_name());
wdenkcbd8a352004-02-24 02:00:03 +0000718
Mike Frysingerb6446b62009-02-17 00:00:53 -0500719 printf("File transfer via NFS from server %pI4"
720 "; our IP address is %pI4", &NfsServerIP, &NetOurIP);
wdenkcbd8a352004-02-24 02:00:03 +0000721
722 /* Check if we need to send across this subnet */
723 if (NetOurGatewayIP && NetOurSubnetMask) {
724 IPaddr_t OurNet = NetOurIP & NetOurSubnetMask;
725 IPaddr_t ServerNet = NetServerIP & NetOurSubnetMask;
726
Mike Frysingerb6446b62009-02-17 00:00:53 -0500727 if (OurNet != ServerNet)
728 printf("; sending through gateway %pI4", &NetOurGatewayIP);
wdenkcbd8a352004-02-24 02:00:03 +0000729 }
wdenk4b9206e2004-03-23 22:14:11 +0000730 printf ("\nFilename '%s/%s'.", nfs_path, nfs_filename);
wdenkcbd8a352004-02-24 02:00:03 +0000731
732 if (NetBootFileSize) {
733 printf (" Size is 0x%x Bytes = ", NetBootFileSize<<9);
734 print_size (NetBootFileSize<<9, "");
735 }
wdenk4b9206e2004-03-23 22:14:11 +0000736 printf ("\nLoad address: 0x%lx\n"
737 "Loading: *\b", load_addr);
wdenkcbd8a352004-02-24 02:00:03 +0000738
Bartlomiej Sieka49f3bdb2008-10-01 15:26:28 +0200739 NetSetTimeout (NFS_TIMEOUT, NfsTimeout);
wdenkcbd8a352004-02-24 02:00:03 +0000740 NetSetHandler (NfsHandler);
741
wdenkcbd8a352004-02-24 02:00:03 +0000742 NfsTimeoutCount = 0;
743 NfsState = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
744
745 /*NfsOurPort = 4096 + (get_ticks() % 3072);*/
746 /*FIX ME !!!*/
747 NfsOurPort = 1000;
748
749 /* zero out server ether in case the server ip has changed */
750 memset (NetServerEther, 0, 6);
751
752 NfsSend ();
753}