[packages/autofs.git] / autofs-4.1.3-non_block_ping.patch

diff -Nur autofs-4.1.3.orig/lib/rpc_subs.c autofs-4.1.3/lib/rpc_subs.c
--- autofs-4.1.3.orig/lib/rpc_subs.c	2004-06-14 21:55:29.000000000 +0800
+++ autofs-4.1.3/lib/rpc_subs.c	2004-06-14 21:54:35.000000000 +0800
@@ -1,38 +1,284 @@
+/* ----------------------------------------------------------------------- *
+ *   
+ *  rpc_subs.c - routines for rpc discovery
+ *
+ *   Copyright 2004 Ian Kent <raven@themaw.net> - All Rights Reserved
+ *   Copyright 2004 Jeff Moyer <jmoyer@redaht.com> - All Rights Reserved
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
+ *   USA; either version 2 of the License, or (at your option) any later
+ *   version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
 #include <rpc/rpc.h>
+#include <rpc/pmap_prot.h>
 #include <nfs/nfs.h>
 #include <linux/nfs2.h>
 #include <linux/nfs3.h>
 #include <rpc/xdr.h>
- 
+
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/fcntl.h>
+#include <errno.h>
+
 #include "automount.h"
 
+#define PMAP_TOUT_UDP	2
+#define PMAP_TOUT_TCP	3
+
+struct conn_info {
+	const char *host;
+	unsigned short port;
+	unsigned long program;
+	unsigned long version;
+	struct protoent *proto;
+	unsigned int send_sz;
+	unsigned int recv_sz;
+	struct timeval timeout;
+};
+
+/*
+ * Create a UDP RPC client
+ */
+static CLIENT* create_udp_client(struct conn_info *info)
+{
+	int fd = -1;
+	CLIENT *client;
+	struct sockaddr_in addr;
+	struct hostent *hp;
+
+	if (info->proto->p_proto != IPPROTO_UDP)
+		return NULL;
+
+	memset(&addr, 0, sizeof(addr));
+
+	hp = gethostbyname(info->host);
+	if (!hp)
+		return NULL;
+
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons(info->port);
+	memcpy(&addr.sin_addr.s_addr, hp->h_addr, hp->h_length);
+
+	client = clntudp_bufcreate(&addr,
+				   info->program, info->version,
+				   info->timeout, &fd,
+				   info->send_sz, info->recv_sz);
+
+	return client;
+}
+
+/*
+ *  Perform a non-blocking connect on the socket fd.
+ *
+ *  tout contains the timeout.  It will be modified to contain the time
+ *  remaining (i.e. time provided - time elasped).
+ */
+static int connect_nb(int fd, struct sockaddr_in *addr, struct timeval *tout)
+{
+	int flags, ret, len;
+	fd_set wset, rset;
+
+	flags = fcntl(fd, F_GETFL, 0);
+	if (flags < 0)
+		return -1;
+
+	ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+	if (ret < 0)
+		return -1;
+
+	/* 
+	 * From here on subsequent sys calls could change errno so
+	 * we set ret = -errno to capture it in case we decide to
+	 * use it later.
+	 */
+	ret = connect(fd, (struct sockaddr *)addr, sizeof(struct sockaddr));
+	if (ret < 0 && errno != EINPROGRESS) {
+		ret = -errno;
+		goto done;
+	}
+
+	if (ret == 0)
+		goto done;
+
+	/* now wait */
+	FD_ZERO(&rset);
+	FD_SET(fd, &rset);
+	wset = rset;
+
+	ret = select(fd + 1, &rset, &wset, NULL, tout);
+	if (ret <= 0) {
+		if (ret == 0)
+			ret = -ETIMEDOUT;
+		else
+			ret = -errno;
+		goto done;
+	}
+
+	if (FD_ISSET(fd, &rset) || FD_ISSET(fd, &wset)) {
+		int stat;
+
+		len = sizeof(ret);
+		stat = getsockopt(fd, SOL_SOCKET, SO_ERROR, &ret, &len);
+		if (stat < 0) {
+			ret = -errno;
+			goto done;
+		}
+
+		/* Oops - something wrong with connect */
+		if (ret)
+			ret = -ret;
+	}
+
+done:
+	fcntl(fd, F_SETFL, flags);
+	return ret;
+}
+
+/*
+ * Create a TCP RPC client using non-blocking connect
+ */
+static CLIENT* create_tcp_client(struct conn_info *info)
+{
+	int fd;
+	CLIENT *client;
+	struct sockaddr_in addr;
+	struct hostent *hp;
+	int ret;
+
+	if (info->proto->p_proto != IPPROTO_TCP)
+		return NULL;
+
+	memset(&addr, 0, sizeof(addr));
+
+	hp = gethostbyname(info->host);
+	if (!hp)
+		return NULL;
+
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons(info->port);
+	memcpy(&addr.sin_addr.s_addr, hp->h_addr, hp->h_length);
+
+	fd = socket(PF_INET, SOCK_STREAM, info->proto->p_proto);
+	if (fd < 0)
+		return NULL;
+
+	ret = connect_nb(fd, &addr, &info->timeout);
+	if (ret < 0)
+		goto out_close;
+
+	client = clnttcp_create(&addr,
+				info->program, info->version, &fd,
+				info->send_sz, info->recv_sz);
+	if (!client)
+		goto out_close;
+
+	return client;
+
+out_close:
+	close(fd);
+	return NULL;
+}
+
+static unsigned short portmap_getport(struct conn_info *info)
+{
+	struct conn_info pmap_info;
+	unsigned short port = 0;
+	CLIENT *client;
+	enum clnt_stat stat;
+	struct pmap parms;
+
+	pmap_info.host = info->host;
+	pmap_info.port = PMAPPORT;
+	pmap_info.program = PMAPPROG;
+	pmap_info.version = PMAPVERS;
+	pmap_info.proto = info->proto;
+	pmap_info.send_sz = RPCSMALLMSGSIZE;
+	pmap_info.recv_sz = RPCSMALLMSGSIZE;
+	pmap_info.timeout.tv_sec = PMAP_TOUT_UDP;
+	pmap_info.timeout.tv_usec = 0;
+
+	if (info->proto->p_proto == IPPROTO_TCP) {
+		pmap_info.timeout.tv_sec = PMAP_TOUT_TCP;
+		client = create_tcp_client(&pmap_info);
+	} else
+		client = create_udp_client(&pmap_info);
+
+	if (!client)
+		return 0;
+	
+	parms.pm_prog = info->program;
+	parms.pm_vers = info->version;
+	parms.pm_prot = info->proto->p_proto;
+	parms.pm_port = 0;
+
+	stat = clnt_call(client, PMAPPROC_GETPORT,
+			 (xdrproc_t) xdr_pmap, (caddr_t) &parms,
+			 (xdrproc_t) xdr_u_short, (caddr_t) &port,
+			 pmap_info.timeout);
+
+	clnt_destroy(client);
+
+	if (stat != RPC_SUCCESS)
+		return 0;
+
+	return port;
+}
+
 static int rpc_ping_proto(const char *host,
-			  unsigned long nfs_version, const char *proto,
+			  unsigned long nfs_version,
+			  const char *proto,
 			  long seconds, long micros)
 {
+	struct conn_info info;
 	CLIENT *client;
-	struct timeval tout;
 	enum clnt_stat stat;
+	struct protoent *prot;
+
+	prot = getprotobyname(proto);
+	if (!prot)
+		return 1;
+
+	info.host = host;
+	info.program = NFS_PROGRAM;
+	info.version = nfs_version;
+	info.proto = prot;
+	info.send_sz = 0;
+	info.recv_sz = 0;
+	info.timeout.tv_sec = seconds;
+	info.timeout.tv_usec = micros;
 
-	client = clnt_create(host, NFS_PROGRAM, nfs_version, proto);
-	if (client == NULL) {
+	info.port = portmap_getport(&info);
+	if (!info.port)
 		return 0;
-	}
 
-	tout.tv_sec = seconds;
-	tout.tv_usec = micros;
+	if (prot->p_proto == IPPROTO_UDP) {
+		info.send_sz = UDPMSGSIZE;
+		info.recv_sz = UDPMSGSIZE;
+		client = create_udp_client(&info);
+	} else
+		client = create_tcp_client(&info);
+
+	if (!client)
+		return 0;
 
-	clnt_control(client, CLSET_TIMEOUT, (char *)&tout);
-	clnt_control(client, CLSET_RETRY_TIMEOUT, (char *)&tout);
+	clnt_control(client, CLSET_TIMEOUT, (char *) &info.timeout);
+	clnt_control(client, CLSET_RETRY_TIMEOUT, (char *) &info.timeout);
 
 	stat = clnt_call(client, NFSPROC_NULL,
-			 (xdrproc_t)xdr_void, 0, (xdrproc_t)xdr_void, 0, tout);
+			 (xdrproc_t) xdr_void, 0, (xdrproc_t) xdr_void, 0,
+			 info.timeout);
 
 	clnt_destroy(client);
 
