base/SOURCES/autofs-5.0.8-fix-ipv6-libtirpc-getport.patch

autofs-5.0.8 - fix ipv6 libtirpc getport

From: Ian Kent <ikent@redhat.com>

The method that was being used to obtain a service port number
when using libtirpc was wrong.
---
 CHANGELOG      |    1 
 lib/rpc_subs.c |  283 +++++++++++++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 267 insertions(+), 17 deletions(-)

--- autofs-5.0.7.orig/CHANGELOG
+++ autofs-5.0.7/CHANGELOG
@@ -64,6 +64,7 @@
 - fix get_nfs_info() probe.
 - fix portmap lookup.
 - only probe specific nfs version if requested.
+- fix ipv6 libtirpc getport.
 
 25/07/2012 autofs-5.0.7
 =======================
--- autofs-5.0.7.orig/lib/rpc_subs.c
+++ autofs-5.0.7/lib/rpc_subs.c
@@ -234,6 +234,28 @@ static int rpc_do_create_client(struct s
 
 	return 0;
 }
+static int rpc_getport(struct conn_info *info,
+		       struct pmap *parms, CLIENT *client)
+{
+	enum clnt_stat status;
+
+	/*
+	 * Check to see if server is up otherwise a getport will take
+	 * forever to timeout.
+	 */
+	status = clnt_call(client, PMAPPROC_NULL,
+			 (xdrproc_t) xdr_void, 0, (xdrproc_t) xdr_void, 0,
+			 info->timeout);
+
+	if (status == RPC_SUCCESS) {
+		status = clnt_call(client, PMAPPROC_GETPORT,
+				 (xdrproc_t) xdr_pmap, (caddr_t) parms,
+				 (xdrproc_t) xdr_u_short, (caddr_t) port,
+				 info->timeout);
+	}
+
+	return status;
+}
 #else
 static int rpc_do_create_client(struct sockaddr *addr, struct conn_info *info, int *fd, CLIENT **client)
 {
@@ -267,9 +289,6 @@ static int rpc_do_create_client(struct s
 		laddr = (struct sockaddr *) &in4_laddr;
 		in4_raddr->sin_port = htons(info->port);
 		slen = sizeof(struct sockaddr_in);
-		/* Use rpcbind v2 for AF_INET */
-		if (info->program == rpcb_prog)
-			info->version = PMAPVERS;
 	} else if (addr->sa_family == AF_INET6) {
 		struct sockaddr_in6 *in6_raddr = (struct sockaddr_in6 *) addr;
 		in6_laddr.sin6_family = AF_INET6;
@@ -324,6 +343,244 @@ static int rpc_do_create_client(struct s
 
 	return 0;
 }
+
+/*
+ * Thankfully nfs-utils had already dealt with this.
+ * Thanks to Chuck Lever for his nfs-utils patch series, much of
+ * which is used here.
+ */
+static pthread_mutex_t proto_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static enum clnt_stat rpc_get_netid(const sa_family_t family,
+				    const int protocol, char **netid)
+{
+	char *nc_protofmly, *nc_proto, *nc_netid;
+	struct netconfig *nconf;
+	struct protoent *proto;
+	void *handle;
+
+	switch (family) {
+	case AF_LOCAL:
+	case AF_INET:
+		nc_protofmly = NC_INET;
+		break;
+	case AF_INET6:
+		nc_protofmly = NC_INET6;
+		break;
+	default:
+		return RPC_UNKNOWNPROTO;
+        }
+
+	pthread_mutex_lock(&proto_mutex);
+	proto = getprotobynumber(protocol);
+	if (!proto) {
+		pthread_mutex_unlock(&proto_mutex);
+		return RPC_UNKNOWNPROTO;
+	}
+	nc_proto = strdup(proto->p_name);
+	pthread_mutex_unlock(&proto_mutex);
+	if (!nc_proto)
+		return RPC_SYSTEMERROR;
+
+	handle = setnetconfig();
+	while ((nconf = getnetconfig(handle)) != NULL) {
+		if (nconf->nc_protofmly != NULL &&
+		    strcmp(nconf->nc_protofmly, nc_protofmly) != 0)
+			continue;
+		if (nconf->nc_proto != NULL &&
+		    strcmp(nconf->nc_proto, nc_proto) != 0)
+			continue;
+
+		nc_netid = strdup(nconf->nc_netid);
+		if (!nc_netid) {
+			free(nc_proto);
+			return RPC_SYSTEMERROR;
+		}
+
+		*netid = nc_netid;
+	}
+	endnetconfig(handle);
+	free(nc_proto);
+
+	return RPC_SUCCESS;
+}
+
+static char *rpc_sockaddr2universal(const struct sockaddr *addr)
+{
+	const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *) addr;
+	const struct sockaddr_un *sun = (const struct sockaddr_un *) addr;
+	const struct sockaddr_in *sin = (const struct sockaddr_in *) addr;
+	char buf[INET6_ADDRSTRLEN + 8 /* for port information */];
+	uint16_t port;
+	size_t count;
+	char *result;
+	int len;
+
+	switch (addr->sa_family) {
+	case AF_LOCAL:
+		return strndup(sun->sun_path, sizeof(sun->sun_path));
+	case AF_INET:
+		if (inet_ntop(AF_INET, (const void *)&sin->sin_addr.s_addr,
+					buf, (socklen_t)sizeof(buf)) == NULL)
+			goto out_err;
+		port = ntohs(sin->sin_port);
+		break;
+	case AF_INET6:
+		if (inet_ntop(AF_INET6, (const void *)&sin6->sin6_addr,
+					buf, (socklen_t)sizeof(buf)) == NULL)
+			goto out_err;
+		port = ntohs(sin6->sin6_port);
+		break;
+	default:
+		goto out_err;
+	}
+
+	count = sizeof(buf) - strlen(buf);
+	len = snprintf(buf + strlen(buf), count, ".%u.%u",
+			(unsigned)(port >> 8), (unsigned)(port & 0xff));
+	/* before glibc 2.0.6, snprintf(3) could return -1 */
+	if (len < 0 || (size_t)len > count)
+		goto out_err;
+
+	result = strdup(buf);
+	return result;
+
+out_err:
+        return NULL;
+}
+
+static int rpc_universal2port(const char *uaddr)
+{
+	char *addrstr;
+	char *p, *endptr;
+	unsigned long portlo, porthi;
+	int port = -1;
+
+	addrstr = strdup(uaddr);
+	if (!addrstr)
+		return -1;
+
+	p = strrchr(addrstr, '.');
+	if (!p)
+		goto out;
+
+	portlo = strtoul(p + 1, &endptr, 10);
+	if (*endptr != '\0' || portlo > 255)
+		goto out;
+	*p = '\0';
+
+        p = strrchr(addrstr, '.');
+        if (!p)
+                goto out;
+
+        porthi = strtoul(p + 1, &endptr, 10);
+        if (*endptr != '\0' || porthi > 255)
+                goto out;
+        *p = '\0';
+
+        port = (porthi << 8) | portlo;
+
+out:
+	free(addrstr);
+	return port;
+}
+
+static enum clnt_stat rpc_rpcb_getport(CLIENT *client,
+				       struct rpcb *parms,
+				       struct timeval timeout,
+				       unsigned short *port)
+{
+	rpcvers_t rpcb_version;
+	struct rpc_err rpcerr;
+	int s_port = 0;
+
+	for (rpcb_version = RPCBVERS_4;
+	     rpcb_version >= RPCBVERS_3;
+	     rpcb_version--) {
+		enum clnt_stat status;
+		char *uaddr = NULL;
+
+		CLNT_CONTROL(client, CLSET_VERS, (void *) &rpcb_version);
+		status = CLNT_CALL(client, (rpcproc_t) RPCBPROC_GETADDR,
+				  (xdrproc_t) xdr_rpcb, (void *) parms,
+				  (xdrproc_t) xdr_wrapstring, (void *) &uaddr,
+				  timeout);
+
+		switch (status) {
+		case RPC_SUCCESS:
+			if ((uaddr == NULL) || (uaddr[0] == '\0'))
+				return RPC_PROGNOTREGISTERED;
+
+			s_port = rpc_universal2port(uaddr);
+			xdr_free((xdrproc_t) xdr_wrapstring, (char *) &uaddr);
+			if (s_port == -1) {
+				return RPC_N2AXLATEFAILURE;
+			}
+			*port = s_port;
+			return RPC_SUCCESS;
+
+		case RPC_PROGVERSMISMATCH:
+			clnt_geterr(client, &rpcerr);
+			if (rpcerr.re_vers.low > RPCBVERS4)
+				return status;
+			continue;
+		case RPC_PROCUNAVAIL:
+		case RPC_PROGUNAVAIL:
+			continue;
+		default:
+                        /* Most likely RPC_TIMEDOUT or RPC_CANTRECV */
+			return status;
+		}
+	}
+
+        if (s_port == 0)
+		return RPC_PROGNOTREGISTERED;
+
+        return RPC_PROCUNAVAIL;
+}
+
+static enum clnt_stat rpc_getport(struct conn_info *info,
+				  struct pmap *parms, CLIENT *client,
+				  unsigned short *port)
+{
+	enum clnt_stat status;
+	struct sockaddr *paddr, addr;
+	struct rpcb rpcb_parms;
+	char *netid, *raddr;
+
+	if (info->addr)
+		paddr = info->addr;
+	else {
+		if (!clnt_control(client, CLGET_SERVER_ADDR, (char *) &addr))
+			return RPC_UNKNOWNADDR;
+		paddr = &addr;
+	}
+
+	netid = NULL;
+	status = rpc_get_netid(paddr->sa_family, info->proto, &netid);
+	if (status != RPC_SUCCESS)
+		return status;
+
+	raddr = rpc_sockaddr2universal(paddr);
+	if (!raddr) {
+		free(netid);
+		return RPC_UNKNOWNADDR;
+	}
+
+	memset(&rpcb_parms, 0, sizeof(rpcb_parms));
+	rpcb_parms.r_prog   = parms->pm_prog;
+	rpcb_parms.r_vers   = parms->pm_vers;
+	rpcb_parms.r_netid  = netid;
+	rpcb_parms.r_addr   = raddr;
+	rpcb_parms.r_owner  = "";
+
+	status = rpc_rpcb_getport(client, &rpcb_parms, info->timeout, port);
+
+	free(netid);
+	free(raddr);
+
+	return status;
+}
 #endif
 
 #if defined(HAVE_GETRPCBYNAME) || defined(HAVE_GETSERVBYNAME)
@@ -647,20 +904,7 @@ int rpc_portmap_getport(struct conn_info
 			return ret;
 	}
 
-	/*
-	 * Check to see if server is up otherwise a getport will take
-	 * forever to timeout.
-	 */
-	status = clnt_call(client, PMAPPROC_NULL,
-			 (xdrproc_t) xdr_void, 0, (xdrproc_t) xdr_void, 0,
-			 pmap_info.timeout);
-
-	if (status == RPC_SUCCESS) {
-		status = clnt_call(client, PMAPPROC_GETPORT,
-				 (xdrproc_t) xdr_pmap, (caddr_t) parms,
-				 (xdrproc_t) xdr_u_short, (caddr_t) port,
-				 pmap_info.timeout);
-	}
+	status = rpc_getport(&pmap_info, parms, client, port);
 
 	if (!info->client) {
 		/*
@@ -867,6 +1111,11 @@ static int rpc_get_exports_proto(struct
 	clnt_control(client, CLSET_RETRY_TIMEOUT, (char *) &info->timeout);
 
 	client->cl_auth = authunix_create_default();
+	if (client->cl_auth == NULL) {
+		error(LOGOPT_ANY, "auth create failed");
+		clnt_destroy(client);
+		return 0;
+	}
 
 	vers_entry = 0;
 	while (1) {