*
*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
#include <ctype.h>
#include <unistd.h>
#include <stdio.h>
#include <rpc/pmap_clnt.h>
#include <sys/socket.h>
-#include "conn.h"
#include "xcommon.h"
#include "mount.h"
#include "nls.h"
#define NFS_PORT 2049
#endif
+#define PMAP_TIMEOUT (10)
+#define CONNECT_TIMEOUT (20)
+#define MOUNT_TIMEOUT (30)
+
+#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,
0,
};
-int nfs_gethostbyname(const char *hostname, struct sockaddr_in *saddr)
+/**
+ * nfs_name_to_address - resolve hostname to an IPv4 or IPv6 socket address
+ * @hostname: pointer to C string containing DNS hostname to resolve
+ * @sap: pointer to buffer to fill with socket address
+ * @len: IN: size of buffer to fill; OUT: size of socket address
+ *
+ * Returns 1 and places a socket address at @sap if successful;
+ * otherwise zero.
+ */
+int nfs_name_to_address(const char *hostname,
+ const sa_family_t af_hint,
+ struct sockaddr *sap, socklen_t *salen)
{
- struct hostent *hp;
-
- saddr->sin_family = AF_INET;
- if (!inet_aton(hostname, &saddr->sin_addr)) {
- if ((hp = gethostbyname(hostname)) == NULL) {
- nfs_error(_("%s: can't get address for %s\n"),
- progname, hostname);
- return 0;
- } else {
- if (hp->h_length > sizeof(*saddr)) {
- nfs_error(_("%s: got bad hp->h_length\n"),
- progname);
- hp->h_length = sizeof(*saddr);
- }
- memcpy(&saddr->sin_addr, hp->h_addr, hp->h_length);
+ struct addrinfo *gai_results;
+ struct addrinfo gai_hint = {
+ .ai_family = af_hint,
+ .ai_flags = AI_ADDRCONFIG,
+ };
+ socklen_t len = *salen;
+ int error, ret = 0;
+
+ if (af_hint == AF_INET6)
+ gai_hint.ai_flags |= AI_V4MAPPED|AI_ALL;
+
+ *salen = 0;
+
+ error = getaddrinfo(hostname, NULL, &gai_hint, &gai_results);
+ if (error) {
+ nfs_error(_("%s: DNS resolution failed for %s: %s"),
+ progname, hostname, (error == EAI_SYSTEM ?
+ strerror(errno) : gai_strerror(error)));
+ return ret;
+ }
+
+ switch (gai_results->ai_addr->sa_family) {
+ case AF_INET:
+ case AF_INET6:
+ if (len >= gai_results->ai_addrlen) {
+ *salen = gai_results->ai_addrlen;
+ memcpy(sap, gai_results->ai_addr, *salen);
+ ret = 1;
}
+ break;
+ default:
+ /* things are really broken if we get here, so warn */
+ nfs_error(_("%s: unrecognized DNS resolution results for %s"),
+ progname, hostname);
+ break;
}
- return 1;
+
+ freeaddrinfo(gai_results);
+ return ret;
+}
+
+/**
+ * nfs_gethostbyname - resolve a hostname to an IPv4 address
+ * @hostname: pointer to a C string containing a DNS hostname
+ * @saddr: returns an IPv4 address
+ *
+ * Returns 1 if successful, otherwise zero.
+ */
+int nfs_gethostbyname(const char *hostname, struct sockaddr_in *sin)
+{
+ socklen_t len = sizeof(*sin);
+
+ return nfs_name_to_address(hostname, AF_INET,
+ (struct sockaddr *)sin, &len);
+}
+
+/*
+ * Attempt to connect a socket, but time out after "timeout" seconds.
+ *
+ * On error return, caller closes the socket.
+ */
+static int connect_to(int fd, struct sockaddr *addr,
+ socklen_t addrlen, int timeout)
+{
+ int ret, saved;
+ fd_set rset, wset;
+ struct timeval tv = {
+ .tv_sec = timeout,
+ };
+
+ saved = fcntl(fd, F_GETFL, 0);
+ fcntl(fd, F_SETFL, saved | O_NONBLOCK);
+
+ ret = connect(fd, addr, addrlen);
+ if (ret < 0 && errno != EINPROGRESS)
+ return -1;
+ if (ret == 0)
+ goto out;
+
+ FD_ZERO(&rset);
+ FD_SET(fd, &rset);
+ wset = rset;
+ ret = select(fd + 1, &rset, &wset, NULL, &tv);
+ if (ret == 0) {
+ errno = ETIMEDOUT;
+ return -1;
+ }
+ if (FD_ISSET(fd, &rset) || FD_ISSET(fd, &wset)) {
+ int error;
+ socklen_t len = sizeof(error);
+ if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
+ return -1;
+ if (error) {
+ errno = error;
+ return -1;
+ }
+ } else
+ return -1;
+
+out:
+ fcntl(fd, F_SETFL, saved);
+ return 0;
+}
+
+/*
+ * Create a socket that is locally bound to a reserved or non-reserved port.
+ *
+ * The caller should check rpc_createerr to determine the cause of any error.
+ */
+static int get_socket(struct sockaddr_in *saddr, unsigned int p_prot,
+ unsigned int timeout, int resvp, int conn)
+{
+ int so, cc, type;
+ struct sockaddr_in laddr;
+ socklen_t namelen = sizeof(laddr);
+
+ type = (p_prot == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM);
+ if ((so = socket (AF_INET, type, p_prot)) < 0)
+ goto err_socket;
+
+ laddr.sin_family = AF_INET;
+ laddr.sin_port = 0;
+ laddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ if (resvp) {
+ if (bindresvport(so, &laddr) < 0)
+ goto err_bindresvport;
+ } else {
+ cc = bind(so, (struct sockaddr *)&laddr, namelen);
+ if (cc < 0)
+ goto err_bind;
+ }
+ if (type == SOCK_STREAM || (conn && type == SOCK_DGRAM)) {
+ cc = connect_to(so, (struct sockaddr *)saddr, namelen,
+ timeout);
+ if (cc < 0)
+ goto err_connect;
+ }
+ return so;
+
+err_socket:
+ rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+ rpc_createerr.cf_error.re_errno = errno;
+ if (verbose) {
+ nfs_error(_("%s: Unable to create %s socket: errno %d (%s)\n"),
+ progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
+ errno, strerror(errno));
+ }
+ return RPC_ANYSOCK;
+
+err_bindresvport:
+ rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+ rpc_createerr.cf_error.re_errno = errno;
+ if (verbose) {
+ nfs_error(_("%s: Unable to bindresvport %s socket: errno %d"
+ " (%s)\n"),
+ progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
+ errno, strerror(errno));
+ }
+ close(so);
+ return RPC_ANYSOCK;
+
+err_bind:
+ rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+ rpc_createerr.cf_error.re_errno = errno;
+ if (verbose) {
+ nfs_error(_("%s: Unable to bind to %s socket: errno %d (%s)\n"),
+ progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
+ errno, strerror(errno));
+ }
+ close(so);
+ return RPC_ANYSOCK;
+
+err_connect:
+ rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+ rpc_createerr.cf_error.re_errno = errno;
+ if (verbose) {
+ nfs_error(_("%s: Unable to connect to %s:%d, errno %d (%s)\n"),
+ progname, inet_ntoa(saddr->sin_addr),
+ ntohs(saddr->sin_port), errno, strerror(errno));
+ }
+ close(so);
+ return RPC_ANYSOCK;
}
/*
unsigned long version,
unsigned int proto)
{
+ struct sockaddr_in bind_saddr;
unsigned short port = 0;
int socket;
CLIENT *clnt = NULL;
enum clnt_stat stat;
+
+ bind_saddr = *saddr;
+ bind_saddr.sin_port = htons(PMAPPORT);
- saddr->sin_port = htons(PMAPPORT);
-
- /*
- * Try to get a socket with a non-privileged port.
- * clnt*create() will create one anyway if this
- * fails.
- */
- socket = get_socket(saddr, proto, FALSE, FALSE);
+ socket = get_socket(&bind_saddr, proto, PMAP_TIMEOUT, FALSE, FALSE);
if (socket == RPC_ANYSOCK) {
- if (proto == IPPROTO_TCP && errno == ETIMEDOUT) {
- /*
- * TCP SYN timed out, so exit now.
- */
+ if (proto == IPPROTO_TCP &&
+ rpc_createerr.cf_error.re_errno == ETIMEDOUT)
rpc_createerr.cf_stat = RPC_TIMEDOUT;
- }
return 0;
}
switch (proto) {
case IPPROTO_UDP:
- clnt = clntudp_bufcreate(saddr,
+ clnt = clntudp_bufcreate(&bind_saddr,
PMAPPROG, PMAPVERS,
RETRY_TIMEOUT, &socket,
RPCSMALLMSGSIZE,
RPCSMALLMSGSIZE);
break;
case IPPROTO_TCP:
- clnt = clnttcp_create(saddr, PMAPPROG, PMAPVERS, &socket,
+ clnt = clnttcp_create(&bind_saddr,
+ PMAPPROG, PMAPVERS,
+ &socket,
RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
break;
}
else if (port == 0)
rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
}
- if (socket != 1)
- close(socket);
+ close(socket);
return port;
}
p_vers = vers ? &vers : versions;
rpc_createerr.cf_stat = 0;
for (;;) {
- saddr->sin_port = htons(PMAPPORT);
p_port = getport(saddr, prog, *p_vers, *p_prot);
if (p_port) {
if (!port || port == p_port) {
inet_ntoa(saddr->sin_addr),
prog, *p_vers,
*p_prot == IPPROTO_UDP ?
- "udp" : "tcp",
+ _("UDP") : _("TCP"),
p_port);
}
if (clnt_ping(saddr, prog, *p_vers, *p_prot, NULL))
goto out_bad;
}
}
- if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED)
+ if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED &&
+ rpc_createerr.cf_stat != RPC_PROGVERSMISMATCH)
goto out_bad;
if (!prot) {
continue;
p_prot = protos;
}
- if (vers == pmap->pm_vers) {
- p_vers = versions;
- vers = 0;
- }
if (vers || !*++p_vers)
break;
}
return probe_port(mnt_server, probe_mnt1_first, probe_udp_only);
}
+/**
+ * probe_bothports - discover the RPC endpoints of mountd and NFS server
+ * @mnt_server: pointer to address and pmap argument for mountd results
+ * @nfs_server: pointer to address and pmap argument for NFS server
+ *
+ * Returns 1 if successful, otherwise zero if some error occurred.
+ * Note that the arguments are both input and output arguments.
+ *
+ * A side effect of calling this function is that rpccreateerr is set.
+ */
int probe_bothports(clnt_addr_t *mnt_server, clnt_addr_t *nfs_server)
{
struct pmap *nfs_pmap = &nfs_server->pmap;
for (; *probe_vers; probe_vers++) {
nfs_pmap->pm_vers = mntvers_to_nfs(*probe_vers);
if ((res = probe_nfsport(nfs_server) != 0)) {
- mnt_pmap->pm_vers = nfsvers_to_mnt(nfs_pmap->pm_vers);
+ mnt_pmap->pm_vers = *probe_vers;
if ((res = probe_mntport(mnt_server)) != 0)
return 1;
memcpy(mnt_pmap, &save_mnt, sizeof(*mnt_pmap));
return 1;
}
-/*
- * Attempt to start rpc.statd
+/**
+ * start_statd - attempt to start rpc.statd
+ *
+ * Returns 1 if statd is running; otherwise zero.
*/
int start_statd(void)
{
return 0;
}
-/*
+/**
* nfs_call_umount - ask the server to remove a share from it's rmtab
* @mnt_server: address of RPC MNT program server
* @argp: directory path of share to "unmount"
enum clnt_stat res = 0;
int msock;
- switch (mnt_server->pmap.pm_vers) {
- case 3:
- case 2:
- case 1:
- if (!probe_mntport(mnt_server))
- return 0;
- clnt = mnt_openclnt(mnt_server, &msock);
- if (!clnt)
- return 0;
- res = clnt_call(clnt, MOUNTPROC_UMNT,
- (xdrproc_t)xdr_dirpath, (caddr_t)argp,
- (xdrproc_t)xdr_void, NULL,
- TIMEOUT);
- mnt_closeclnt(clnt, msock);
- if (res == RPC_SUCCESS)
- return 1;
+ if (!probe_mntport(mnt_server))
+ return 0;
+ clnt = mnt_openclnt(mnt_server, &msock);
+ if (!clnt)
+ return 0;
+ res = clnt_call(clnt, MOUNTPROC_UMNT,
+ (xdrproc_t)xdr_dirpath, (caddr_t)argp,
+ (xdrproc_t)xdr_void, NULL,
+ TIMEOUT);
+ mnt_closeclnt(clnt, msock);
+
+ if (res == RPC_SUCCESS)
+ return 1;
+ return 0;
+}
+
+/**
+ * mnt_openclnt - get a handle for a remote mountd service
+ * @mnt_server: address and pmap arguments of mountd service
+ * @msock: returns a file descriptor of the underlying transport socket
+ *
+ * Returns an active handle for the remote's mountd service
+ */
+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, MOUNT_TIMEOUT,
+ 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;
- default:
- res = RPC_SUCCESS;
+ 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;
+}
- if (res == RPC_SUCCESS)
+/**
+ * mnt_closeclnt - terminate a handle for a remote mountd service
+ * @clnt: pointer to an active handle for a remote mountd service
+ * @msock: file descriptor of the underlying transport socket
+ *
+ */
+void mnt_closeclnt(CLIENT *clnt, int msock)
+{
+ auth_destroy(clnt->cl_auth);
+ clnt_destroy(clnt);
+ close(msock);
+}
+
+/**
+ * clnt_ping - send an RPC ping to the remote RPC service endpoint
+ * @saddr: server's address
+ * @prog: target RPC program number
+ * @vers: target RPC version number
+ * @prot: target RPC protocol
+ * @caddr: filled in with our network address
+ *
+ * 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.
+ *
+ * caddr is the network address that the server will use to call us back.
+ * On multi-homed clients, this address depends on which NIC we use to
+ * route requests to the server.
+ *
+ * Returns one if successful, otherwise zero.
+ */
+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 = 0;
+ sock = get_socket(saddr, prot, CONNECT_TIMEOUT, FALSE, TRUE);
+ if (sock == RPC_ANYSOCK) {
+ if (rpc_createerr.cf_error.re_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;
- return 0;
+ else
+ return 0;
+}
+
+/**
+ * get_client_address - acquire our local network address
+ * @saddr: server's address
+ * @caddr: filled in with our network address
+ *
+ * Discover a network address that the server will use to call us back.
+ * On multi-homed clients, this address depends on which NIC we use to
+ * route requests to the server.
+ *
+ * Use a connected datagram socket so as not to leave a socket in TIME_WAIT.
+ *
+ * Returns one if successful, otherwise zero.
+ */
+int get_client_address(struct sockaddr_in *saddr, struct sockaddr_in *caddr)
+{
+ socklen_t len = sizeof(*caddr);
+ int socket, err;
+
+ socket = get_socket(saddr, IPPROTO_UDP, CONNECT_TIMEOUT, FALSE, TRUE);
+ if (socket == RPC_ANYSOCK)
+ return 0;
+
+ err = getsockname(socket, caddr, &len);
+ close(socket);
+
+ if (err && verbose) {
+ nfs_error(_("%s: getsockname failed: %s"),
+ progname, strerror(errno));
+ return 0;
+ }
+ return 1;
}
projects / nfs-utils.git / blobdiff