-	if (stat != RPC_SUCCESS) {
+	if (stat != RPC_SUCCESS)
 		return 0;
-	}
 
 	return 1;
 }
@@ -108,10 +354,39 @@
 
 	taken = elapsed(start, end);
 
-	if (result != NULL) {
+	if (result != NULL)
 		*result = taken;
-	}
 
 	return status;
 }
 
+#if 0
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+	int ret;
+	double res = 0.0;
+
+	ret = rpc_ping("budgie", 10, 0);
+	printf("ret = %d\n", ret);
+
+	res = 0.0;
+	ret = rpc_time("raven", NFS2_VERSION, RPC_PING_TCP, 10, 0, &res);
+	printf("v2 tcp ret = %d, res = %f\n", ret, res);
+
+	res = 0.0;
+	ret = rpc_time("raven", NFS3_VERSION, RPC_PING_TCP, 10, 0, &res);
+	printf("v3 tcp ret = %d, res = %f\n", ret, res);
+
+	res = 0.0;
+	ret = rpc_time("raven", NFS2_VERSION, RPC_PING_UDP, 10, 0, &res);
+	printf("v2 udp ret = %d, res = %f\n", ret, res);
+
+	res = 0.0;
+	ret = rpc_time("raven", NFS3_VERSION, RPC_PING_UDP, 10, 0, &res);
+	printf("v3 udp ret = %d, res = %f\n", ret, res);
+
+	exit(0);
+}
+#endif
Commit	Line	Data
e3a22658	1	diff -Nur autofs-4.1.3.orig/lib/rpc_subs.c autofs-4.1.3/lib/rpc_subs.c
	2	--- autofs-4.1.3.orig/lib/rpc_subs.c 2004-06-14 21:55:29.000000000 +0800
	3	+++ autofs-4.1.3/lib/rpc_subs.c 2004-06-14 21:54:35.000000000 +0800
	4	@@ -1,38 +1,284 @@
	5	+/* ----------------------------------------------------------------------- *
	6	+ *
	7	+ * rpc_subs.c - routines for rpc discovery
	8	+ *
	9	+ * Copyright 2004 Ian Kent <raven@themaw.net> - All Rights Reserved
	10	+ * Copyright 2004 Jeff Moyer <jmoyer@redaht.com> - All Rights Reserved
	11	+ *
	12	+ * This program is free software; you can redistribute it and/or modify
	13	+ * it under the terms of the GNU General Public License as published by
	14	+ * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
	15	+ * USA; either version 2 of the License, or (at your option) any later
	16	+ * version; incorporated herein by reference.
	17	+ *
	18	+ * ----------------------------------------------------------------------- */
	19	+
	20	#include <rpc/rpc.h>
	21	+#include <rpc/pmap_prot.h>
	22	#include <nfs/nfs.h>
	23	#include <linux/nfs2.h>
	24	#include <linux/nfs3.h>
	25	#include <rpc/xdr.h>
	26	-
	27	+
	28	+#include <unistd.h>
	29	+#include <sys/socket.h>
	30	+#include <netdb.h>
	31	+#include <netinet/in.h>
	32	+#include <sys/fcntl.h>
	33	+#include <errno.h>
	34	+
	35	#include "automount.h"
	36
	37	+#define PMAP_TOUT_UDP 2
	38	+#define PMAP_TOUT_TCP 3
	39	+
	40	+struct conn_info {
	41	+ const char *host;
	42	+ unsigned short port;
	43	+ unsigned long program;
	44	+ unsigned long version;
	45	+ struct protoent *proto;
	46	+ unsigned int send_sz;
	47	+ unsigned int recv_sz;
	48	+ struct timeval timeout;
	49	+};
	50	+
	51	+/*
	52	+ * Create a UDP RPC client
	53	+ */
	54	+static CLIENT* create_udp_client(struct conn_info *info)
	55	+{
	56	+ int fd = -1;
	57	+ CLIENT *client;
	58	+ struct sockaddr_in addr;
	59	+ struct hostent *hp;
	60	+
	61	+ if (info->proto->p_proto != IPPROTO_UDP)
	62	+ return NULL;
	63	+
	64	+ memset(&addr, 0, sizeof(addr));
65	+
66	+ hp = gethostbyname(info->host);
67	+ if (!hp)
68	+ return NULL;
69	+
70	+ addr.sin_family = AF_INET;
71	+ addr.sin_port = htons(info->port);
72	+ memcpy(&addr.sin_addr.s_addr, hp->h_addr, hp->h_length);
73	+
74	+ client = clntudp_bufcreate(&addr,
75	+ info->program, info->version,
76	+ info->timeout, &fd,
77	+ info->send_sz, info->recv_sz);
78	+
79	+ return client;
80	+}
81	+
82	+/*
83	+ * Perform a non-blocking connect on the socket fd.
84	+ *
85	+ * tout contains the timeout. It will be modified to contain the time
86	+ * remaining (i.e. time provided - time elasped).
87	+ */
88	+static int connect_nb(int fd, struct sockaddr_in addr, struct timeval tout)
89	+{
90	+ int flags, ret, len;
91	+ fd_set wset, rset;
92	+
93	+ flags = fcntl(fd, F_GETFL, 0);
94	+ if (flags < 0)
95	+ return -1;
96	+
97	+ ret = fcntl(fd, F_SETFL, flags \| O_NONBLOCK);
98	+ if (ret < 0)
99	+ return -1;
100	+
101	+ /*
102	+ * From here on subsequent sys calls could change errno so
103	+ * we set ret = -errno to capture it in case we decide to
104	+ * use it later.
105	+ */
106	+ ret = connect(fd, (struct sockaddr *)addr, sizeof(struct sockaddr));
107	+ if (ret < 0 && errno != EINPROGRESS) {
108	+ ret = -errno;
109	+ goto done;
110	+ }
111	+
112	+ if (ret == 0)
113	+ goto done;
114	+
115	+ /* now wait */
116	+ FD_ZERO(&rset);
117	+ FD_SET(fd, &rset);
118	+ wset = rset;
119	+
120	+ ret = select(fd + 1, &rset, &wset, NULL, tout);
121	+ if (ret <= 0) {
122	+ if (ret == 0)
123	+ ret = -ETIMEDOUT;
124	+ else
125	+ ret = -errno;
126	+ goto done;
127	+ }
128	+
129	+ if (FD_ISSET(fd, &rset) \|\| FD_ISSET(fd, &wset)) {
130	+ int stat;
131	+
132	+ len = sizeof(ret);
133	+ stat = getsockopt(fd, SOL_SOCKET, SO_ERROR, &ret, &len);
134	+ if (stat < 0) {
135	+ ret = -errno;
136	+ goto done;
137	+ }
138	+
139	+ /* Oops - something wrong with connect */
140	+ if (ret)
141	+ ret = -ret;
142	+ }
143	+
144	+done:
145	+ fcntl(fd, F_SETFL, flags);
146	+ return ret;
147	+}
148	+
149	+/*
150	+ * Create a TCP RPC client using non-blocking connect
151	+ */
152	+static CLIENT* create_tcp_client(struct conn_info *info)
153	+{
154	+ int fd;
155	+ CLIENT *client;
156	+ struct sockaddr_in addr;
157	+ struct hostent *hp;
158	+ int ret;
159	+
160	+ if (info->proto->p_proto != IPPROTO_TCP)
161	+ return NULL;
162	+
163	+ memset(&addr, 0, sizeof(addr));
164	+
165	+ hp = gethostbyname(info->host);
166	+ if (!hp)
167	+ return NULL;
168	+
169	+ addr.sin_family = AF_INET;
170	+ addr.sin_port = htons(info->port);
171	+ memcpy(&addr.sin_addr.s_addr, hp->h_addr, hp->h_length);
172	+
173	+ fd = socket(PF_INET, SOCK_STREAM, info->proto->p_proto);
174	+ if (fd < 0)
175	+ return NULL;
176	+
177	+ ret = connect_nb(fd, &addr, &info->timeout);
178	+ if (ret < 0)
179	+ goto out_close;
180	+
181	+ client = clnttcp_create(&addr,
182	+ info->program, info->version, &fd,
183	+ info->send_sz, info->recv_sz);
184	+ if (!client)
185	+ goto out_close;
186	+
187	+ return client;
188	+
189	+out_close:
190	+ close(fd);
191	+ return NULL;
192	+}
193	+
194	+static unsigned short portmap_getport(struct conn_info *info)
195	+{
196	+ struct conn_info pmap_info;
197	+ unsigned short port = 0;
198	+ CLIENT *client;
199	+ enum clnt_stat stat;
200	+ struct pmap parms;
201	+
202	+ pmap_info.host = info->host;
203	+ pmap_info.port = PMAPPORT;
204	+ pmap_info.program = PMAPPROG;
205	+ pmap_info.version = PMAPVERS;
206	+ pmap_info.proto = info->proto;
207	+ pmap_info.send_sz = RPCSMALLMSGSIZE;
208	+ pmap_info.recv_sz = RPCSMALLMSGSIZE;
209	+ pmap_info.timeout.tv_sec = PMAP_TOUT_UDP;
210	+ pmap_info.timeout.tv_usec = 0;
211	+
212	+ if (info->proto->p_proto == IPPROTO_TCP) {
213	+ pmap_info.timeout.tv_sec = PMAP_TOUT_TCP;
214	+ client = create_tcp_client(&pmap_info);
215	+ } else
216	+ client = create_udp_client(&pmap_info);
217	+
218	+ if (!client)
219	+ return 0;
220	+
221	+ parms.pm_prog = info->program;
222	+ parms.pm_vers = info->version;
223	+ parms.pm_prot = info->proto->p_proto;
224	+ parms.pm_port = 0;
225	+
226	+ stat = clnt_call(client, PMAPPROC_GETPORT,
227	+ (xdrproc_t) xdr_pmap, (caddr_t) &parms,
228	+ (xdrproc_t) xdr_u_short, (caddr_t) &port,
229	+ pmap_info.timeout);
230	+
231	+ clnt_destroy(client);
232	+
233	+ if (stat != RPC_SUCCESS)
234	+ return 0;
235	+
236	+ return port;
237	+}
238	+
239	static int rpc_ping_proto(const char *host,
240	- unsigned long nfs_version, const char *proto,
241	+ unsigned long nfs_version,
242	+ const char *proto,
243	long seconds, long micros)
244	{
245	+ struct conn_info info;
246	CLIENT *client;
247	- struct timeval tout;
248	enum clnt_stat stat;
249	+ struct protoent *prot;
250	+
251	+ prot = getprotobyname(proto);
252	+ if (!prot)
253	+ return 1;
254	+
255	+ info.host = host;
256	+ info.program = NFS_PROGRAM;
257	+ info.version = nfs_version;
258	+ info.proto = prot;
259	+ info.send_sz = 0;
260	+ info.recv_sz = 0;
261	+ info.timeout.tv_sec = seconds;
262	+ info.timeout.tv_usec = micros;
263
264	- client = clnt_create(host, NFS_PROGRAM, nfs_version, proto);
265	- if (client == NULL) {
266	+ info.port = portmap_getport(&info);
267	+ if (!info.port)
268	return 0;
269	- }
270
271	- tout.tv_sec = seconds;
272	- tout.tv_usec = micros;
273	+ if (prot->p_proto == IPPROTO_UDP) {
274	+ info.send_sz = UDPMSGSIZE;
275	+ info.recv_sz = UDPMSGSIZE;
276	+ client = create_udp_client(&info);
277	+ } else
278	+ client = create_tcp_client(&info);
279	+
280	+ if (!client)
281	+ return 0;
282
283	- clnt_control(client, CLSET_TIMEOUT, (char *)&tout);
284	- clnt_control(client, CLSET_RETRY_TIMEOUT, (char *)&tout);
285	+ clnt_control(client, CLSET_TIMEOUT, (char *) &info.timeout);
286	+ clnt_control(client, CLSET_RETRY_TIMEOUT, (char *) &info.timeout);
287
288	stat = clnt_call(client, NFSPROC_NULL,
289	- (xdrproc_t)xdr_void, 0, (xdrproc_t)xdr_void, 0, tout);
290	+ (xdrproc_t) xdr_void, 0, (xdrproc_t) xdr_void, 0,
291	+ info.timeout);
292
293	clnt_destroy(client);
294
295	- if (stat != RPC_SUCCESS) {
296	+ if (stat != RPC_SUCCESS)
297	return 0;
298	- }
299
300	return 1;
301	}
302	@@ -108,10 +354,39 @@
303
304	taken = elapsed(start, end);
305
306	- if (result != NULL) {
307	+ if (result != NULL)
308	*result = taken;
309	- }
310
311	return status;
312	}
313
314	+#if 0
315	+#include <stdio.h>
316	+
317	+int main(int argc, char **argv)
318	+{
319	+ int ret;
320	+ double res = 0.0;
321	+
322	+ ret = rpc_ping("budgie", 10, 0);
323	+ printf("ret = %d\n", ret);
324	+
325	+ res = 0.0;
326	+ ret = rpc_time("raven", NFS2_VERSION, RPC_PING_TCP, 10, 0, &res);
327	+ printf("v2 tcp ret = %d, res = %f\n", ret, res);
328	+
329	+ res = 0.0;
330	+ ret = rpc_time("raven", NFS3_VERSION, RPC_PING_TCP, 10, 0, &res);
331	+ printf("v3 tcp ret = %d, res = %f\n", ret, res);
332	+
333	+ res = 0.0;
334	+ ret = rpc_time("raven", NFS2_VERSION, RPC_PING_UDP, 10, 0, &res);
335	+ printf("v2 udp ret = %d, res = %f\n", ret, res);
336	+
337	+ res = 0.0;
338	+ ret = rpc_time("raven", NFS3_VERSION, RPC_PING_UDP, 10, 0, &res);
339	+ printf("v3 udp ret = %d, res = %f\n", ret, res);
340	+
341	+ exit(0);
342	+}
343	+#endif