X-Git-Url: https://git.decadent.org.uk/gitweb/?p=nfs-utils.git;a=blobdiff_plain;f=utils%2Fmount%2Fnetwork.c;h=a5b0b71435303b94068c6bc86c5427e7d9c71e64;hp=565330281c940f94a5ab03bd7c945778934d1398;hb=56a4a153c8559efe6e090e99eaf190d530299de2;hpb=897f581874255d363e00ef94534f6fced8dd2ba2 diff --git a/utils/mount/network.c b/utils/mount/network.c index 5653302..a5b0b71 100644 --- a/utils/mount/network.c +++ b/utils/mount/network.c @@ -53,10 +53,48 @@ #define NFS_PORT 2049 #endif +#if SIZEOF_SOCKLEN_T - 0 == 0 +#define socklen_t unsigned int +#endif + extern int nfs_mount_data_version; extern char *progname; extern int verbose; +static const unsigned long nfs_to_mnt[] = { + 0, + 0, + 1, + 3, +}; + +static const unsigned long mnt_to_nfs[] = { + 0, + 2, + 2, + 3, +}; + +/* + * Map an NFS version into the corresponding Mountd version + */ +unsigned long nfsvers_to_mnt(const unsigned long vers) +{ + if (vers <= 3) + return nfs_to_mnt[vers]; + return 0; +} + +/* + * Map a Mountd version into the corresponding NFS version + */ +static unsigned long mntvers_to_nfs(const unsigned long vers) +{ + if (vers <= 3) + return mnt_to_nfs[vers]; + return 0; +} + static const unsigned int probe_udp_only[] = { IPPROTO_UDP, 0, @@ -121,18 +159,22 @@ int nfs_gethostbyname(const char *hostname, struct sockaddr_in *saddr) } /* - * getport() is very similar to pmap_getport() with - * the exception this version uses a non-reserve ports - * instead of reserve ports since reserve ports - * are not needed for pmap requests. + * getport() is very similar to pmap_getport() with the exception that + * this version tries to use an ephemeral port, since reserved ports are + * not needed for GETPORT queries. This conserves the very limited + * reserved port space, which helps reduce failed socket binds + * during mount storms. + * + * A side effect of calling this function is that rpccreateerr is set. */ -unsigned short getport(struct sockaddr_in *saddr, unsigned long prog, - unsigned long vers, unsigned int prot) +static unsigned short getport(struct sockaddr_in *saddr, + unsigned long program, + unsigned long version, + unsigned int proto) { unsigned short port = 0; int socket; CLIENT *clnt = NULL; - struct pmap parms; enum clnt_stat stat; saddr->sin_port = htons(PMAPPORT); @@ -153,25 +195,30 @@ unsigned short getport(struct sockaddr_in *saddr, unsigned long prog, return 0; } - switch (prot) { + switch (proto) { case IPPROTO_UDP: clnt = clntudp_bufcreate(saddr, - PMAPPROG, PMAPVERS, TIMEOUT, &socket, - UDPMSGSIZE, UDPMSGSIZE); + PMAPPROG, PMAPVERS, + RETRY_TIMEOUT, &socket, + RPCSMALLMSGSIZE, + RPCSMALLMSGSIZE); break; case IPPROTO_TCP: - clnt = clnttcp_create(saddr, - PMAPPROG, PMAPVERS, &socket, 50, 500); + clnt = clnttcp_create(saddr, PMAPPROG, PMAPVERS, &socket, + RPCSMALLMSGSIZE, RPCSMALLMSGSIZE); break; } if (clnt != NULL) { - parms.pm_prog = prog; - parms.pm_vers = vers; - parms.pm_prot = prot; - parms.pm_port = 0; /* not needed or used */ - - stat = clnt_call(clnt, PMAPPROC_GETPORT, (xdrproc_t)xdr_pmap, - (caddr_t)&parms, (xdrproc_t)xdr_u_short, (caddr_t)&port, TIMEOUT); + struct pmap parms = { + .pm_prog = program, + .pm_vers = version, + .pm_prot = proto, + }; + + stat = clnt_call(clnt, PMAPPROC_GETPORT, + (xdrproc_t)xdr_pmap, (caddr_t)&parms, + (xdrproc_t)xdr_u_short, (caddr_t)&port, + TIMEOUT); if (stat) { clnt_geterr(clnt, &rpc_createerr.cf_error); rpc_createerr.cf_stat = stat; @@ -420,3 +467,125 @@ int nfs_call_umount(clnt_addr_t *mnt_server, dirpath *argp) return 1; return 0; } + +CLIENT *mnt_openclnt(clnt_addr_t *mnt_server, int *msock) +{ + struct sockaddr_in *mnt_saddr = &mnt_server->saddr; + struct pmap *mnt_pmap = &mnt_server->pmap; + CLIENT *clnt = NULL; + + mnt_saddr->sin_port = htons((u_short)mnt_pmap->pm_port); + *msock = get_socket(mnt_saddr, mnt_pmap->pm_prot, TRUE, FALSE); + if (*msock == RPC_ANYSOCK) { + if (rpc_createerr.cf_error.re_errno == EADDRINUSE) + /* + * Probably in-use by a TIME_WAIT connection, + * It is worth waiting a while and trying again. + */ + rpc_createerr.cf_stat = RPC_TIMEDOUT; + return NULL; + } + + switch (mnt_pmap->pm_prot) { + case IPPROTO_UDP: + clnt = clntudp_bufcreate(mnt_saddr, + mnt_pmap->pm_prog, mnt_pmap->pm_vers, + RETRY_TIMEOUT, msock, + MNT_SENDBUFSIZE, MNT_RECVBUFSIZE); + break; + case IPPROTO_TCP: + clnt = clnttcp_create(mnt_saddr, + mnt_pmap->pm_prog, mnt_pmap->pm_vers, + msock, + MNT_SENDBUFSIZE, MNT_RECVBUFSIZE); + break; + } + if (clnt) { + /* try to mount hostname:dirname */ + clnt->cl_auth = authunix_create_default(); + return clnt; + } + return NULL; +} + +void mnt_closeclnt(CLIENT *clnt, int msock) +{ + auth_destroy(clnt->cl_auth); + clnt_destroy(clnt); + close(msock); +} + +/* + * Sigh... getport() doesn't actually check the version number. + * In order to make sure that the server actually supports the service + * we're requesting, we open and RPC client, and fire off a NULL + * RPC call. + */ +int clnt_ping(struct sockaddr_in *saddr, const unsigned long prog, + const unsigned long vers, const unsigned int prot, + struct sockaddr_in *caddr) +{ + CLIENT *clnt = NULL; + int sock, stat; + static char clnt_res; + struct sockaddr dissolve; + + rpc_createerr.cf_stat = stat = errno = 0; + sock = get_socket(saddr, prot, FALSE, TRUE); + if (sock == RPC_ANYSOCK) { + if (errno == ETIMEDOUT) { + /* + * TCP timeout. Bubble up the error to see + * how it should be handled. + */ + rpc_createerr.cf_stat = RPC_TIMEDOUT; + } + return 0; + } + + if (caddr) { + /* Get the address of our end of this connection */ + socklen_t len = sizeof(*caddr); + if (getsockname(sock, caddr, &len) != 0) + caddr->sin_family = 0; + } + + switch(prot) { + case IPPROTO_UDP: + /* The socket is connected (so we could getsockname successfully), + * but some servers on multi-homed hosts reply from + * the wrong address, so if we stay connected, we lose the reply. + */ + dissolve.sa_family = AF_UNSPEC; + connect(sock, &dissolve, sizeof(dissolve)); + + clnt = clntudp_bufcreate(saddr, prog, vers, + RETRY_TIMEOUT, &sock, + RPCSMALLMSGSIZE, RPCSMALLMSGSIZE); + break; + case IPPROTO_TCP: + clnt = clnttcp_create(saddr, prog, vers, &sock, + RPCSMALLMSGSIZE, RPCSMALLMSGSIZE); + break; + } + if (!clnt) { + close(sock); + return 0; + } + memset(&clnt_res, 0, sizeof(clnt_res)); + stat = clnt_call(clnt, NULLPROC, + (xdrproc_t)xdr_void, (caddr_t)NULL, + (xdrproc_t)xdr_void, (caddr_t)&clnt_res, + TIMEOUT); + if (stat) { + clnt_geterr(clnt, &rpc_createerr.cf_error); + rpc_createerr.cf_stat = stat; + } + clnt_destroy(clnt); + close(sock); + + if (stat == RPC_SUCCESS) + return 1; + else + return 0; +}