source: MondoRescue/trunk/mindi-busybox/util-linux/nfsmount.c@ 929

Last change on this file since 929 was 821, checked in by Bruno Cornec, 18 years ago

Addition of busybox 1.2.1 as a mindi-busybox new package
This should avoid delivering binary files in mindi not built there (Fedora and Debian are quite serious about that)
File size: 24.5 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * nfsmount.c -- Linux NFS mount
4 * Copyright (C) 1993 Rick Sladkey <jrs@world.std.com>
5 *
6 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
7 *
8 * Wed Feb 8 12:51:48 1995, biro@yggdrasil.com (Ross Biro): allow all port
9 * numbers to be specified on the command line.
10 *
11 * Fri, 8 Mar 1996 18:01:39, Swen Thuemmler <swen@uni-paderborn.de>:
12 * Omit the call to connect() for Linux version 1.3.11 or later.
13 *
14 * Wed Oct 1 23:55:28 1997: Dick Streefland <dick_streefland@tasking.com>
15 * Implemented the "bg", "fg" and "retry" mount options for NFS.
16 *
17 * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@misiek.eu.org>
18 * - added Native Language Support
19 *
20 * Modified by Olaf Kirch and Trond Myklebust for new NFS code,
21 * plus NFSv3 stuff.
22 */
23
24/*
25 * nfsmount.c,v 1.1.1.1 1993/11/18 08:40:51 jrs Exp
26 */
27
28#include "busybox.h"
29#include <unistd.h>
30#include <string.h>
31#include <errno.h>
32#include <time.h>
33#include <sys/utsname.h>
34#undef TRUE
35#undef FALSE
36#include <rpc/rpc.h>
37#include <rpc/pmap_prot.h>
38#include <rpc/pmap_clnt.h>
39#include "nfsmount.h"
40
41/* This is just a warning of a common mistake. Possibly this should be a
42 * uclibc faq entry rather than in busybox... */
43#if ENABLE_FEATURE_MOUNT_NFS && defined(__UCLIBC__) && ! defined(__UCLIBC_HAS_RPC__)
44#error "You need to build uClibc with UCLIBC_HAS_RPC for NFS support."
45#endif
46
47
48/*
49 * NFS stats. The good thing with these values is that NFSv3 errors are
50 * a superset of NFSv2 errors (with the exception of NFSERR_WFLUSH which
51 * no-one uses anyway), so we can happily mix code as long as we make sure
52 * no NFSv3 errors are returned to NFSv2 clients.
53 * Error codes that have a `--' in the v2 column are not part of the
54 * standard, but seem to be widely used nevertheless.
55 */
56enum nfs_stat {
57 NFS_OK = 0, /* v2 v3 */
58 NFSERR_PERM = 1, /* v2 v3 */
59 NFSERR_NOENT = 2, /* v2 v3 */
60 NFSERR_IO = 5, /* v2 v3 */
61 NFSERR_NXIO = 6, /* v2 v3 */
62 NFSERR_EAGAIN = 11, /* v2 v3 */
63 NFSERR_ACCES = 13, /* v2 v3 */
64 NFSERR_EXIST = 17, /* v2 v3 */
65 NFSERR_XDEV = 18, /* v3 */
66 NFSERR_NODEV = 19, /* v2 v3 */
67 NFSERR_NOTDIR = 20, /* v2 v3 */
68 NFSERR_ISDIR = 21, /* v2 v3 */
69 NFSERR_INVAL = 22, /* v2 v3 that Sun forgot */
70 NFSERR_FBIG = 27, /* v2 v3 */
71 NFSERR_NOSPC = 28, /* v2 v3 */
72 NFSERR_ROFS = 30, /* v2 v3 */
73 NFSERR_MLINK = 31, /* v3 */
74 NFSERR_OPNOTSUPP = 45, /* v2 v3 */
75 NFSERR_NAMETOOLONG = 63, /* v2 v3 */
76 NFSERR_NOTEMPTY = 66, /* v2 v3 */
77 NFSERR_DQUOT = 69, /* v2 v3 */
78 NFSERR_STALE = 70, /* v2 v3 */
79 NFSERR_REMOTE = 71, /* v2 v3 */
80 NFSERR_WFLUSH = 99, /* v2 */
81 NFSERR_BADHANDLE = 10001, /* v3 */
82 NFSERR_NOT_SYNC = 10002, /* v3 */
83 NFSERR_BAD_COOKIE = 10003, /* v3 */
84 NFSERR_NOTSUPP = 10004, /* v3 */
85 NFSERR_TOOSMALL = 10005, /* v3 */
86 NFSERR_SERVERFAULT = 10006, /* v3 */
87 NFSERR_BADTYPE = 10007, /* v3 */
88 NFSERR_JUKEBOX = 10008 /* v3 */
89};
90
91#define NFS_PROGRAM 100003
92
93
94enum {
95#ifndef NFS_FHSIZE
96 NFS_FHSIZE = 32,
97#endif
98#ifndef NFS_PORT
99 NFS_PORT = 2049
100#endif
101};
102
103/* Disable the nls stuff */
104# undef bindtextdomain
105# define bindtextdomain(Domain, Directory) /* empty */
106# undef textdomain
107# define textdomain(Domain) /* empty */
108
109enum {
110 S_QUOTA = 128, /* Quota initialized for file/directory/symlink */
111};
112
113
114/*
115 * We want to be able to compile mount on old kernels in such a way
116 * that the binary will work well on more recent kernels.
117 * Thus, if necessary we teach nfsmount.c the structure of new fields
118 * that will come later.
119 *
120 * Moreover, the new kernel includes conflict with glibc includes
121 * so it is easiest to ignore the kernel altogether (at compile time).
122 */
123
124/* NOTE: Do not make this into a 'static const int' because the pre-processor
125 * needs to test this value in some #if statements. */
126#define NFS_MOUNT_VERSION 4
127
128struct nfs2_fh {
129 char data[32];
130};
131struct nfs3_fh {
132 unsigned short size;
133 unsigned char data[64];
134};
135
136struct nfs_mount_data {
137 int version; /* 1 */
138 int fd; /* 1 */
139 struct nfs2_fh old_root; /* 1 */
140 int flags; /* 1 */
141 int rsize; /* 1 */
142 int wsize; /* 1 */
143 int timeo; /* 1 */
144 int retrans; /* 1 */
145 int acregmin; /* 1 */
146 int acregmax; /* 1 */
147 int acdirmin; /* 1 */
148 int acdirmax; /* 1 */
149 struct sockaddr_in addr; /* 1 */
150 char hostname[256]; /* 1 */
151 int namlen; /* 2 */
152 unsigned int bsize; /* 3 */
153 struct nfs3_fh root; /* 4 */
154};
155
156/* bits in the flags field */
157enum {
158 NFS_MOUNT_SOFT = 0x0001, /* 1 */
159 NFS_MOUNT_INTR = 0x0002, /* 1 */
160 NFS_MOUNT_SECURE = 0x0004, /* 1 */
161 NFS_MOUNT_POSIX = 0x0008, /* 1 */
162 NFS_MOUNT_NOCTO = 0x0010, /* 1 */
163 NFS_MOUNT_NOAC = 0x0020, /* 1 */
164 NFS_MOUNT_TCP = 0x0040, /* 2 */
165 NFS_MOUNT_VER3 = 0x0080, /* 3 */
166 NFS_MOUNT_KERBEROS = 0x0100, /* 3 */
167 NFS_MOUNT_NONLM = 0x0200 /* 3 */
168};
169
170
171#define UTIL_LINUX_VERSION "2.10m"
172#define util_linux_version "util-linux-2.10m"
173
174#define HAVE_inet_aton
175#define HAVE_scsi_h
176#define HAVE_blkpg_h
177#define HAVE_kd_h
178#define HAVE_termcap
179#define HAVE_locale_h
180#define HAVE_libintl_h
181#define ENABLE_NLS
182#define HAVE_langinfo_h
183#define HAVE_progname
184#define HAVE_openpty
185#define HAVE_nanosleep
186#define HAVE_personality
187#define HAVE_tm_gmtoff
188
189static char *nfs_strerror(int status);
190
191#define MAX_NFSPROT ((nfs_mount_version >= 4) ? 3 : 2)
192
193enum {
194 EX_FAIL = 32, /* mount failure */
195 EX_BG = 256 /* retry in background (internal only) */
196};
197
198
199/*
200 * nfs_mount_version according to the sources seen at compile time.
201 */
202static int nfs_mount_version;
203
204/*
205 * Unfortunately, the kernel prints annoying console messages
206 * in case of an unexpected nfs mount version (instead of
207 * just returning some error). Therefore we'll have to try
208 * and figure out what version the kernel expects.
209 *
210 * Variables:
211 * KERNEL_NFS_MOUNT_VERSION: kernel sources at compile time
212 * NFS_MOUNT_VERSION: these nfsmount sources at compile time
213 * nfs_mount_version: version this source and running kernel can handle
214 */
215static void
216find_kernel_nfs_mount_version(void)
217{
218 static int kernel_version = 0;
219
220 if (kernel_version)
221 return;
222
223 nfs_mount_version = NFS_MOUNT_VERSION; /* default */
224
225 kernel_version = get_linux_version_code();
226 if (kernel_version) {
227 if (kernel_version < KERNEL_VERSION(2,1,32))
228 nfs_mount_version = 1;
229 else if (kernel_version < KERNEL_VERSION(2,2,18) ||
230 (kernel_version >= KERNEL_VERSION(2,3,0) &&
231 kernel_version < KERNEL_VERSION(2,3,99)))
232 nfs_mount_version = 3;
233 else
234 nfs_mount_version = 4; /* since 2.3.99pre4 */
235 }
236 if (nfs_mount_version > NFS_MOUNT_VERSION)
237 nfs_mount_version = NFS_MOUNT_VERSION;
238}
239
240static struct pmap *
241get_mountport(struct sockaddr_in *server_addr,
242 long unsigned prog,
243 long unsigned version,
244 long unsigned proto,
245 long unsigned port)
246{
247struct pmaplist *pmap;
248static struct pmap p = {0, 0, 0, 0};
249
250server_addr->sin_port = PMAPPORT;
251pmap = pmap_getmaps(server_addr);
252
253if (version > MAX_NFSPROT)
254 version = MAX_NFSPROT;
255if (!prog)
256 prog = MOUNTPROG;
257p.pm_prog = prog;
258p.pm_vers = version;
259p.pm_prot = proto;
260p.pm_port = port;
261
262while (pmap) {
263 if (pmap->pml_map.pm_prog != prog)
264 goto next;
265 if (!version && p.pm_vers > pmap->pml_map.pm_vers)
266 goto next;
267 if (version > 2 && pmap->pml_map.pm_vers != version)
268 goto next;
269 if (version && version <= 2 && pmap->pml_map.pm_vers > 2)
270 goto next;
271 if (pmap->pml_map.pm_vers > MAX_NFSPROT ||
272 (proto && p.pm_prot && pmap->pml_map.pm_prot != proto) ||
273 (port && pmap->pml_map.pm_port != port))
274 goto next;
275 memcpy(&p, &pmap->pml_map, sizeof(p));
276next:
277 pmap = pmap->pml_next;
278}
279if (!p.pm_vers)
280 p.pm_vers = MOUNTVERS;
281if (!p.pm_port)
282 p.pm_port = MOUNTPORT;
283if (!p.pm_prot)
284 p.pm_prot = IPPROTO_TCP;
285return &p;
286}
287
288int nfsmount(const char *spec, const char *node, int *flags,
289 char **mount_opts, int running_bg)
290{
291 static char *prev_bg_host;
292 char hostdir[1024];
293 CLIENT *mclient;
294 char *hostname;
295 char *pathname;
296 char *old_opts;
297 char *mounthost=NULL;
298 char new_opts[1024];
299 struct timeval total_timeout;
300 enum clnt_stat clnt_stat;
301 struct nfs_mount_data data;
302 char *opt, *opteq;
303 int val;
304 struct hostent *hp;
305 struct sockaddr_in server_addr;
306 struct sockaddr_in mount_server_addr;
307 struct pmap* pm_mnt;
308 int msock, fsock;
309 struct timeval retry_timeout;
310 union {
311 struct fhstatus nfsv2;
312 struct mountres3 nfsv3;
313 } status;
314 struct stat statbuf;
315 char *s;
316 int port;
317 int mountport;
318 int proto;
319 int bg;
320 int soft;
321 int intr;
322 int posix;
323 int nocto;
324 int noac;
325 int nolock;
326 int retry;
327 int tcp;
328 int mountprog;
329 int mountvers;
330 int nfsprog;
331 int nfsvers;
332 int retval;
333 time_t t;
334 time_t prevt;
335 time_t timeout;
336
337 find_kernel_nfs_mount_version();
338
339 retval = EX_FAIL;
340 msock = fsock = -1;
341 mclient = NULL;
342 if (strlen(spec) >= sizeof(hostdir)) {
343 bb_error_msg("excessively long host:dir argument");
344 goto fail;
345 }
346 strcpy(hostdir, spec);
347 if ((s = strchr(hostdir, ':'))) {
348 hostname = hostdir;
349 pathname = s + 1;
350 *s = '\0';
351 /* Ignore all but first hostname in replicated mounts
352 until they can be fully supported. (mack@sgi.com) */
353 if ((s = strchr(hostdir, ','))) {
354 *s = '\0';
355 bb_error_msg("warning: multiple hostnames not supported");
356 }
357 } else {
358 bb_error_msg("directory to mount not in host:dir format");
359 goto fail;
360 }
361
362 server_addr.sin_family = AF_INET;
363#ifdef HAVE_inet_aton
364 if (!inet_aton(hostname, &server_addr.sin_addr))
365#endif
366 {
367 if ((hp = gethostbyname(hostname)) == NULL) {
368 bb_herror_msg("%s", hostname);
369 goto fail;
370 } else {
371 if (hp->h_length > sizeof(struct in_addr)) {
372 bb_error_msg("got bad hp->h_length");
373 hp->h_length = sizeof(struct in_addr);
374 }
375 memcpy(&server_addr.sin_addr,
376 hp->h_addr, hp->h_length);
377 }
378 }
379
380 memcpy (&mount_server_addr, &server_addr, sizeof (mount_server_addr));
381
382 /* add IP address to mtab options for use when unmounting */
383
384 s = inet_ntoa(server_addr.sin_addr);
385 old_opts = *mount_opts;
386 if (!old_opts)
387 old_opts = "";
388 if (strlen(old_opts) + strlen(s) + 10 >= sizeof(new_opts)) {
389 bb_error_msg("excessively long option argument");
390 goto fail;
391 }
392 sprintf(new_opts, "%s%saddr=%s",
393 old_opts, *old_opts ? "," : "", s);
394 *mount_opts = bb_xstrdup(new_opts);
395
396 /* Set default options.
397 * rsize/wsize (and bsize, for ver >= 3) are left 0 in order to
398 * let the kernel decide.
399 * timeo is filled in after we know whether it'll be TCP or UDP. */
400 memset(&data, 0, sizeof(data));
401 data.retrans = 3;
402 data.acregmin = 3;
403 data.acregmax = 60;
404 data.acdirmin = 30;
405 data.acdirmax = 60;
406#if NFS_MOUNT_VERSION >= 2
407 data.namlen = NAME_MAX;
408#endif
409
410 bg = 0;
411 soft = 0;
412 intr = 0;
413 posix = 0;
414 nocto = 0;
415 nolock = 0;
416 noac = 0;
417 retry = 10000; /* 10000 minutes ~ 1 week */
418 tcp = 0;
419
420 mountprog = MOUNTPROG;
421 mountvers = 0;
422 port = 0;
423 mountport = 0;
424 nfsprog = NFS_PROGRAM;
425 nfsvers = 0;
426
427 /* parse options */
428
429 for (opt = strtok(old_opts, ","); opt; opt = strtok(NULL, ",")) {
430 if ((opteq = strchr(opt, '='))) {
431 val = atoi(opteq + 1);
432 *opteq = '\0';
433 if (!strcmp(opt, "rsize"))
434 data.rsize = val;
435 else if (!strcmp(opt, "wsize"))
436 data.wsize = val;
437 else if (!strcmp(opt, "timeo"))
438 data.timeo = val;
439 else if (!strcmp(opt, "retrans"))
440 data.retrans = val;
441 else if (!strcmp(opt, "acregmin"))
442 data.acregmin = val;
443 else if (!strcmp(opt, "acregmax"))
444 data.acregmax = val;
445 else if (!strcmp(opt, "acdirmin"))
446 data.acdirmin = val;
447 else if (!strcmp(opt, "acdirmax"))
448 data.acdirmax = val;
449 else if (!strcmp(opt, "actimeo")) {
450 data.acregmin = val;
451 data.acregmax = val;
452 data.acdirmin = val;
453 data.acdirmax = val;
454 }
455 else if (!strcmp(opt, "retry"))
456 retry = val;
457 else if (!strcmp(opt, "port"))
458 port = val;
459 else if (!strcmp(opt, "mountport"))
460 mountport = val;
461 else if (!strcmp(opt, "mounthost"))
462 mounthost=bb_xstrndup(opteq+1,
463 strcspn(opteq+1," \t\n\r,"));
464 else if (!strcmp(opt, "mountprog"))
465 mountprog = val;
466 else if (!strcmp(opt, "mountvers"))
467 mountvers = val;
468 else if (!strcmp(opt, "nfsprog"))
469 nfsprog = val;
470 else if (!strcmp(opt, "nfsvers") ||
471 !strcmp(opt, "vers"))
472 nfsvers = val;
473 else if (!strcmp(opt, "proto")) {
474 if (!strncmp(opteq+1, "tcp", 3))
475 tcp = 1;
476 else if (!strncmp(opteq+1, "udp", 3))
477 tcp = 0;
478 else
479 printf("Warning: Unrecognized proto= option.\n");
480 } else if (!strcmp(opt, "namlen")) {
481#if NFS_MOUNT_VERSION >= 2
482 if (nfs_mount_version >= 2)
483 data.namlen = val;
484 else
485#endif
486 printf("Warning: Option namlen is not supported.\n");
487 } else if (!strcmp(opt, "addr"))
488 /* ignore */;
489 else {
490 printf("unknown nfs mount parameter: %s=%d\n", opt, val);
491 goto fail;
492 }
493 }
494 else {
495 val = 1;
496 if (!strncmp(opt, "no", 2)) {
497 val = 0;
498 opt += 2;
499 }
500 if (!strcmp(opt, "bg"))
501 bg = val;
502 else if (!strcmp(opt, "fg"))
503 bg = !val;
504 else if (!strcmp(opt, "soft"))
505 soft = val;
506 else if (!strcmp(opt, "hard"))
507 soft = !val;
508 else if (!strcmp(opt, "intr"))
509 intr = val;
510 else if (!strcmp(opt, "posix"))
511 posix = val;
512 else if (!strcmp(opt, "cto"))
513 nocto = !val;
514 else if (!strcmp(opt, "ac"))
515 noac = !val;
516 else if (!strcmp(opt, "tcp"))
517 tcp = val;
518 else if (!strcmp(opt, "udp"))
519 tcp = !val;
520 else if (!strcmp(opt, "lock")) {
521 if (nfs_mount_version >= 3)
522 nolock = !val;
523 else
524 printf("Warning: option nolock is not supported.\n");
525 } else {
526 printf("unknown nfs mount option: %s%s\n", val ? "" : "no", opt);
527 goto fail;
528 }
529 }
530 }
531 proto = (tcp) ? IPPROTO_TCP : IPPROTO_UDP;
532
533 data.flags = (soft ? NFS_MOUNT_SOFT : 0)
534 | (intr ? NFS_MOUNT_INTR : 0)
535 | (posix ? NFS_MOUNT_POSIX : 0)
536 | (nocto ? NFS_MOUNT_NOCTO : 0)
537 | (noac ? NFS_MOUNT_NOAC : 0);
538#if NFS_MOUNT_VERSION >= 2
539 if (nfs_mount_version >= 2)
540 data.flags |= (tcp ? NFS_MOUNT_TCP : 0);
541#endif
542#if NFS_MOUNT_VERSION >= 3
543 if (nfs_mount_version >= 3)
544 data.flags |= (nolock ? NFS_MOUNT_NONLM : 0);
545#endif
546 if (nfsvers > MAX_NFSPROT || mountvers > MAX_NFSPROT) {
547 bb_error_msg("NFSv%d not supported!", nfsvers);
548 return 1;
549 }
550 if (nfsvers && !mountvers)
551 mountvers = (nfsvers < 3) ? 1 : nfsvers;
552 if (nfsvers && nfsvers < mountvers) {
553 mountvers = nfsvers;
554 }
555
556 /* Adjust options if none specified */
557 if (!data.timeo)
558 data.timeo = tcp ? 70 : 7;
559
560#ifdef NFS_MOUNT_DEBUG
561 printf("rsize = %d, wsize = %d, timeo = %d, retrans = %d\n",
562 data.rsize, data.wsize, data.timeo, data.retrans);
563 printf("acreg (min, max) = (%d, %d), acdir (min, max) = (%d, %d)\n",
564 data.acregmin, data.acregmax, data.acdirmin, data.acdirmax);
565 printf("port = %d, bg = %d, retry = %d, flags = %.8x\n",
566 port, bg, retry, data.flags);
567 printf("mountprog = %d, mountvers = %d, nfsprog = %d, nfsvers = %d\n",
568 mountprog, mountvers, nfsprog, nfsvers);
569 printf("soft = %d, intr = %d, posix = %d, nocto = %d, noac = %d\n",
570 (data.flags & NFS_MOUNT_SOFT) != 0,
571 (data.flags & NFS_MOUNT_INTR) != 0,
572 (data.flags & NFS_MOUNT_POSIX) != 0,
573 (data.flags & NFS_MOUNT_NOCTO) != 0,
574 (data.flags & NFS_MOUNT_NOAC) != 0);
575#if NFS_MOUNT_VERSION >= 2
576 printf("tcp = %d\n",
577 (data.flags & NFS_MOUNT_TCP) != 0);
578#endif
579#endif
580
581 data.version = nfs_mount_version;
582
583 if (*flags & MS_REMOUNT)
584 goto copy_data_and_return;
585
586 /*
587 * If the previous mount operation on the same host was
588 * backgrounded, and the "bg" for this mount is also set,
589 * give up immediately, to avoid the initial timeout.
590 */
591 if (bg && !running_bg &&
592 prev_bg_host && strcmp(hostname, prev_bg_host) == 0) {
593 if (retry > 0)
594 retval = EX_BG;
595 return retval;
596 }
597
598 /* create mount daemon client */
599 /* See if the nfs host = mount host. */
600 if (mounthost) {
601 if (mounthost[0] >= '0' && mounthost[0] <= '9') {
602 mount_server_addr.sin_family = AF_INET;
603 mount_server_addr.sin_addr.s_addr = inet_addr(hostname);
604 } else {
605 if ((hp = gethostbyname(mounthost)) == NULL) {
606 bb_herror_msg("%s", mounthost);
607 goto fail;
608 } else {
609 if (hp->h_length > sizeof(struct in_addr)) {
610 bb_error_msg("got bad hp->h_length?");
611 hp->h_length = sizeof(struct in_addr);
612 }
613 mount_server_addr.sin_family = AF_INET;
614 memcpy(&mount_server_addr.sin_addr,
615 hp->h_addr, hp->h_length);
616 }
617 }
618 }
619
620 /*
621 * The following loop implements the mount retries. On the first
622 * call, "running_bg" is 0. When the mount times out, and the
623 * "bg" option is set, the exit status EX_BG will be returned.
624 * For a backgrounded mount, there will be a second call by the
625 * child process with "running_bg" set to 1.
626 *
627 * The case where the mount point is not present and the "bg"
628 * option is set, is treated as a timeout. This is done to
629 * support nested mounts.
630 *
631 * The "retry" count specified by the user is the number of
632 * minutes to retry before giving up.
633 *
634 * Only the first error message will be displayed.
635 */
636 retry_timeout.tv_sec = 3;
637 retry_timeout.tv_usec = 0;
638 total_timeout.tv_sec = 20;
639 total_timeout.tv_usec = 0;
640 timeout = time(NULL) + 60 * retry;
641 prevt = 0;
642 t = 30;
643 val = 1;
644 for (;;) {
645 if (bg && stat(node, &statbuf) == -1) {
646 if (running_bg) {
647 sleep(val); /* 1, 2, 4, 8, 16, 30, ... */
648 val *= 2;
649 if (val > 30)
650 val = 30;
651 }
652 } else {
653 /* be careful not to use too many CPU cycles */
654 if (t - prevt < 30)
655 sleep(30);
656
657 pm_mnt = get_mountport(&mount_server_addr,
658 mountprog,
659 mountvers,
660 proto,
661 mountport);
662
663 /* contact the mount daemon via TCP */
664 mount_server_addr.sin_port = htons(pm_mnt->pm_port);
665 msock = RPC_ANYSOCK;
666
667 switch (pm_mnt->pm_prot) {
668 case IPPROTO_UDP:
669 mclient = clntudp_create(&mount_server_addr,
670 pm_mnt->pm_prog,
671 pm_mnt->pm_vers,
672 retry_timeout,
673 &msock);
674 if (mclient)
675 break;
676 mount_server_addr.sin_port = htons(pm_mnt->pm_port);
677 msock = RPC_ANYSOCK;
678 case IPPROTO_TCP:
679 mclient = clnttcp_create(&mount_server_addr,
680 pm_mnt->pm_prog,
681 pm_mnt->pm_vers,
682 &msock, 0, 0);
683 break;
684 default:
685 mclient = 0;
686 }
687 if (mclient) {
688 /* try to mount hostname:pathname */
689 mclient->cl_auth = authunix_create_default();
690
691 /* make pointers in xdr_mountres3 NULL so
692 * that xdr_array allocates memory for us
693 */
694 memset(&status, 0, sizeof(status));
695
696 if (pm_mnt->pm_vers == 3)
697 clnt_stat = clnt_call(mclient, MOUNTPROC3_MNT,
698 (xdrproc_t) xdr_dirpath,
699 (caddr_t) &pathname,
700 (xdrproc_t) xdr_mountres3,
701 (caddr_t) &status,
702 total_timeout);
703 else
704 clnt_stat = clnt_call(mclient, MOUNTPROC_MNT,
705 (xdrproc_t) xdr_dirpath,
706 (caddr_t) &pathname,
707 (xdrproc_t) xdr_fhstatus,
708 (caddr_t) &status,
709 total_timeout);
710
711 if (clnt_stat == RPC_SUCCESS)
712 break; /* we're done */
713 if (errno != ECONNREFUSED) {
714 clnt_perror(mclient, "mount");
715 goto fail; /* don't retry */
716 }
717 if (!running_bg && prevt == 0)
718 clnt_perror(mclient, "mount");
719 auth_destroy(mclient->cl_auth);
720 clnt_destroy(mclient);
721 mclient = 0;
722 close(msock);
723 } else {
724 if (!running_bg && prevt == 0)
725 clnt_pcreateerror("mount");
726 }
727 prevt = t;
728 }
729 if (!bg)
730 goto fail;
731 if (!running_bg) {
732 prev_bg_host = bb_xstrdup(hostname);
733 if (retry > 0)
734 retval = EX_BG;
735 goto fail;
736 }
737 t = time(NULL);
738 if (t >= timeout)
739 goto fail;
740 }
741 nfsvers = (pm_mnt->pm_vers < 2) ? 2 : pm_mnt->pm_vers;
742
743 if (nfsvers == 2) {
744 if (status.nfsv2.fhs_status != 0) {
745 bb_error_msg("%s:%s failed, reason given by server: %s",
746 hostname, pathname,
747 nfs_strerror(status.nfsv2.fhs_status));
748 goto fail;
749 }
750 memcpy(data.root.data,
751 (char *) status.nfsv2.fhstatus_u.fhs_fhandle,
752 NFS_FHSIZE);
753#if NFS_MOUNT_VERSION >= 4
754 data.root.size = NFS_FHSIZE;
755 memcpy(data.old_root.data,
756 (char *) status.nfsv2.fhstatus_u.fhs_fhandle,
757 NFS_FHSIZE);
758#endif
759 } else {
760#if NFS_MOUNT_VERSION >= 4
761 fhandle3 *my_fhandle;
762 if (status.nfsv3.fhs_status != 0) {
763 bb_error_msg("%s:%s failed, reason given by server: %s",
764 hostname, pathname,
765 nfs_strerror(status.nfsv3.fhs_status));
766 goto fail;
767 }
768 my_fhandle = &status.nfsv3.mountres3_u.mountinfo.fhandle;
769 memset(data.old_root.data, 0, NFS_FHSIZE);
770 memset(&data.root, 0, sizeof(data.root));
771 data.root.size = my_fhandle->fhandle3_len;
772 memcpy(data.root.data,
773 (char *) my_fhandle->fhandle3_val,
774 my_fhandle->fhandle3_len);
775
776 data.flags |= NFS_MOUNT_VER3;
777#endif
778 }
779
780 /* create nfs socket for kernel */
781
782 if (tcp) {
783 if (nfs_mount_version < 3) {
784 printf("NFS over TCP is not supported.\n");
785 goto fail;
786 }
787 fsock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
788 } else
789 fsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
790 if (fsock < 0) {
791 perror("nfs socket");
792 goto fail;
793 }
794 if (bindresvport(fsock, 0) < 0) {
795 perror("nfs bindresvport");
796 goto fail;
797 }
798 if (port == 0) {
799 server_addr.sin_port = PMAPPORT;
800 port = pmap_getport(&server_addr, nfsprog, nfsvers,
801 tcp ? IPPROTO_TCP : IPPROTO_UDP);
802 if (port == 0)
803 port = NFS_PORT;
804#ifdef NFS_MOUNT_DEBUG
805 else
806 printf("used portmapper to find NFS port\n");
807#endif
808 }
809#ifdef NFS_MOUNT_DEBUG
810 printf("using port %d for nfs daemon\n", port);
811#endif
812 server_addr.sin_port = htons(port);
813 /*
814 * connect() the socket for kernels 1.3.10 and below only,
815 * to avoid problems with multihomed hosts.
816 * --Swen
817 */
818 if (get_linux_version_code() <= KERNEL_VERSION(2,3,10)
819 && connect(fsock, (struct sockaddr *) &server_addr,
820 sizeof (server_addr)) < 0) {
821 perror("nfs connect");
822 goto fail;
823 }
824
825 /* prepare data structure for kernel */
826
827 data.fd = fsock;
828 memcpy((char *) &data.addr, (char *) &server_addr, sizeof(data.addr));
829 strncpy(data.hostname, hostname, sizeof(data.hostname));
830
831 /* clean up */
832
833 auth_destroy(mclient->cl_auth);
834 clnt_destroy(mclient);
835 close(msock);
836copy_data_and_return:
837 *mount_opts = xrealloc(*mount_opts, sizeof(data));
838 memcpy(*mount_opts, &data, sizeof(data));
839 return 0;
840
841 /* abort */
842
843fail:
844 if (msock != -1) {
845 if (mclient) {
846 auth_destroy(mclient->cl_auth);
847 clnt_destroy(mclient);
848 }
849 close(msock);
850 }
851 if (fsock != -1)
852 close(fsock);
853 return retval;
854}
855
856/*
857 * We need to translate between nfs status return values and
858 * the local errno values which may not be the same.
859 *
860 * Andreas Schwab <schwab@LS5.informatik.uni-dortmund.de>: change errno:
861 * "after #include <errno.h> the symbol errno is reserved for any use,
862 * it cannot even be used as a struct tag or field name".
863 */
864
865#ifndef EDQUOT
866#define EDQUOT ENOSPC
867#endif
868
869static const struct {
870 enum nfs_stat stat;
871 int errnum;
872} nfs_errtbl[] = {
873 { NFS_OK, 0 },
874 { NFSERR_PERM, EPERM },
875 { NFSERR_NOENT, ENOENT },
876 { NFSERR_IO, EIO },
877 { NFSERR_NXIO, ENXIO },
878 { NFSERR_ACCES, EACCES },
879 { NFSERR_EXIST, EEXIST },
880 { NFSERR_NODEV, ENODEV },
881 { NFSERR_NOTDIR, ENOTDIR },
882 { NFSERR_ISDIR, EISDIR },
883#ifdef NFSERR_INVAL
884 { NFSERR_INVAL, EINVAL }, /* that Sun forgot */
885#endif
886 { NFSERR_FBIG, EFBIG },
887 { NFSERR_NOSPC, ENOSPC },
888 { NFSERR_ROFS, EROFS },
889 { NFSERR_NAMETOOLONG, ENAMETOOLONG },
890 { NFSERR_NOTEMPTY, ENOTEMPTY },
891 { NFSERR_DQUOT, EDQUOT },
892 { NFSERR_STALE, ESTALE },
893#ifdef EWFLUSH
894 { NFSERR_WFLUSH, EWFLUSH },
895#endif
896 /* Throw in some NFSv3 values for even more fun (HP returns these) */
897 { 71, EREMOTE },
898
899 { -1, EIO }
900};
901
902static char *nfs_strerror(int status)
903{
904 int i;
905 static char buf[256];
906
907 for (i = 0; nfs_errtbl[i].stat != -1; i++) {
908 if (nfs_errtbl[i].stat == status)
909 return strerror(nfs_errtbl[i].errnum);
910 }
911 sprintf(buf, "unknown nfs status return value: %d", status);
912 return buf;
913}
914
915static bool_t
916xdr_fhandle (XDR *xdrs, fhandle objp)
917{
918 if (!xdr_opaque (xdrs, objp, FHSIZE))
919 return FALSE;
920 return TRUE;
921}
922
923bool_t
924xdr_fhstatus (XDR *xdrs, fhstatus *objp)
925{
926 if (!xdr_u_int (xdrs, &objp->fhs_status))
927 return FALSE;
928 switch (objp->fhs_status) {
929 case 0:
930 if (!xdr_fhandle (xdrs, objp->fhstatus_u.fhs_fhandle))
931 return FALSE;
932 break;
933 default:
934 break;
935 }
936 return TRUE;
937}
938
939bool_t
940xdr_dirpath (XDR *xdrs, dirpath *objp)
941{
942 if (!xdr_string (xdrs, objp, MNTPATHLEN))
943 return FALSE;
944 return TRUE;
945}
946
947bool_t
948xdr_fhandle3 (XDR *xdrs, fhandle3 *objp)
949{
950 if (!xdr_bytes (xdrs, (char **)&objp->fhandle3_val, (unsigned int *) &objp->fhandle3_len, FHSIZE3))
951 return FALSE;
952 return TRUE;
953}
954
955bool_t
956xdr_mountres3_ok (XDR *xdrs, mountres3_ok *objp)
957{
958 if (!xdr_fhandle3 (xdrs, &objp->fhandle))
959 return FALSE;
960 if (!xdr_array (xdrs, &(objp->auth_flavours.auth_flavours_val), &(objp->auth_flavours.auth_flavours_len), ~0,
961 sizeof (int), (xdrproc_t) xdr_int))
962 return FALSE;
963 return TRUE;
964}
965
966bool_t
967xdr_mountstat3 (XDR *xdrs, mountstat3 *objp)
968{
969 if (!xdr_enum (xdrs, (enum_t *) objp))
970 return FALSE;
971 return TRUE;
972}
973
974bool_t
975xdr_mountres3 (XDR *xdrs, mountres3 *objp)
976{
977 if (!xdr_mountstat3 (xdrs, &objp->fhs_status))
978 return FALSE;
979 switch (objp->fhs_status) {
980 case MNT_OK:
981 if (!xdr_mountres3_ok (xdrs, &objp->mountres3_u.mountinfo))
982 return FALSE;
983 break;
984 default:
985 break;
986 }
987 return TRUE;
988}
989
Note: See TracBrowser for help on using the repository browser.