X-Git-Url: https://git.decadent.org.uk/gitweb/?p=nfs-utils.git;a=blobdiff_plain;f=utils%2Fmount%2Fnetwork.c;h=49d3c6b26d63c33c4b83ae6f497e1fb2a809f87f;hp=c092571044b0c31d61cec3f7862c16a93c8f8650;hb=bda03ca689ff8b410a778299e5c6f4a14fcc85f8;hpb=b6e4ddd10b3c67ef210e572dec956cb35ce96440

diff --git a/utils/mount/network.c b/utils/mount/network.c
index c092571..49d3c6b 100644
--- a/utils/mount/network.c
+++ b/utils/mount/network.c
@@ -34,7 +34,6 @@
 #include <rpc/pmap_clnt.h>
 #include <sys/socket.h>
 
-#include "conn.h"
 #include "xcommon.h"
 #include "mount.h"
 #include "nls.h"
@@ -53,6 +52,14 @@
 #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;
@@ -132,6 +139,13 @@ static const unsigned long probe_mnt3_first[] = {
 	0,
 };
 
+/**
+ * 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 *saddr)
 {
 	struct hostent *hp;
@@ -154,6 +168,134 @@ int nfs_gethostbyname(const char *hostname, struct sockaddr_in *saddr)
 	return 1;
 }
 
+/*
+ * 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;
+}
+
 /*
  * getport() is very similar to pmap_getport() with the exception that
  * this version tries to use an ephemeral port, since reserved ports are
@@ -168,39 +310,35 @@ static unsigned short getport(struct sockaddr_in *saddr,
 				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;
 	}
@@ -225,8 +363,7 @@ static unsigned short getport(struct sockaddr_in *saddr,
 		else if (port == 0)
 			rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
 	}
-	if (socket != 1)
-		close(socket);
+	close(socket);
 
 	return port;
 }
@@ -251,7 +388,6 @@ static int probe_port(clnt_addr_t *server, const unsigned long *versions,
 	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) {
@@ -263,7 +399,7 @@ static int probe_port(clnt_addr_t *server, const unsigned long *versions,
 						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))
@@ -328,6 +464,16 @@ static int probe_mntport(clnt_addr_t *mnt_server)
 		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;
@@ -395,8 +541,10 @@ static int probe_statd(void)
 	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)
 {
@@ -420,7 +568,7 @@ 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"
@@ -464,6 +612,13 @@ int nfs_call_umount(clnt_addr_t *mnt_server, dirpath *argp)
 	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;
@@ -471,7 +626,8 @@ CLIENT *mnt_openclnt(clnt_addr_t *mnt_server, int *msock)
 	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);
+	*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)
 			/*
@@ -504,9 +660,136 @@ CLIENT *mnt_openclnt(clnt_addr_t *mnt_server, int *msock)
 	return NULL;
 }
 
+/**
+ * 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;
+	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;
+}