nfs.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787
  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. /* NOTE: the NFS code is heavily inspired by the NetBSD netboot code (read:
  8. * large portions are copied verbatim) as distributed in OSKit 0.97. A few
  9. * changes were necessary to adapt the code to Etherboot and to fix several
  10. * inconsistencies. Also the RPC message preparation is done "by hand" to
  11. * avoid adding netsprintf() which I find hard to understand and use. */
  12. /* NOTE 2: Etherboot does not care about things beyond the kernel image, so
  13. * it loads the kernel image off the boot server (ARP_SERVER) and does not
  14. * access the client root disk (root-path in dhcpd.conf), which would use
  15. * ARP_ROOTSERVER. The root disk is something the operating system we are
  16. * about to load needs to use. This is different from the OSKit 0.97 logic. */
  17. /* NOTE 3: Symlink handling introduced by Anselm M Hoffmeister, 2003-July-14
  18. * If a symlink is encountered, it is followed as far as possible (recursion
  19. * possible, maximum 16 steps). There is no clearing of ".."'s inside the
  20. * path, so please DON'T DO THAT. thx. */
  21. #include <common.h>
  22. #include <command.h>
  23. #include <net.h>
  24. #include <malloc.h>
  25. #include "nfs.h"
  26. #include "bootp.h"
  27. #define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
  28. #define NFS_RETRY_COUNT 30
  29. #ifndef CONFIG_NFS_TIMEOUT
  30. # define NFS_TIMEOUT 2000UL
  31. #else
  32. # define NFS_TIMEOUT CONFIG_NFS_TIMEOUT
  33. #endif
  34. #define NFS_RPC_ERR 1
  35. #define NFS_RPC_DROP 124
  36. static int fs_mounted;
  37. static unsigned long rpc_id;
  38. static int nfs_offset = -1;
  39. static int nfs_len;
  40. static ulong nfs_timeout = NFS_TIMEOUT;
  41. static char dirfh[NFS_FHSIZE]; /* file handle of directory */
  42. static char filefh[NFS_FHSIZE]; /* file handle of kernel image */
  43. static enum net_loop_state nfs_download_state;
  44. static IPaddr_t NfsServerIP;
  45. static int NfsSrvMountPort;
  46. static int NfsSrvNfsPort;
  47. static int NfsOurPort;
  48. static int NfsTimeoutCount;
  49. static int NfsState;
  50. #define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
  51. #define STATE_PRCLOOKUP_PROG_NFS_REQ 2
  52. #define STATE_MOUNT_REQ 3
  53. #define STATE_UMOUNT_REQ 4
  54. #define STATE_LOOKUP_REQ 5
  55. #define STATE_READ_REQ 6
  56. #define STATE_READLINK_REQ 7
  57. static char default_filename[64];
  58. static char *nfs_filename;
  59. static char *nfs_path;
  60. static char nfs_path_buff[2048];
  61. static inline int
  62. store_block(uchar *src, unsigned offset, unsigned len)
  63. {
  64. ulong newsize = offset + len;
  65. #ifdef CONFIG_SYS_DIRECT_FLASH_NFS
  66. int i, rc = 0;
  67. for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
  68. /* start address in flash? */
  69. if (load_addr + offset >= flash_info[i].start[0]) {
  70. rc = 1;
  71. break;
  72. }
  73. }
  74. if (rc) { /* Flash is destination for this packet */
  75. rc = flash_write((uchar *)src, (ulong)(load_addr+offset), len);
  76. if (rc) {
  77. flash_perror(rc);
  78. return -1;
  79. }
  80. } else
  81. #endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
  82. {
  83. (void)memcpy((void *)(load_addr + offset), src, len);
  84. }
  85. if (NetBootFileXferSize < (offset+len))
  86. NetBootFileXferSize = newsize;
  87. return 0;
  88. }
  89. static char*
  90. basename(char *path)
  91. {
  92. char *fname;
  93. fname = path + strlen(path) - 1;
  94. while (fname >= path) {
  95. if (*fname == '/') {
  96. fname++;
  97. break;
  98. }
  99. fname--;
  100. }
  101. return fname;
  102. }
  103. static char*
  104. dirname(char *path)
  105. {
  106. char *fname;
  107. fname = basename(path);
  108. --fname;
  109. *fname = '\0';
  110. return path;
  111. }
  112. /**************************************************************************
  113. RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
  114. **************************************************************************/
  115. static long *rpc_add_credentials(long *p)
  116. {
  117. int hl;
  118. int hostnamelen;
  119. char hostname[256];
  120. strcpy(hostname, "");
  121. hostnamelen = strlen(hostname);
  122. /* Here's the executive summary on authentication requirements of the
  123. * various NFS server implementations: Linux accepts both AUTH_NONE
  124. * and AUTH_UNIX authentication (also accepts an empty hostname field
  125. * in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
  126. * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
  127. * scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
  128. * it (if the BOOTP/DHCP reply didn't give one, just use an empty
  129. * hostname). */
  130. hl = (hostnamelen + 3) & ~3;
  131. /* Provide an AUTH_UNIX credential. */
  132. *p++ = htonl(1); /* AUTH_UNIX */
  133. *p++ = htonl(hl+20); /* auth length */
  134. *p++ = htonl(0); /* stamp */
  135. *p++ = htonl(hostnamelen); /* hostname string */
  136. if (hostnamelen & 3)
  137. *(p + hostnamelen / 4) = 0; /* add zero padding */
  138. memcpy(p, hostname, hostnamelen);
  139. p += hl / 4;
  140. *p++ = 0; /* uid */
  141. *p++ = 0; /* gid */
  142. *p++ = 0; /* auxiliary gid list */
  143. /* Provide an AUTH_NONE verifier. */
  144. *p++ = 0; /* AUTH_NONE */
  145. *p++ = 0; /* auth length */
  146. return p;
  147. }
  148. /**************************************************************************
  149. RPC_LOOKUP - Lookup RPC Port numbers
  150. **************************************************************************/
  151. static void
  152. rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
  153. {
  154. struct rpc_t pkt;
  155. unsigned long id;
  156. uint32_t *p;
  157. int pktlen;
  158. int sport;
  159. id = ++rpc_id;
  160. pkt.u.call.id = htonl(id);
  161. pkt.u.call.type = htonl(MSG_CALL);
  162. pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
  163. pkt.u.call.prog = htonl(rpc_prog);
  164. pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
  165. pkt.u.call.proc = htonl(rpc_proc);
  166. p = (uint32_t *)&(pkt.u.call.data);
  167. if (datalen)
  168. memcpy((char *)p, (char *)data, datalen*sizeof(uint32_t));
  169. pktlen = (char *)p + datalen*sizeof(uint32_t) - (char *)&pkt;
  170. memcpy((char *)NetTxPacket + NetEthHdrSize() + IP_UDP_HDR_SIZE,
  171. (char *)&pkt, pktlen);
  172. if (rpc_prog == PROG_PORTMAP)
  173. sport = SUNRPC_PORT;
  174. else if (rpc_prog == PROG_MOUNT)
  175. sport = NfsSrvMountPort;
  176. else
  177. sport = NfsSrvNfsPort;
  178. NetSendUDPPacket(NetServerEther, NfsServerIP, sport, NfsOurPort,
  179. pktlen);
  180. }
  181. /**************************************************************************
  182. RPC_LOOKUP - Lookup RPC Port numbers
  183. **************************************************************************/
  184. static void
  185. rpc_lookup_req(int prog, int ver)
  186. {
  187. uint32_t data[16];
  188. data[0] = 0; data[1] = 0; /* auth credential */
  189. data[2] = 0; data[3] = 0; /* auth verifier */
  190. data[4] = htonl(prog);
  191. data[5] = htonl(ver);
  192. data[6] = htonl(17); /* IP_UDP */
  193. data[7] = 0;
  194. rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
  195. }
  196. /**************************************************************************
  197. NFS_MOUNT - Mount an NFS Filesystem
  198. **************************************************************************/
  199. static void
  200. nfs_mount_req(char *path)
  201. {
  202. uint32_t data[1024];
  203. uint32_t *p;
  204. int len;
  205. int pathlen;
  206. pathlen = strlen(path);
  207. p = &(data[0]);
  208. p = (uint32_t *)rpc_add_credentials((long *)p);
  209. *p++ = htonl(pathlen);
  210. if (pathlen & 3)
  211. *(p + pathlen / 4) = 0;
  212. memcpy(p, path, pathlen);
  213. p += (pathlen + 3) / 4;
  214. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  215. rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len);
  216. }
  217. /**************************************************************************
  218. NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
  219. **************************************************************************/
  220. static void
  221. nfs_umountall_req(void)
  222. {
  223. uint32_t data[1024];
  224. uint32_t *p;
  225. int len;
  226. if ((NfsSrvMountPort == -1) || (!fs_mounted))
  227. /* Nothing mounted, nothing to umount */
  228. return;
  229. p = &(data[0]);
  230. p = (uint32_t *)rpc_add_credentials((long *)p);
  231. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  232. rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
  233. }
  234. /***************************************************************************
  235. * NFS_READLINK (AH 2003-07-14)
  236. * This procedure is called when read of the first block fails -
  237. * this probably happens when it's a directory or a symlink
  238. * In case of successful readlink(), the dirname is manipulated,
  239. * so that inside the nfs() function a recursion can be done.
  240. **************************************************************************/
  241. static void
  242. nfs_readlink_req(void)
  243. {
  244. uint32_t data[1024];
  245. uint32_t *p;
  246. int len;
  247. p = &(data[0]);
  248. p = (uint32_t *)rpc_add_credentials((long *)p);
  249. memcpy(p, filefh, NFS_FHSIZE);
  250. p += (NFS_FHSIZE / 4);
  251. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  252. rpc_req(PROG_NFS, NFS_READLINK, data, len);
  253. }
  254. /**************************************************************************
  255. NFS_LOOKUP - Lookup Pathname
  256. **************************************************************************/
  257. static void
  258. nfs_lookup_req(char *fname)
  259. {
  260. uint32_t data[1024];
  261. uint32_t *p;
  262. int len;
  263. int fnamelen;
  264. fnamelen = strlen(fname);
  265. p = &(data[0]);
  266. p = (uint32_t *)rpc_add_credentials((long *)p);
  267. memcpy(p, dirfh, NFS_FHSIZE);
  268. p += (NFS_FHSIZE / 4);
  269. *p++ = htonl(fnamelen);
  270. if (fnamelen & 3)
  271. *(p + fnamelen / 4) = 0;
  272. memcpy(p, fname, fnamelen);
  273. p += (fnamelen + 3) / 4;
  274. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  275. rpc_req(PROG_NFS, NFS_LOOKUP, data, len);
  276. }
  277. /**************************************************************************
  278. NFS_READ - Read File on NFS Server
  279. **************************************************************************/
  280. static void
  281. nfs_read_req(int offset, int readlen)
  282. {
  283. uint32_t data[1024];
  284. uint32_t *p;
  285. int len;
  286. p = &(data[0]);
  287. p = (uint32_t *)rpc_add_credentials((long *)p);
  288. memcpy(p, filefh, NFS_FHSIZE);
  289. p += (NFS_FHSIZE / 4);
  290. *p++ = htonl(offset);
  291. *p++ = htonl(readlen);
  292. *p++ = 0;
  293. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  294. rpc_req(PROG_NFS, NFS_READ, data, len);
  295. }
  296. /**************************************************************************
  297. RPC request dispatcher
  298. **************************************************************************/
  299. static void
  300. NfsSend(void)
  301. {
  302. debug("%s\n", __func__);
  303. switch (NfsState) {
  304. case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
  305. rpc_lookup_req(PROG_MOUNT, 1);
  306. break;
  307. case STATE_PRCLOOKUP_PROG_NFS_REQ:
  308. rpc_lookup_req(PROG_NFS, 2);
  309. break;
  310. case STATE_MOUNT_REQ:
  311. nfs_mount_req(nfs_path);
  312. break;
  313. case STATE_UMOUNT_REQ:
  314. nfs_umountall_req();
  315. break;
  316. case STATE_LOOKUP_REQ:
  317. nfs_lookup_req(nfs_filename);
  318. break;
  319. case STATE_READ_REQ:
  320. nfs_read_req(nfs_offset, nfs_len);
  321. break;
  322. case STATE_READLINK_REQ:
  323. nfs_readlink_req();
  324. break;
  325. }
  326. }
  327. /**************************************************************************
  328. Handlers for the reply from server
  329. **************************************************************************/
  330. static int
  331. rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
  332. {
  333. struct rpc_t rpc_pkt;
  334. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  335. debug("%s\n", __func__);
  336. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  337. return -NFS_RPC_ERR;
  338. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  339. return -NFS_RPC_DROP;
  340. if (rpc_pkt.u.reply.rstatus ||
  341. rpc_pkt.u.reply.verifier ||
  342. rpc_pkt.u.reply.astatus)
  343. return -1;
  344. switch (prog) {
  345. case PROG_MOUNT:
  346. NfsSrvMountPort = ntohl(rpc_pkt.u.reply.data[0]);
  347. break;
  348. case PROG_NFS:
  349. NfsSrvNfsPort = ntohl(rpc_pkt.u.reply.data[0]);
  350. break;
  351. }
  352. return 0;
  353. }
  354. static int
  355. nfs_mount_reply(uchar *pkt, unsigned len)
  356. {
  357. struct rpc_t rpc_pkt;
  358. debug("%s\n", __func__);
  359. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  360. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  361. return -NFS_RPC_ERR;
  362. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  363. return -NFS_RPC_DROP;
  364. if (rpc_pkt.u.reply.rstatus ||
  365. rpc_pkt.u.reply.verifier ||
  366. rpc_pkt.u.reply.astatus ||
  367. rpc_pkt.u.reply.data[0])
  368. return -1;
  369. fs_mounted = 1;
  370. memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
  371. return 0;
  372. }
  373. static int
  374. nfs_umountall_reply(uchar *pkt, unsigned len)
  375. {
  376. struct rpc_t rpc_pkt;
  377. debug("%s\n", __func__);
  378. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  379. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  380. return -NFS_RPC_ERR;
  381. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  382. return -NFS_RPC_DROP;
  383. if (rpc_pkt.u.reply.rstatus ||
  384. rpc_pkt.u.reply.verifier ||
  385. rpc_pkt.u.reply.astatus)
  386. return -1;
  387. fs_mounted = 0;
  388. memset(dirfh, 0, sizeof(dirfh));
  389. return 0;
  390. }
  391. static int
  392. nfs_lookup_reply(uchar *pkt, unsigned len)
  393. {
  394. struct rpc_t rpc_pkt;
  395. debug("%s\n", __func__);
  396. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  397. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  398. return -NFS_RPC_ERR;
  399. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  400. return -NFS_RPC_DROP;
  401. if (rpc_pkt.u.reply.rstatus ||
  402. rpc_pkt.u.reply.verifier ||
  403. rpc_pkt.u.reply.astatus ||
  404. rpc_pkt.u.reply.data[0])
  405. return -1;
  406. memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
  407. return 0;
  408. }
  409. static int
  410. nfs_readlink_reply(uchar *pkt, unsigned len)
  411. {
  412. struct rpc_t rpc_pkt;
  413. int rlen;
  414. debug("%s\n", __func__);
  415. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  416. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  417. return -NFS_RPC_ERR;
  418. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  419. return -NFS_RPC_DROP;
  420. if (rpc_pkt.u.reply.rstatus ||
  421. rpc_pkt.u.reply.verifier ||
  422. rpc_pkt.u.reply.astatus ||
  423. rpc_pkt.u.reply.data[0])
  424. return -1;
  425. rlen = ntohl(rpc_pkt.u.reply.data[1]); /* new path length */
  426. if (*((char *)&(rpc_pkt.u.reply.data[2])) != '/') {
  427. int pathlen;
  428. strcat(nfs_path, "/");
  429. pathlen = strlen(nfs_path);
  430. memcpy(nfs_path + pathlen, (uchar *)&(rpc_pkt.u.reply.data[2]),
  431. rlen);
  432. nfs_path[pathlen + rlen] = 0;
  433. } else {
  434. memcpy(nfs_path, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen);
  435. nfs_path[rlen] = 0;
  436. }
  437. return 0;
  438. }
  439. static int
  440. nfs_read_reply(uchar *pkt, unsigned len)
  441. {
  442. struct rpc_t rpc_pkt;
  443. int rlen;
  444. debug("%s\n", __func__);
  445. memcpy((uchar *)&rpc_pkt, pkt, sizeof(rpc_pkt.u.reply));
  446. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  447. return -NFS_RPC_ERR;
  448. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  449. return -NFS_RPC_DROP;
  450. if (rpc_pkt.u.reply.rstatus ||
  451. rpc_pkt.u.reply.verifier ||
  452. rpc_pkt.u.reply.astatus ||
  453. rpc_pkt.u.reply.data[0]) {
  454. if (rpc_pkt.u.reply.rstatus)
  455. return -9999;
  456. if (rpc_pkt.u.reply.astatus)
  457. return -9999;
  458. return -ntohl(rpc_pkt.u.reply.data[0]);
  459. }
  460. if ((nfs_offset != 0) && !((nfs_offset) %
  461. (NFS_READ_SIZE / 2 * 10 * HASHES_PER_LINE)))
  462. puts("\n\t ");
  463. if (!(nfs_offset % ((NFS_READ_SIZE / 2) * 10)))
  464. putc('#');
  465. rlen = ntohl(rpc_pkt.u.reply.data[18]);
  466. if (store_block((uchar *)pkt + sizeof(rpc_pkt.u.reply),
  467. nfs_offset, rlen))
  468. return -9999;
  469. return rlen;
  470. }
  471. /**************************************************************************
  472. Interfaces of U-BOOT
  473. **************************************************************************/
  474. static void
  475. NfsTimeout(void)
  476. {
  477. if (++NfsTimeoutCount > NFS_RETRY_COUNT) {
  478. puts("\nRetry count exceeded; starting again\n");
  479. NetStartAgain();
  480. } else {
  481. puts("T ");
  482. NetSetTimeout(nfs_timeout + NFS_TIMEOUT * NfsTimeoutCount,
  483. NfsTimeout);
  484. NfsSend();
  485. }
  486. }
  487. static void
  488. NfsHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src, unsigned len)
  489. {
  490. int rlen;
  491. int reply;
  492. debug("%s\n", __func__);
  493. if (dest != NfsOurPort)
  494. return;
  495. switch (NfsState) {
  496. case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
  497. if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP)
  498. break;
  499. NfsState = STATE_PRCLOOKUP_PROG_NFS_REQ;
  500. NfsSend();
  501. break;
  502. case STATE_PRCLOOKUP_PROG_NFS_REQ:
  503. if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
  504. break;
  505. NfsState = STATE_MOUNT_REQ;
  506. NfsSend();
  507. break;
  508. case STATE_MOUNT_REQ:
  509. reply = nfs_mount_reply(pkt, len);
  510. if (reply == -NFS_RPC_DROP)
  511. break;
  512. else if (reply == -NFS_RPC_ERR) {
  513. puts("*** ERROR: Cannot mount\n");
  514. /* just to be sure... */
  515. NfsState = STATE_UMOUNT_REQ;
  516. NfsSend();
  517. } else {
  518. NfsState = STATE_LOOKUP_REQ;
  519. NfsSend();
  520. }
  521. break;
  522. case STATE_UMOUNT_REQ:
  523. reply = nfs_umountall_reply(pkt, len);
  524. if (reply == -NFS_RPC_DROP)
  525. break;
  526. else if (reply == -NFS_RPC_ERR) {
  527. puts("*** ERROR: Cannot umount\n");
  528. net_set_state(NETLOOP_FAIL);
  529. } else {
  530. puts("\ndone\n");
  531. net_set_state(nfs_download_state);
  532. }
  533. break;
  534. case STATE_LOOKUP_REQ:
  535. reply = nfs_lookup_reply(pkt, len);
  536. if (reply == -NFS_RPC_DROP)
  537. break;
  538. else if (reply == -NFS_RPC_ERR) {
  539. puts("*** ERROR: File lookup fail\n");
  540. NfsState = STATE_UMOUNT_REQ;
  541. NfsSend();
  542. } else {
  543. NfsState = STATE_READ_REQ;
  544. nfs_offset = 0;
  545. nfs_len = NFS_READ_SIZE;
  546. NfsSend();
  547. }
  548. break;
  549. case STATE_READLINK_REQ:
  550. reply = nfs_readlink_reply(pkt, len);
  551. if (reply == -NFS_RPC_DROP)
  552. break;
  553. else if (reply == -NFS_RPC_ERR) {
  554. puts("*** ERROR: Symlink fail\n");
  555. NfsState = STATE_UMOUNT_REQ;
  556. NfsSend();
  557. } else {
  558. debug("Symlink --> %s\n", nfs_path);
  559. nfs_filename = basename(nfs_path);
  560. nfs_path = dirname(nfs_path);
  561. NfsState = STATE_MOUNT_REQ;
  562. NfsSend();
  563. }
  564. break;
  565. case STATE_READ_REQ:
  566. rlen = nfs_read_reply(pkt, len);
  567. NetSetTimeout(nfs_timeout, NfsTimeout);
  568. if (rlen > 0) {
  569. nfs_offset += rlen;
  570. NfsSend();
  571. } else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
  572. /* symbolic link */
  573. NfsState = STATE_READLINK_REQ;
  574. NfsSend();
  575. } else {
  576. if (!rlen)
  577. nfs_download_state = NETLOOP_SUCCESS;
  578. NfsState = STATE_UMOUNT_REQ;
  579. NfsSend();
  580. }
  581. break;
  582. }
  583. }
  584. void
  585. NfsStart(void)
  586. {
  587. debug("%s\n", __func__);
  588. nfs_download_state = NETLOOP_FAIL;
  589. NfsServerIP = NetServerIP;
  590. nfs_path = (char *)nfs_path_buff;
  591. if (nfs_path == NULL) {
  592. net_set_state(NETLOOP_FAIL);
  593. puts("*** ERROR: Fail allocate memory\n");
  594. return;
  595. }
  596. if (BootFile[0] == '\0') {
  597. sprintf(default_filename, "/nfsroot/%02X%02X%02X%02X.img",
  598. NetOurIP & 0xFF,
  599. (NetOurIP >> 8) & 0xFF,
  600. (NetOurIP >> 16) & 0xFF,
  601. (NetOurIP >> 24) & 0xFF);
  602. strcpy(nfs_path, default_filename);
  603. printf("*** Warning: no boot file name; using '%s'\n",
  604. nfs_path);
  605. } else {
  606. char *p = BootFile;
  607. p = strchr(p, ':');
  608. if (p != NULL) {
  609. NfsServerIP = string_to_ip(BootFile);
  610. ++p;
  611. strcpy(nfs_path, p);
  612. } else {
  613. strcpy(nfs_path, BootFile);
  614. }
  615. }
  616. nfs_filename = basename(nfs_path);
  617. nfs_path = dirname(nfs_path);
  618. printf("Using %s device\n", eth_get_name());
  619. printf("File transfer via NFS from server %pI4"
  620. "; our IP address is %pI4", &NfsServerIP, &NetOurIP);
  621. /* Check if we need to send across this subnet */
  622. if (NetOurGatewayIP && NetOurSubnetMask) {
  623. IPaddr_t OurNet = NetOurIP & NetOurSubnetMask;
  624. IPaddr_t ServerNet = NetServerIP & NetOurSubnetMask;
  625. if (OurNet != ServerNet)
  626. printf("; sending through gateway %pI4",
  627. &NetOurGatewayIP);
  628. }
  629. printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
  630. if (NetBootFileSize) {
  631. printf(" Size is 0x%x Bytes = ", NetBootFileSize<<9);
  632. print_size(NetBootFileSize<<9, "");
  633. }
  634. printf("\nLoad address: 0x%lx\n"
  635. "Loading: *\b", load_addr);
  636. NetSetTimeout(nfs_timeout, NfsTimeout);
  637. net_set_udp_handler(NfsHandler);
  638. NfsTimeoutCount = 0;
  639. NfsState = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
  640. /*NfsOurPort = 4096 + (get_ticks() % 3072);*/
  641. /*FIX ME !!!*/
  642. NfsOurPort = 1000;
  643. /* zero out server ether in case the server ip has changed */
  644. memset(NetServerEther, 0, 6);
  645. NfsSend();
  646. }