libnfs.a: move more mount-only functions out of libnfs.a
[nfs-utils.git] / support / nfs / conn.c
1 /*
2  * conn.c -- NFS client mount / umount connection code support functions
3  *
4  * 2006-06-06 Amit Gud <agud@redhat.com>
5  * - Moved code snippets to nfs-utils/support/nfs from util-linux/mount/nfsmount.c
6  *
7  */
8
9 #include "config.h"
10 #include <errno.h>
11 #include <unistd.h>
12 #include <rpc/rpc.h>
13 #include <rpc/pmap_prot.h>
14 #include <rpc/pmap_clnt.h>
15 #include <sys/socket.h>
16 #include <sys/stat.h>
17 #include <netinet/in.h>
18 #include <arpa/inet.h>
19
20 #include "conn.h"
21
22 #if SIZEOF_SOCKLEN_T - 0 == 0
23 #define socklen_t int
24 #endif
25
26 extern int verbose;
27
28 /*
29  * Create a socket that is locally bound to a 
30  * reserve or non-reserve port. For any failures,
31  * RPC_ANYSOCK is returned which will cause 
32  * the RPC code to create the socket instead. 
33  */
34 int get_socket(struct sockaddr_in *saddr, u_int p_prot, int resvp, int conn)
35 {
36         int so, cc, type;
37         struct sockaddr_in laddr;
38         socklen_t namelen = sizeof(laddr);
39
40         type = (p_prot == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM);
41         if ((so = socket (AF_INET, type, p_prot)) < 0) {
42                 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
43                 rpc_createerr.cf_error.re_errno = errno;
44                 if (verbose) {
45                         fprintf(stderr, 
46                                 "mount: Unable to create %s socket: errno %d (%s)\n",
47                                 p_prot == IPPROTO_UDP ? "UDP" : "TCP", 
48                                 errno, strerror(errno));
49                 }
50                 return RPC_ANYSOCK;
51         }
52         laddr.sin_family = AF_INET;
53         laddr.sin_port = 0;
54         laddr.sin_addr.s_addr = htonl(INADDR_ANY);
55         if (resvp) {
56                 if (bindresvport(so, &laddr) < 0) {
57                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
58                         rpc_createerr.cf_error.re_errno = errno;
59                         if (verbose) {
60                                 fprintf(stderr, 
61                                         "mount: Unable to bindresvport %s socket: errno %d (%s)\n",
62                                         p_prot == IPPROTO_UDP ? "UDP" : "TCP", 
63                                         errno, strerror(errno));
64                         }
65                         close(so);
66                         return RPC_ANYSOCK;
67                 }
68         } else {
69                 cc = bind(so, (struct sockaddr *)&laddr, namelen);
70                 if (cc < 0) {
71                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
72                         rpc_createerr.cf_error.re_errno = errno;
73                         if (verbose) {
74                                 fprintf(stderr, 
75                                         "mount: Unable to bind to %s socket: errno %d (%s)\n",
76                                         p_prot == IPPROTO_UDP ? "UDP" : "TCP", 
77                                         errno, strerror(errno));
78                         }
79                         close(so);
80                         return RPC_ANYSOCK;
81                 }
82         }
83         if (type == SOCK_STREAM || (conn && type == SOCK_DGRAM)) {
84                 cc = connect(so, (struct sockaddr *)saddr, namelen);
85                 if (cc < 0) {
86                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
87                         rpc_createerr.cf_error.re_errno = errno;
88                         if (verbose) {
89                                 fprintf(stderr, 
90                                         "mount: Unable to connect to %s:%d, errno %d (%s)\n",
91                                         inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port),
92                                         errno, strerror(errno));
93                         }
94                         close(so);
95                         return RPC_ANYSOCK;
96                 }
97         }
98         return so;
99 }
100
101 /*
102  * Sigh... getport() doesn't actually check the version number.
103  * In order to make sure that the server actually supports the service
104  * we're requesting, we open and RPC client, and fire off a NULL
105  * RPC call.
106  */
107 int
108 clnt_ping(struct sockaddr_in *saddr, const u_long prog, const u_long vers,
109           const u_int prot, struct sockaddr_in *caddr)
110 {
111         CLIENT *clnt=NULL;
112         int sock, stat;
113         static char clnt_res;
114         struct sockaddr dissolve;
115
116         rpc_createerr.cf_stat = stat = errno = 0;
117         sock = get_socket(saddr, prot, FALSE, TRUE);
118         if (sock == RPC_ANYSOCK) {
119                 if (errno == ETIMEDOUT) {
120                         /*
121                          * TCP timeout. Bubble up the error to see 
122                          * how it should be handled.
123                          */
124                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
125                 }
126                 return 0;
127         }
128
129         if (caddr) {
130                 /* Get the address of our end of this connection */
131                 socklen_t len = sizeof(*caddr);
132                 if (getsockname(sock, caddr, &len) != 0)
133                         caddr->sin_family = 0;
134         }
135
136         switch(prot) {
137         case IPPROTO_UDP:
138                 /* The socket is connected (so we could getsockname successfully),
139                  * but some servers on multi-homed hosts reply from
140                  * the wrong address, so if we stay connected, we lose the reply.
141                  */
142                 dissolve.sa_family = AF_UNSPEC;
143                 connect(sock, &dissolve, sizeof(dissolve));
144
145                 clnt = clntudp_bufcreate(saddr, prog, vers,
146                                          RETRY_TIMEOUT, &sock,
147                                          RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
148                 break;
149         case IPPROTO_TCP:
150                 clnt = clnttcp_create(saddr, prog, vers, &sock,
151                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
152                 break;
153         }
154         if (!clnt) {
155                 close(sock);
156                 return 0;
157         }
158         memset(&clnt_res, 0, sizeof(clnt_res));
159         stat = clnt_call(clnt, NULLPROC,
160                          (xdrproc_t)xdr_void, (caddr_t)NULL,
161                          (xdrproc_t)xdr_void, (caddr_t)&clnt_res,
162                          TIMEOUT);
163         if (stat) {
164                 clnt_geterr(clnt, &rpc_createerr.cf_error);
165                 rpc_createerr.cf_stat = stat;
166         }
167         clnt_destroy(clnt);
168         close(sock);
169
170         if (stat == RPC_SUCCESS)
171                 return 1;
172         else
173                 return 0;
174 }