blob: 9152ab742ef1a327254547d8ae125588b736b105 [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
Guillaume GARDETb0baca92016-07-29 11:31:00 +020025/* 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
wdenkcbd8a352004-02-24 02:00:03 +000029#include <common.h>
30#include <command.h>
Simon Glass0ee482522019-12-28 10:44:40 -070031#include <flash.h>
Simon Glass8e8ccfe2019-12-28 10:45:03 -070032#include <image.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060033#include <log.h>
wdenkcbd8a352004-02-24 02:00:03 +000034#include <net.h>
35#include <malloc.h>
Joe Hershberger55d5fd92015-03-22 17:09:08 -050036#include <mapmem.h>
wdenkcbd8a352004-02-24 02:00:03 +000037#include "nfs.h"
38#include "bootp.h"
Simon Glass10453152019-11-14 12:57:30 -070039#include <time.h>
wdenkcbd8a352004-02-24 02:00:03 +000040
wdenkcbd8a352004-02-24 02:00:03 +000041#define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
Hiroshi Itofe891ec2008-01-31 18:35:04 +090042#define NFS_RETRY_COUNT 30
wdenkcbd8a352004-02-24 02:00:03 +000043
Matthias Bruggerfa84fa72012-12-11 19:14:16 +010044#define NFS_RPC_ERR 1
45#define NFS_RPC_DROP 124
46
Joe Hershbergerc9f6c912012-05-15 08:59:09 +000047static int fs_mounted;
48static unsigned long rpc_id;
wdenkcbd8a352004-02-24 02:00:03 +000049static int nfs_offset = -1;
50static int nfs_len;
Tom Rinieeda7622022-03-11 09:12:05 -050051static const ulong nfs_timeout = CONFIG_NFS_TIMEOUT;
wdenkcbd8a352004-02-24 02:00:03 +000052
Guillaume GARDETb0baca92016-07-29 11:31:00 +020053static char dirfh[NFS_FHSIZE]; /* NFSv2 / NFSv3 file handle of directory */
Joe Hershberger5280c762016-08-15 15:03:19 -050054static char filefh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle */
Andrea zi0Black Cappabdbf7a02022-05-18 16:30:08 +000055static unsigned int filefh3_length; /* (variable) length of filefh when NFSv3 */
wdenkcbd8a352004-02-24 02:00:03 +000056
Joe Hershberger22f6e992012-05-23 07:59:14 +000057static enum net_loop_state nfs_download_state;
Joe Hershberger049a95a2015-04-08 01:41:01 -050058static struct in_addr nfs_server_ip;
Joe Hershberger68c76a32015-04-08 01:41:10 -050059static int nfs_server_mount_port;
60static int nfs_server_port;
61static int nfs_our_port;
62static int nfs_timeout_count;
63static int nfs_state;
wdenkcbd8a352004-02-24 02:00:03 +000064#define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
65#define STATE_PRCLOOKUP_PROG_NFS_REQ 2
66#define STATE_MOUNT_REQ 3
67#define STATE_UMOUNT_REQ 4
68#define STATE_LOOKUP_REQ 5
69#define STATE_READ_REQ 6
70#define STATE_READLINK_REQ 7
71
wdenkcbd8a352004-02-24 02:00:03 +000072static char *nfs_filename;
73static char *nfs_path;
74static char nfs_path_buff[2048];
75
Guillaume GARDETb0baca92016-07-29 11:31:00 +020076#define NFSV2_FLAG 1
77#define NFSV3_FLAG 1 << 1
78static char supported_nfs_versions = NFSV2_FLAG | NFSV3_FLAG;
79
Joe Hershberger68c76a32015-04-08 01:41:10 -050080static inline int store_block(uchar *src, unsigned offset, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +000081{
wdenka084f7d2004-02-24 22:33:21 +000082 ulong newsize = offset + len;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020083#ifdef CONFIG_SYS_DIRECT_FLASH_NFS
wdenkcbd8a352004-02-24 02:00:03 +000084 int i, rc = 0;
85
Joe Hershbergerc9f6c912012-05-15 08:59:09 +000086 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
wdenkcbd8a352004-02-24 02:00:03 +000087 /* start address in flash? */
Simon Glassbb872dd2019-12-28 10:45:02 -070088 if (image_load_addr + offset >= flash_info[i].start[0]) {
wdenkcbd8a352004-02-24 02:00:03 +000089 rc = 1;
90 break;
91 }
92 }
93
94 if (rc) { /* Flash is destination for this packet */
Simon Glassbb872dd2019-12-28 10:45:02 -070095 rc = flash_write((uchar *)src, (ulong)image_load_addr + offset,
96 len);
wdenkcbd8a352004-02-24 02:00:03 +000097 if (rc) {
Joe Hershbergerc9f6c912012-05-15 08:59:09 +000098 flash_perror(rc);
Wolfgang Denk23a7a322005-08-06 01:11:12 +020099 return -1;
wdenkcbd8a352004-02-24 02:00:03 +0000100 }
101 } else
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200102#endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
wdenkcbd8a352004-02-24 02:00:03 +0000103 {
Simon Glassbb872dd2019-12-28 10:45:02 -0700104 void *ptr = map_sysmem(image_load_addr + offset, len);
Joe Hershberger55d5fd92015-03-22 17:09:08 -0500105
106 memcpy(ptr, src, len);
107 unmap_sysmem(ptr);
wdenkcbd8a352004-02-24 02:00:03 +0000108 }
wdenka084f7d2004-02-24 22:33:21 +0000109
Joe Hershberger14111572015-04-08 01:41:02 -0500110 if (net_boot_file_size < (offset + len))
111 net_boot_file_size = newsize;
Wolfgang Denk23a7a322005-08-06 01:11:12 +0200112 return 0;
wdenkcbd8a352004-02-24 02:00:03 +0000113}
114
Joe Hershberger68c76a32015-04-08 01:41:10 -0500115static char *basename(char *path)
wdenkcbd8a352004-02-24 02:00:03 +0000116{
117 char *fname;
118
119 fname = path + strlen(path) - 1;
120 while (fname >= path) {
121 if (*fname == '/') {
122 fname++;
123 break;
124 }
125 fname--;
126 }
127 return fname;
128}
129
Joe Hershberger68c76a32015-04-08 01:41:10 -0500130static char *dirname(char *path)
wdenkcbd8a352004-02-24 02:00:03 +0000131{
132 char *fname;
133
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000134 fname = basename(path);
wdenkcbd8a352004-02-24 02:00:03 +0000135 --fname;
136 *fname = '\0';
137 return path;
138}
139
140/**************************************************************************
wdenkcbd8a352004-02-24 02:00:03 +0000141RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
142**************************************************************************/
Ralf Huberte4ead4a2016-07-01 13:19:51 +0200143static uint32_t *rpc_add_credentials(uint32_t *p)
wdenkcbd8a352004-02-24 02:00:03 +0000144{
wdenkcbd8a352004-02-24 02:00:03 +0000145 /* Here's the executive summary on authentication requirements of the
146 * various NFS server implementations: Linux accepts both AUTH_NONE
147 * and AUTH_UNIX authentication (also accepts an empty hostname field
148 * in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
149 * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
150 * scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
151 * it (if the BOOTP/DHCP reply didn't give one, just use an empty
152 * hostname). */
153
wdenkcbd8a352004-02-24 02:00:03 +0000154 /* Provide an AUTH_UNIX credential. */
155 *p++ = htonl(1); /* AUTH_UNIX */
Joe Hershberger1ff65d42016-08-15 15:03:27 -0500156 *p++ = htonl(20); /* auth length */
157 *p++ = 0; /* stamp */
158 *p++ = 0; /* hostname string */
wdenkcbd8a352004-02-24 02:00:03 +0000159 *p++ = 0; /* uid */
160 *p++ = 0; /* gid */
161 *p++ = 0; /* auxiliary gid list */
162
163 /* Provide an AUTH_NONE verifier. */
164 *p++ = 0; /* AUTH_NONE */
165 *p++ = 0; /* auth length */
166
167 return p;
168}
169
170/**************************************************************************
171RPC_LOOKUP - Lookup RPC Port numbers
172**************************************************************************/
Joe Hershbergera73588f2016-09-09 12:56:26 -0500173static void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
wdenkcbd8a352004-02-24 02:00:03 +0000174{
Joe Hershbergera73588f2016-09-09 12:56:26 -0500175 struct rpc_t rpc_pkt;
wdenkcbd8a352004-02-24 02:00:03 +0000176 unsigned long id;
Joe Hershbergera73588f2016-09-09 12:56:26 -0500177 uint32_t *p;
wdenkcbd8a352004-02-24 02:00:03 +0000178 int pktlen;
179 int sport;
180
wdenkc3f9d492004-03-14 00:59:59 +0000181 id = ++rpc_id;
Joe Hershbergera73588f2016-09-09 12:56:26 -0500182 rpc_pkt.u.call.id = htonl(id);
183 rpc_pkt.u.call.type = htonl(MSG_CALL);
184 rpc_pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
185 rpc_pkt.u.call.prog = htonl(rpc_prog);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200186 switch (rpc_prog) {
187 case PROG_NFS:
188 if (supported_nfs_versions & NFSV2_FLAG)
Joe Hershbergera73588f2016-09-09 12:56:26 -0500189 rpc_pkt.u.call.vers = htonl(2); /* NFS v2 */
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200190 else /* NFSV3_FLAG */
Joe Hershbergera73588f2016-09-09 12:56:26 -0500191 rpc_pkt.u.call.vers = htonl(3); /* NFS v3 */
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200192 break;
193 case PROG_PORTMAP:
194 case PROG_MOUNT:
195 default:
Joe Hershbergera73588f2016-09-09 12:56:26 -0500196 rpc_pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200197 }
Joe Hershbergera73588f2016-09-09 12:56:26 -0500198 rpc_pkt.u.call.proc = htonl(rpc_proc);
Heinrich Schuchardt15eea9a2019-09-02 23:55:32 +0200199 p = rpc_pkt.u.call.data;
wdenkcbd8a352004-02-24 02:00:03 +0000200
Joe Hershbergera73588f2016-09-09 12:56:26 -0500201 if (datalen)
Heinrich Schuchardt15eea9a2019-09-02 23:55:32 +0200202 memcpy(p, data, datalen * sizeof(uint32_t));
Joe Hershbergera73588f2016-09-09 12:56:26 -0500203
204 pktlen = (char *)p + datalen * sizeof(uint32_t) - (char *)&rpc_pkt;
205
206 memcpy((char *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE,
207 &rpc_pkt.u.data[0], pktlen);
wdenkcbd8a352004-02-24 02:00:03 +0000208
209 if (rpc_prog == PROG_PORTMAP)
210 sport = SUNRPC_PORT;
211 else if (rpc_prog == PROG_MOUNT)
Joe Hershberger68c76a32015-04-08 01:41:10 -0500212 sport = nfs_server_mount_port;
wdenkcbd8a352004-02-24 02:00:03 +0000213 else
Joe Hershberger68c76a32015-04-08 01:41:10 -0500214 sport = nfs_server_port;
wdenkcbd8a352004-02-24 02:00:03 +0000215
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500216 net_send_udp_packet(net_server_ethaddr, nfs_server_ip, sport,
Joe Hershberger68c76a32015-04-08 01:41:10 -0500217 nfs_our_port, pktlen);
wdenkcbd8a352004-02-24 02:00:03 +0000218}
219
220/**************************************************************************
221RPC_LOOKUP - Lookup RPC Port numbers
222**************************************************************************/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500223static void rpc_lookup_req(int prog, int ver)
wdenkcbd8a352004-02-24 02:00:03 +0000224{
Joe Hershbergera73588f2016-09-09 12:56:26 -0500225 uint32_t data[16];
wdenkcbd8a352004-02-24 02:00:03 +0000226
227 data[0] = 0; data[1] = 0; /* auth credential */
228 data[2] = 0; data[3] = 0; /* auth verifier */
229 data[4] = htonl(prog);
230 data[5] = htonl(ver);
231 data[6] = htonl(17); /* IP_UDP */
232 data[7] = 0;
Joe Hershbergera73588f2016-09-09 12:56:26 -0500233 rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
wdenkcbd8a352004-02-24 02:00:03 +0000234}
235
236/**************************************************************************
237NFS_MOUNT - Mount an NFS Filesystem
238**************************************************************************/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500239static void nfs_mount_req(char *path)
wdenkcbd8a352004-02-24 02:00:03 +0000240{
Joe Hershbergera73588f2016-09-09 12:56:26 -0500241 uint32_t data[1024];
wdenkcbd8a352004-02-24 02:00:03 +0000242 uint32_t *p;
243 int len;
244 int pathlen;
245
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000246 pathlen = strlen(path);
wdenkcbd8a352004-02-24 02:00:03 +0000247
Joe Hershbergera73588f2016-09-09 12:56:26 -0500248 p = &(data[0]);
Ralf Huberte4ead4a2016-07-01 13:19:51 +0200249 p = rpc_add_credentials(p);
wdenkcbd8a352004-02-24 02:00:03 +0000250
251 *p++ = htonl(pathlen);
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000252 if (pathlen & 3)
253 *(p + pathlen / 4) = 0;
254 memcpy(p, path, pathlen);
wdenkcbd8a352004-02-24 02:00:03 +0000255 p += (pathlen + 3) / 4;
256
Joe Hershbergera73588f2016-09-09 12:56:26 -0500257 len = (uint32_t *)p - (uint32_t *)&(data[0]);
wdenkcbd8a352004-02-24 02:00:03 +0000258
Joe Hershbergera73588f2016-09-09 12:56:26 -0500259 rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len);
wdenkcbd8a352004-02-24 02:00:03 +0000260}
261
262/**************************************************************************
263NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
264**************************************************************************/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500265static void nfs_umountall_req(void)
wdenkcbd8a352004-02-24 02:00:03 +0000266{
Joe Hershbergera73588f2016-09-09 12:56:26 -0500267 uint32_t data[1024];
wdenkcbd8a352004-02-24 02:00:03 +0000268 uint32_t *p;
269 int len;
270
Joe Hershberger68c76a32015-04-08 01:41:10 -0500271 if ((nfs_server_mount_port == -1) || (!fs_mounted))
wdenkcbd8a352004-02-24 02:00:03 +0000272 /* Nothing mounted, nothing to umount */
273 return;
wdenkcbd8a352004-02-24 02:00:03 +0000274
Joe Hershbergera73588f2016-09-09 12:56:26 -0500275 p = &(data[0]);
Ralf Huberte4ead4a2016-07-01 13:19:51 +0200276 p = rpc_add_credentials(p);
wdenkcbd8a352004-02-24 02:00:03 +0000277
Joe Hershbergera73588f2016-09-09 12:56:26 -0500278 len = (uint32_t *)p - (uint32_t *)&(data[0]);
wdenkcbd8a352004-02-24 02:00:03 +0000279
Joe Hershbergera73588f2016-09-09 12:56:26 -0500280 rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
wdenkcbd8a352004-02-24 02:00:03 +0000281}
282
283/***************************************************************************
284 * NFS_READLINK (AH 2003-07-14)
285 * This procedure is called when read of the first block fails -
286 * this probably happens when it's a directory or a symlink
287 * In case of successful readlink(), the dirname is manipulated,
288 * so that inside the nfs() function a recursion can be done.
289 **************************************************************************/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500290static void nfs_readlink_req(void)
wdenkcbd8a352004-02-24 02:00:03 +0000291{
Joe Hershbergera73588f2016-09-09 12:56:26 -0500292 uint32_t data[1024];
wdenkcbd8a352004-02-24 02:00:03 +0000293 uint32_t *p;
294 int len;
295
Joe Hershbergera73588f2016-09-09 12:56:26 -0500296 p = &(data[0]);
Ralf Huberte4ead4a2016-07-01 13:19:51 +0200297 p = rpc_add_credentials(p);
wdenkcbd8a352004-02-24 02:00:03 +0000298
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200299 if (supported_nfs_versions & NFSV2_FLAG) {
300 memcpy(p, filefh, NFS_FHSIZE);
301 p += (NFS_FHSIZE / 4);
302 } else { /* NFSV3_FLAG */
303 *p++ = htonl(filefh3_length);
Joe Hershberger5280c762016-08-15 15:03:19 -0500304 memcpy(p, filefh, filefh3_length);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200305 p += (filefh3_length / 4);
306 }
wdenkcbd8a352004-02-24 02:00:03 +0000307
Joe Hershbergera73588f2016-09-09 12:56:26 -0500308 len = (uint32_t *)p - (uint32_t *)&(data[0]);
wdenkcbd8a352004-02-24 02:00:03 +0000309
Joe Hershbergera73588f2016-09-09 12:56:26 -0500310 rpc_req(PROG_NFS, NFS_READLINK, data, len);
wdenkcbd8a352004-02-24 02:00:03 +0000311}
312
313/**************************************************************************
314NFS_LOOKUP - Lookup Pathname
315**************************************************************************/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500316static void nfs_lookup_req(char *fname)
wdenkcbd8a352004-02-24 02:00:03 +0000317{
Joe Hershbergera73588f2016-09-09 12:56:26 -0500318 uint32_t data[1024];
wdenkcbd8a352004-02-24 02:00:03 +0000319 uint32_t *p;
320 int len;
321 int fnamelen;
322
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000323 fnamelen = strlen(fname);
wdenkcbd8a352004-02-24 02:00:03 +0000324
Joe Hershbergera73588f2016-09-09 12:56:26 -0500325 p = &(data[0]);
Ralf Huberte4ead4a2016-07-01 13:19:51 +0200326 p = rpc_add_credentials(p);
wdenkcbd8a352004-02-24 02:00:03 +0000327
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200328 if (supported_nfs_versions & NFSV2_FLAG) {
329 memcpy(p, dirfh, NFS_FHSIZE);
330 p += (NFS_FHSIZE / 4);
331 *p++ = htonl(fnamelen);
332 if (fnamelen & 3)
333 *(p + fnamelen / 4) = 0;
334 memcpy(p, fname, fnamelen);
335 p += (fnamelen + 3) / 4;
wdenkcbd8a352004-02-24 02:00:03 +0000336
Joe Hershbergera73588f2016-09-09 12:56:26 -0500337 len = (uint32_t *)p - (uint32_t *)&(data[0]);
wdenkcbd8a352004-02-24 02:00:03 +0000338
Joe Hershbergera73588f2016-09-09 12:56:26 -0500339 rpc_req(PROG_NFS, NFS_LOOKUP, data, len);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200340 } else { /* NFSV3_FLAG */
341 *p++ = htonl(NFS_FHSIZE); /* Dir handle length */
342 memcpy(p, dirfh, NFS_FHSIZE);
343 p += (NFS_FHSIZE / 4);
344 *p++ = htonl(fnamelen);
345 if (fnamelen & 3)
346 *(p + fnamelen / 4) = 0;
347 memcpy(p, fname, fnamelen);
348 p += (fnamelen + 3) / 4;
349
Joe Hershbergera73588f2016-09-09 12:56:26 -0500350 len = (uint32_t *)p - (uint32_t *)&(data[0]);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200351
Joe Hershbergera73588f2016-09-09 12:56:26 -0500352 rpc_req(PROG_NFS, NFS3PROC_LOOKUP, data, len);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200353 }
wdenkcbd8a352004-02-24 02:00:03 +0000354}
355
356/**************************************************************************
357NFS_READ - Read File on NFS Server
358**************************************************************************/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500359static void nfs_read_req(int offset, int readlen)
wdenkcbd8a352004-02-24 02:00:03 +0000360{
Joe Hershbergera73588f2016-09-09 12:56:26 -0500361 uint32_t data[1024];
wdenkcbd8a352004-02-24 02:00:03 +0000362 uint32_t *p;
363 int len;
364
Joe Hershbergera73588f2016-09-09 12:56:26 -0500365 p = &(data[0]);
Ralf Huberte4ead4a2016-07-01 13:19:51 +0200366 p = rpc_add_credentials(p);
wdenkcbd8a352004-02-24 02:00:03 +0000367
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200368 if (supported_nfs_versions & NFSV2_FLAG) {
369 memcpy(p, filefh, NFS_FHSIZE);
370 p += (NFS_FHSIZE / 4);
371 *p++ = htonl(offset);
372 *p++ = htonl(readlen);
373 *p++ = 0;
374 } else { /* NFSV3_FLAG */
375 *p++ = htonl(filefh3_length);
Joe Hershberger5280c762016-08-15 15:03:19 -0500376 memcpy(p, filefh, filefh3_length);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200377 p += (filefh3_length / 4);
378 *p++ = htonl(0); /* offset is 64-bit long, so fill with 0 */
379 *p++ = htonl(offset);
380 *p++ = htonl(readlen);
381 *p++ = 0;
382 }
wdenkcbd8a352004-02-24 02:00:03 +0000383
Joe Hershbergera73588f2016-09-09 12:56:26 -0500384 len = (uint32_t *)p - (uint32_t *)&(data[0]);
wdenkcbd8a352004-02-24 02:00:03 +0000385
Joe Hershbergera73588f2016-09-09 12:56:26 -0500386 rpc_req(PROG_NFS, NFS_READ, data, len);
wdenkcbd8a352004-02-24 02:00:03 +0000387}
388
389/**************************************************************************
390RPC request dispatcher
391**************************************************************************/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500392static void nfs_send(void)
wdenkcbd8a352004-02-24 02:00:03 +0000393{
Robin Getz0ebf04c2009-07-23 03:01:03 -0400394 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000395
Joe Hershberger68c76a32015-04-08 01:41:10 -0500396 switch (nfs_state) {
wdenkcbd8a352004-02-24 02:00:03 +0000397 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200398 if (supported_nfs_versions & NFSV2_FLAG)
399 rpc_lookup_req(PROG_MOUNT, 1);
400 else /* NFSV3_FLAG */
401 rpc_lookup_req(PROG_MOUNT, 3);
wdenkcbd8a352004-02-24 02:00:03 +0000402 break;
403 case STATE_PRCLOOKUP_PROG_NFS_REQ:
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200404 if (supported_nfs_versions & NFSV2_FLAG)
405 rpc_lookup_req(PROG_NFS, 2);
406 else /* NFSV3_FLAG */
407 rpc_lookup_req(PROG_NFS, 3);
wdenkcbd8a352004-02-24 02:00:03 +0000408 break;
409 case STATE_MOUNT_REQ:
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000410 nfs_mount_req(nfs_path);
wdenkcbd8a352004-02-24 02:00:03 +0000411 break;
412 case STATE_UMOUNT_REQ:
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000413 nfs_umountall_req();
wdenkcbd8a352004-02-24 02:00:03 +0000414 break;
415 case STATE_LOOKUP_REQ:
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000416 nfs_lookup_req(nfs_filename);
wdenkcbd8a352004-02-24 02:00:03 +0000417 break;
418 case STATE_READ_REQ:
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000419 nfs_read_req(nfs_offset, nfs_len);
wdenkcbd8a352004-02-24 02:00:03 +0000420 break;
421 case STATE_READLINK_REQ:
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000422 nfs_readlink_req();
wdenkcbd8a352004-02-24 02:00:03 +0000423 break;
424 }
425}
426
427/**************************************************************************
428Handlers for the reply from server
429**************************************************************************/
430
Joe Hershberger68c76a32015-04-08 01:41:10 -0500431static int rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +0000432{
433 struct rpc_t rpc_pkt;
434
Joe Hershberger0517cc42016-08-15 15:03:24 -0500435 memcpy(&rpc_pkt.u.data[0], pkt, len);
wdenkcbd8a352004-02-24 02:00:03 +0000436
Robin Getz0ebf04c2009-07-23 03:01:03 -0400437 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000438
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100439 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
440 return -NFS_RPC_ERR;
441 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
442 return -NFS_RPC_DROP;
wdenkc3f9d492004-03-14 00:59:59 +0000443
wdenkcbd8a352004-02-24 02:00:03 +0000444 if (rpc_pkt.u.reply.rstatus ||
445 rpc_pkt.u.reply.verifier ||
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000446 rpc_pkt.u.reply.astatus)
wdenkc3f9d492004-03-14 00:59:59 +0000447 return -1;
wdenkcbd8a352004-02-24 02:00:03 +0000448
449 switch (prog) {
450 case PROG_MOUNT:
Joe Hershberger68c76a32015-04-08 01:41:10 -0500451 nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]);
wdenkcbd8a352004-02-24 02:00:03 +0000452 break;
453 case PROG_NFS:
Joe Hershberger68c76a32015-04-08 01:41:10 -0500454 nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]);
wdenkcbd8a352004-02-24 02:00:03 +0000455 break;
456 }
457
458 return 0;
459}
460
Joe Hershberger68c76a32015-04-08 01:41:10 -0500461static int nfs_mount_reply(uchar *pkt, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +0000462{
463 struct rpc_t rpc_pkt;
464
Robin Getz0ebf04c2009-07-23 03:01:03 -0400465 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000466
Joe Hershberger0517cc42016-08-15 15:03:24 -0500467 memcpy(&rpc_pkt.u.data[0], pkt, len);
wdenkcbd8a352004-02-24 02:00:03 +0000468
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100469 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
470 return -NFS_RPC_ERR;
471 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
472 return -NFS_RPC_DROP;
wdenkc3f9d492004-03-14 00:59:59 +0000473
wdenkcbd8a352004-02-24 02:00:03 +0000474 if (rpc_pkt.u.reply.rstatus ||
475 rpc_pkt.u.reply.verifier ||
476 rpc_pkt.u.reply.astatus ||
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000477 rpc_pkt.u.reply.data[0])
wdenkcbd8a352004-02-24 02:00:03 +0000478 return -1;
wdenkcbd8a352004-02-24 02:00:03 +0000479
480 fs_mounted = 1;
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200481 /* NFSv2 and NFSv3 use same structure */
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000482 memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
wdenkcbd8a352004-02-24 02:00:03 +0000483
484 return 0;
485}
486
Joe Hershberger68c76a32015-04-08 01:41:10 -0500487static int nfs_umountall_reply(uchar *pkt, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +0000488{
489 struct rpc_t rpc_pkt;
490
Robin Getz0ebf04c2009-07-23 03:01:03 -0400491 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000492
Joe Hershberger0517cc42016-08-15 15:03:24 -0500493 memcpy(&rpc_pkt.u.data[0], pkt, len);
wdenkcbd8a352004-02-24 02:00:03 +0000494
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100495 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
496 return -NFS_RPC_ERR;
497 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
498 return -NFS_RPC_DROP;
wdenkc3f9d492004-03-14 00:59:59 +0000499
wdenkcbd8a352004-02-24 02:00:03 +0000500 if (rpc_pkt.u.reply.rstatus ||
501 rpc_pkt.u.reply.verifier ||
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000502 rpc_pkt.u.reply.astatus)
wdenkcbd8a352004-02-24 02:00:03 +0000503 return -1;
wdenkcbd8a352004-02-24 02:00:03 +0000504
505 fs_mounted = 0;
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000506 memset(dirfh, 0, sizeof(dirfh));
wdenkcbd8a352004-02-24 02:00:03 +0000507
508 return 0;
509}
510
Joe Hershberger68c76a32015-04-08 01:41:10 -0500511static int nfs_lookup_reply(uchar *pkt, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +0000512{
513 struct rpc_t rpc_pkt;
514
Robin Getz0ebf04c2009-07-23 03:01:03 -0400515 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000516
Joe Hershberger0517cc42016-08-15 15:03:24 -0500517 memcpy(&rpc_pkt.u.data[0], pkt, len);
wdenkcbd8a352004-02-24 02:00:03 +0000518
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100519 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
520 return -NFS_RPC_ERR;
521 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
522 return -NFS_RPC_DROP;
wdenkc3f9d492004-03-14 00:59:59 +0000523
wdenkcbd8a352004-02-24 02:00:03 +0000524 if (rpc_pkt.u.reply.rstatus ||
525 rpc_pkt.u.reply.verifier ||
526 rpc_pkt.u.reply.astatus ||
Guillaume GARDET69fd0d42016-06-06 15:11:45 +0200527 rpc_pkt.u.reply.data[0]) {
528 switch (ntohl(rpc_pkt.u.reply.astatus)) {
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200529 case NFS_RPC_SUCCESS: /* Not an error */
Guillaume GARDET69fd0d42016-06-06 15:11:45 +0200530 break;
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200531 case NFS_RPC_PROG_MISMATCH:
532 /* Remote can't support NFS version */
533 switch (ntohl(rpc_pkt.u.reply.data[0])) {
534 /* Minimal supported NFS version */
535 case 3:
Joe Hershbergerfaecf842018-07-03 19:22:56 -0500536 debug("*** Warning: NFS version not supported: Requested: V%d, accepted: min V%d - max V%d\n",
Joe Hershberger347a9012016-08-15 15:03:21 -0500537 (supported_nfs_versions & NFSV2_FLAG) ?
538 2 : 3,
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200539 ntohl(rpc_pkt.u.reply.data[0]),
540 ntohl(rpc_pkt.u.reply.data[1]));
541 debug("Will retry with NFSv3\n");
542 /* Clear NFSV2_FLAG from supported versions */
543 supported_nfs_versions &= ~NFSV2_FLAG;
544 return -NFS_RPC_PROG_MISMATCH;
545 case 4:
546 default:
Joe Hershbergerd89ff2d2016-08-15 15:03:25 -0500547 puts("*** ERROR: NFS version not supported");
548 debug(": Requested: V%d, accepted: min V%d - max V%d\n",
549 (supported_nfs_versions & NFSV2_FLAG) ?
Joe Hershberger347a9012016-08-15 15:03:21 -0500550 2 : 3,
Joe Hershbergerd89ff2d2016-08-15 15:03:25 -0500551 ntohl(rpc_pkt.u.reply.data[0]),
552 ntohl(rpc_pkt.u.reply.data[1]));
553 puts("\n");
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200554 }
Guillaume GARDET69fd0d42016-06-06 15:11:45 +0200555 break;
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200556 case NFS_RPC_PROG_UNAVAIL:
557 case NFS_RPC_PROC_UNAVAIL:
558 case NFS_RPC_GARBAGE_ARGS:
559 case NFS_RPC_SYSTEM_ERR:
Guillaume GARDET69fd0d42016-06-06 15:11:45 +0200560 default: /* Unknown error on 'accept state' flag */
Joe Hershbergerd89ff2d2016-08-15 15:03:25 -0500561 debug("*** ERROR: accept state error (%d)\n",
562 ntohl(rpc_pkt.u.reply.astatus));
Guillaume GARDET69fd0d42016-06-06 15:11:45 +0200563 break;
564 }
wdenkcbd8a352004-02-24 02:00:03 +0000565 return -1;
Guillaume GARDET69fd0d42016-06-06 15:11:45 +0200566 }
wdenkcbd8a352004-02-24 02:00:03 +0000567
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200568 if (supported_nfs_versions & NFSV2_FLAG) {
liucheng (G)5d14ee42019-08-29 13:48:02 +0000569 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + NFS_FHSIZE) > len)
570 return -NFS_RPC_DROP;
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200571 memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
572 } else { /* NFSV3_FLAG */
573 filefh3_length = ntohl(rpc_pkt.u.reply.data[1]);
574 if (filefh3_length > NFS3_FHSIZE)
575 filefh3_length = NFS3_FHSIZE;
Joe Hershberger5280c762016-08-15 15:03:19 -0500576 memcpy(filefh, rpc_pkt.u.reply.data + 2, filefh3_length);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200577 }
wdenkcbd8a352004-02-24 02:00:03 +0000578
579 return 0;
580}
581
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500582static int nfs3_get_attributes_offset(uint32_t *data)
583{
Heinrich Schuchardt15eea9a2019-09-02 23:55:32 +0200584 if (data[1]) {
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500585 /* 'attributes_follow' flag is TRUE,
Joe Hershbergerc629c452016-08-15 15:03:23 -0500586 * so we have attributes on 21 dwords */
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500587 /* Skip unused values :
588 type; 32 bits value,
589 mode; 32 bits value,
590 nlink; 32 bits value,
591 uid; 32 bits value,
592 gid; 32 bits value,
593 size; 64 bits value,
594 used; 64 bits value,
595 rdev; 64 bits value,
596 fsid; 64 bits value,
597 fileid; 64 bits value,
598 atime; 64 bits value,
599 mtime; 64 bits value,
600 ctime; 64 bits value,
601 */
602 return 22;
603 } else {
604 /* 'attributes_follow' flag is FALSE,
605 * so we don't have any attributes */
606 return 1;
607 }
608}
609
Joe Hershberger68c76a32015-04-08 01:41:10 -0500610static int nfs_readlink_reply(uchar *pkt, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +0000611{
612 struct rpc_t rpc_pkt;
613 int rlen;
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500614 int nfsv3_data_offset = 0;
wdenkcbd8a352004-02-24 02:00:03 +0000615
Robin Getz0ebf04c2009-07-23 03:01:03 -0400616 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000617
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000618 memcpy((unsigned char *)&rpc_pkt, pkt, len);
wdenkcbd8a352004-02-24 02:00:03 +0000619
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100620 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
621 return -NFS_RPC_ERR;
622 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
623 return -NFS_RPC_DROP;
wdenkc3f9d492004-03-14 00:59:59 +0000624
wdenkcbd8a352004-02-24 02:00:03 +0000625 if (rpc_pkt.u.reply.rstatus ||
626 rpc_pkt.u.reply.verifier ||
627 rpc_pkt.u.reply.astatus ||
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000628 rpc_pkt.u.reply.data[0])
wdenkcbd8a352004-02-24 02:00:03 +0000629 return -1;
wdenkcbd8a352004-02-24 02:00:03 +0000630
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500631 if (!(supported_nfs_versions & NFSV2_FLAG)) { /* NFSV3_FLAG */
632 nfsv3_data_offset =
633 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
634 }
wdenkcbd8a352004-02-24 02:00:03 +0000635
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500636 /* new path length */
637 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200638
liucheng (G)cf3a4f12019-08-29 13:47:54 +0000639 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
640 return -NFS_RPC_DROP;
641
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500642 if (*((char *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset])) != '/') {
643 int pathlen;
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200644
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500645 strcat(nfs_path, "/");
646 pathlen = strlen(nfs_path);
647 memcpy(nfs_path + pathlen,
648 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
649 rlen);
650 nfs_path[pathlen + rlen] = 0;
651 } else {
652 memcpy(nfs_path,
653 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
654 rlen);
655 nfs_path[rlen] = 0;
wdenkcbd8a352004-02-24 02:00:03 +0000656 }
657 return 0;
658}
659
Joe Hershberger68c76a32015-04-08 01:41:10 -0500660static int nfs_read_reply(uchar *pkt, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +0000661{
662 struct rpc_t rpc_pkt;
663 int rlen;
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200664 uchar *data_ptr;
wdenkcbd8a352004-02-24 02:00:03 +0000665
Robin Getz0ebf04c2009-07-23 03:01:03 -0400666 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000667
Joe Hershberger0517cc42016-08-15 15:03:24 -0500668 memcpy(&rpc_pkt.u.data[0], pkt, sizeof(rpc_pkt.u.reply));
wdenkcbd8a352004-02-24 02:00:03 +0000669
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100670 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
671 return -NFS_RPC_ERR;
672 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
673 return -NFS_RPC_DROP;
wdenkc3f9d492004-03-14 00:59:59 +0000674
wdenkcbd8a352004-02-24 02:00:03 +0000675 if (rpc_pkt.u.reply.rstatus ||
676 rpc_pkt.u.reply.verifier ||
677 rpc_pkt.u.reply.astatus ||
678 rpc_pkt.u.reply.data[0]) {
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000679 if (rpc_pkt.u.reply.rstatus)
wdenkcbd8a352004-02-24 02:00:03 +0000680 return -9999;
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000681 if (rpc_pkt.u.reply.astatus)
wdenkcbd8a352004-02-24 02:00:03 +0000682 return -9999;
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000683 return -ntohl(rpc_pkt.u.reply.data[0]);
wdenkcbd8a352004-02-24 02:00:03 +0000684 }
685
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000686 if ((nfs_offset != 0) && !((nfs_offset) %
687 (NFS_READ_SIZE / 2 * 10 * HASHES_PER_LINE)))
688 puts("\n\t ");
689 if (!(nfs_offset % ((NFS_READ_SIZE / 2) * 10)))
690 putc('#');
wdenkcbd8a352004-02-24 02:00:03 +0000691
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200692 if (supported_nfs_versions & NFSV2_FLAG) {
693 rlen = ntohl(rpc_pkt.u.reply.data[18]);
694 data_ptr = (uchar *)&(rpc_pkt.u.reply.data[19]);
695 } else { /* NFSV3_FLAG */
Joe Hershberger051ed9a2016-08-15 15:03:22 -0500696 int nfsv3_data_offset =
697 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
698
699 /* count value */
700 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
701 /* Skip unused values :
702 EOF: 32 bits value,
703 data_size: 32 bits value,
704 */
705 data_ptr = (uchar *)
706 &(rpc_pkt.u.reply.data[4 + nfsv3_data_offset]);
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200707 }
708
liucheng (G)aa207cf2019-08-29 13:47:48 +0000709 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
710 return -9999;
711
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200712 if (store_block(data_ptr, nfs_offset, rlen))
713 return -9999;
wdenkcbd8a352004-02-24 02:00:03 +0000714
715 return rlen;
716}
717
718/**************************************************************************
719Interfaces of U-BOOT
720**************************************************************************/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500721static void nfs_timeout_handler(void)
wdenka5725fa2004-09-28 21:51:42 +0000722{
Joe Hershberger68c76a32015-04-08 01:41:10 -0500723 if (++nfs_timeout_count > NFS_RETRY_COUNT) {
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000724 puts("\nRetry count exceeded; starting again\n");
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500725 net_start_again();
Evan Samanasaabb8cb2009-11-09 20:08:36 -0600726 } else {
727 puts("T ");
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500728 net_set_timeout_handler(nfs_timeout +
Tom Rinieeda7622022-03-11 09:12:05 -0500729 nfs_timeout * nfs_timeout_count,
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500730 nfs_timeout_handler);
Joe Hershberger68c76a32015-04-08 01:41:10 -0500731 nfs_send();
Hiroshi Itofe891ec2008-01-31 18:35:04 +0900732 }
wdenka5725fa2004-09-28 21:51:42 +0000733}
734
Joe Hershberger049a95a2015-04-08 01:41:01 -0500735static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip,
736 unsigned src, unsigned len)
wdenkcbd8a352004-02-24 02:00:03 +0000737{
738 int rlen;
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100739 int reply;
wdenkcbd8a352004-02-24 02:00:03 +0000740
Robin Getz0ebf04c2009-07-23 03:01:03 -0400741 debug("%s\n", __func__);
wdenkcbd8a352004-02-24 02:00:03 +0000742
liucheng (G)741a8a02019-08-29 13:47:40 +0000743 if (len > sizeof(struct rpc_t))
744 return;
745
Joe Hershberger68c76a32015-04-08 01:41:10 -0500746 if (dest != nfs_our_port)
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000747 return;
wdenkcbd8a352004-02-24 02:00:03 +0000748
Joe Hershberger68c76a32015-04-08 01:41:10 -0500749 switch (nfs_state) {
wdenkcbd8a352004-02-24 02:00:03 +0000750 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100751 if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP)
752 break;
Joe Hershberger68c76a32015-04-08 01:41:10 -0500753 nfs_state = STATE_PRCLOOKUP_PROG_NFS_REQ;
754 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000755 break;
756
757 case STATE_PRCLOOKUP_PROG_NFS_REQ:
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100758 if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
759 break;
Joe Hershberger68c76a32015-04-08 01:41:10 -0500760 nfs_state = STATE_MOUNT_REQ;
761 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000762 break;
763
764 case STATE_MOUNT_REQ:
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100765 reply = nfs_mount_reply(pkt, len);
Joe Hershberger68c76a32015-04-08 01:41:10 -0500766 if (reply == -NFS_RPC_DROP) {
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100767 break;
Joe Hershberger68c76a32015-04-08 01:41:10 -0500768 } else if (reply == -NFS_RPC_ERR) {
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000769 puts("*** ERROR: Cannot mount\n");
wdenkcbd8a352004-02-24 02:00:03 +0000770 /* just to be sure... */
Joe Hershberger68c76a32015-04-08 01:41:10 -0500771 nfs_state = STATE_UMOUNT_REQ;
772 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000773 } else {
Joe Hershberger68c76a32015-04-08 01:41:10 -0500774 nfs_state = STATE_LOOKUP_REQ;
775 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000776 }
777 break;
778
779 case STATE_UMOUNT_REQ:
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100780 reply = nfs_umountall_reply(pkt, len);
Joe Hershberger68c76a32015-04-08 01:41:10 -0500781 if (reply == -NFS_RPC_DROP) {
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100782 break;
Joe Hershberger68c76a32015-04-08 01:41:10 -0500783 } else if (reply == -NFS_RPC_ERR) {
Joe Hershbergerd89ff2d2016-08-15 15:03:25 -0500784 debug("*** ERROR: Cannot umount\n");
Joe Hershberger22f6e992012-05-23 07:59:14 +0000785 net_set_state(NETLOOP_FAIL);
wdenkcbd8a352004-02-24 02:00:03 +0000786 } else {
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000787 puts("\ndone\n");
Joe Hershberger22f6e992012-05-23 07:59:14 +0000788 net_set_state(nfs_download_state);
wdenkcbd8a352004-02-24 02:00:03 +0000789 }
790 break;
791
792 case STATE_LOOKUP_REQ:
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100793 reply = nfs_lookup_reply(pkt, len);
Joe Hershberger68c76a32015-04-08 01:41:10 -0500794 if (reply == -NFS_RPC_DROP) {
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100795 break;
Joe Hershberger68c76a32015-04-08 01:41:10 -0500796 } else if (reply == -NFS_RPC_ERR) {
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000797 puts("*** ERROR: File lookup fail\n");
Joe Hershberger68c76a32015-04-08 01:41:10 -0500798 nfs_state = STATE_UMOUNT_REQ;
799 nfs_send();
Joe Hershberger347a9012016-08-15 15:03:21 -0500800 } else if (reply == -NFS_RPC_PROG_MISMATCH &&
801 supported_nfs_versions != 0) {
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200802 /* umount */
803 nfs_state = STATE_UMOUNT_REQ;
804 nfs_send();
805 /* And retry with another supported version */
806 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
807 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000808 } else {
Joe Hershberger68c76a32015-04-08 01:41:10 -0500809 nfs_state = STATE_READ_REQ;
wdenkcbd8a352004-02-24 02:00:03 +0000810 nfs_offset = 0;
811 nfs_len = NFS_READ_SIZE;
Joe Hershberger68c76a32015-04-08 01:41:10 -0500812 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000813 }
814 break;
815
816 case STATE_READLINK_REQ:
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100817 reply = nfs_readlink_reply(pkt, len);
Joe Hershberger68c76a32015-04-08 01:41:10 -0500818 if (reply == -NFS_RPC_DROP) {
Matthias Bruggerfa84fa72012-12-11 19:14:16 +0100819 break;
Joe Hershberger68c76a32015-04-08 01:41:10 -0500820 } else if (reply == -NFS_RPC_ERR) {
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000821 puts("*** ERROR: Symlink fail\n");
Joe Hershberger68c76a32015-04-08 01:41:10 -0500822 nfs_state = STATE_UMOUNT_REQ;
823 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000824 } else {
Robin Getz0ebf04c2009-07-23 03:01:03 -0400825 debug("Symlink --> %s\n", nfs_path);
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000826 nfs_filename = basename(nfs_path);
827 nfs_path = dirname(nfs_path);
wdenkcbd8a352004-02-24 02:00:03 +0000828
Joe Hershberger68c76a32015-04-08 01:41:10 -0500829 nfs_state = STATE_MOUNT_REQ;
830 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000831 }
832 break;
833
834 case STATE_READ_REQ:
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000835 rlen = nfs_read_reply(pkt, len);
Vasily Khoruzhickd48d40a2018-05-14 08:34:36 -0700836 if (rlen == -NFS_RPC_DROP)
837 break;
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500838 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
wdenkcbd8a352004-02-24 02:00:03 +0000839 if (rlen > 0) {
840 nfs_offset += rlen;
Joe Hershberger68c76a32015-04-08 01:41:10 -0500841 nfs_send();
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000842 } else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
wdenkcbd8a352004-02-24 02:00:03 +0000843 /* symbolic link */
Joe Hershberger68c76a32015-04-08 01:41:10 -0500844 nfs_state = STATE_READLINK_REQ;
845 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000846 } else {
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000847 if (!rlen)
Joe Hershberger22f6e992012-05-23 07:59:14 +0000848 nfs_download_state = NETLOOP_SUCCESS;
Guillaume GARDETb0baca92016-07-29 11:31:00 +0200849 if (rlen < 0)
Joe Hershbergerd89ff2d2016-08-15 15:03:25 -0500850 debug("NFS READ error (%d)\n", rlen);
Joe Hershberger68c76a32015-04-08 01:41:10 -0500851 nfs_state = STATE_UMOUNT_REQ;
852 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000853 }
854 break;
855 }
856}
857
wdenkcbd8a352004-02-24 02:00:03 +0000858
Joe Hershberger68c76a32015-04-08 01:41:10 -0500859void nfs_start(void)
wdenkcbd8a352004-02-24 02:00:03 +0000860{
Robin Getz0ebf04c2009-07-23 03:01:03 -0400861 debug("%s\n", __func__);
Joe Hershberger22f6e992012-05-23 07:59:14 +0000862 nfs_download_state = NETLOOP_FAIL;
wdenkcbd8a352004-02-24 02:00:03 +0000863
Joe Hershberger049a95a2015-04-08 01:41:01 -0500864 nfs_server_ip = net_server_ip;
wdenkcbd8a352004-02-24 02:00:03 +0000865 nfs_path = (char *)nfs_path_buff;
866
867 if (nfs_path == NULL) {
Joe Hershberger22f6e992012-05-23 07:59:14 +0000868 net_set_state(NETLOOP_FAIL);
Joe Hershbergerfaecf842018-07-03 19:22:56 -0500869 printf("*** ERROR: Fail allocate memory\n");
wdenkcbd8a352004-02-24 02:00:03 +0000870 return;
871 }
872
Joe Hershberger6ab12832018-07-03 19:36:43 -0500873 if (!net_parse_bootfile(&nfs_server_ip, nfs_path,
874 sizeof(nfs_path_buff))) {
Joe Hershbergerf8b26c72016-08-15 14:42:16 -0500875 sprintf(nfs_path, "/nfsroot/%02X%02X%02X%02X.img",
Joe Hershberger049a95a2015-04-08 01:41:01 -0500876 net_ip.s_addr & 0xFF,
877 (net_ip.s_addr >> 8) & 0xFF,
878 (net_ip.s_addr >> 16) & 0xFF,
879 (net_ip.s_addr >> 24) & 0xFF);
wdenkcbd8a352004-02-24 02:00:03 +0000880
Joe Hershbergerfaecf842018-07-03 19:22:56 -0500881 printf("*** Warning: no boot file name; using '%s'\n",
882 nfs_path);
wdenkcbd8a352004-02-24 02:00:03 +0000883 }
884
Joe Hershbergerc9f6c912012-05-15 08:59:09 +0000885 nfs_filename = basename(nfs_path);
886 nfs_path = dirname(nfs_path);
wdenkcbd8a352004-02-24 02:00:03 +0000887
Joe Hershbergerfaecf842018-07-03 19:22:56 -0500888 printf("Using %s device\n", eth_get_name());
wdenkcbd8a352004-02-24 02:00:03 +0000889
Joe Hershbergerfaecf842018-07-03 19:22:56 -0500890 printf("File transfer via NFS from server %pI4; our IP address is %pI4",
891 &nfs_server_ip, &net_ip);
wdenkcbd8a352004-02-24 02:00:03 +0000892
893 /* Check if we need to send across this subnet */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500894 if (net_gateway.s_addr && net_netmask.s_addr) {
895 struct in_addr our_net;
896 struct in_addr server_net;
wdenkcbd8a352004-02-24 02:00:03 +0000897
Joe Hershberger049a95a2015-04-08 01:41:01 -0500898 our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
Joe Hershberger347e32b2018-07-03 19:22:55 -0500899 server_net.s_addr = nfs_server_ip.s_addr & net_netmask.s_addr;
Joe Hershberger049a95a2015-04-08 01:41:01 -0500900 if (our_net.s_addr != server_net.s_addr)
Joe Hershbergerfaecf842018-07-03 19:22:56 -0500901 printf("; sending through gateway %pI4",
902 &net_gateway);
wdenkcbd8a352004-02-24 02:00:03 +0000903 }
Joe Hershbergerfaecf842018-07-03 19:22:56 -0500904 printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
wdenkcbd8a352004-02-24 02:00:03 +0000905
Joe Hershberger14111572015-04-08 01:41:02 -0500906 if (net_boot_file_expected_size_in_blocks) {
Joe Hershbergerfaecf842018-07-03 19:22:56 -0500907 printf(" Size is 0x%x Bytes = ",
908 net_boot_file_expected_size_in_blocks << 9);
Joe Hershberger14111572015-04-08 01:41:02 -0500909 print_size(net_boot_file_expected_size_in_blocks << 9, "");
wdenkcbd8a352004-02-24 02:00:03 +0000910 }
Simon Glassbb872dd2019-12-28 10:45:02 -0700911 printf("\nLoad address: 0x%lx\nLoading: *\b", image_load_addr);
wdenkcbd8a352004-02-24 02:00:03 +0000912
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500913 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
Joe Hershberger049a95a2015-04-08 01:41:01 -0500914 net_set_udp_handler(nfs_handler);
wdenkcbd8a352004-02-24 02:00:03 +0000915
Joe Hershberger68c76a32015-04-08 01:41:10 -0500916 nfs_timeout_count = 0;
917 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
wdenkcbd8a352004-02-24 02:00:03 +0000918
Joe Hershberger68c76a32015-04-08 01:41:10 -0500919 /*nfs_our_port = 4096 + (get_ticks() % 3072);*/
wdenkcbd8a352004-02-24 02:00:03 +0000920 /*FIX ME !!!*/
Joe Hershberger68c76a32015-04-08 01:41:10 -0500921 nfs_our_port = 1000;
wdenkcbd8a352004-02-24 02:00:03 +0000922
923 /* zero out server ether in case the server ip has changed */
Joe Hershberger0adb5b72015-04-08 01:41:04 -0500924 memset(net_server_ethaddr, 0, 6);
wdenkcbd8a352004-02-24 02:00:03 +0000925
Joe Hershberger68c76a32015-04-08 01:41:10 -0500926 nfs_send();
wdenkcbd8a352004-02-24 02:00:03 +0000927}