Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / amd / conf / transp / transp_sockets.c
1 /*
2  * Copyright (c) 1997-1999 Erez Zadok
3  * Copyright (c) 1990 Jan-Simon Pendry
4  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
5  * Copyright (c) 1990 The Regents of the University of California.
6  * All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Jan-Simon Pendry at Imperial College, London.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgment:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  *      %W% (Berkeley) %G%
40  *
41  * $Id: transp_sockets.c,v 1.5 1999/08/22 21:12:31 ezk Exp $
42  *
43  * Socket specific utilities.
44  *      -Erez Zadok <ezk@cs.columbia.edu>
45  */
46
47 #ifdef HAVE_CONFIG_H
48 # include <config.h>
49 #endif /* HAVE_CONFIG_H */
50 #include <am_defs.h>
51 #include <amu.h>
52
53
54 /*
55  * find the IP address that can be used to connect to the local host
56  */
57 void
58 amu_get_myaddress(struct in_addr *iap)
59 {
60   struct sockaddr_in sin;
61
62   memset((char *) &sin, 0, sizeof(sin));
63   get_myaddress(&sin);
64   iap->s_addr = sin.sin_addr.s_addr;
65 }
66
67
68 /*
69  * How to bind to reserved ports.
70  */
71 int
72 bind_resv_port(int so, u_short *pp)
73 {
74   struct sockaddr_in sin;
75   int rc;
76   u_short port;
77
78   memset((voidp) &sin, 0, sizeof(sin));
79   sin.sin_family = AF_INET;
80
81   port = IPPORT_RESERVED;
82
83   do {
84     --port;
85     sin.sin_port = htons(port);
86     rc = bind(so, (struct sockaddr *) &sin, sizeof(sin));
87   } while (rc < 0 && (int) port > IPPORT_RESERVED / 2);
88
89   if (pp && rc == 0)
90     *pp = port;
91
92   return rc;
93 }
94
95
96 /*
97  * close a descriptor, Sockets style
98  */
99 int
100 amu_close(int fd)
101 {
102   return close(fd);
103 }
104
105
106 /*
107  * Create an rpc client attached to the mount daemon.
108  */
109 CLIENT *
110 get_mount_client(char *unused_host, struct sockaddr_in *sin, struct timeval *tv, int *sock, u_long mnt_version)
111 {
112   CLIENT *client;
113
114   /*
115    * First try a TCP socket
116    */
117   if ((*sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) > 0) {
118     /*
119      * Bind to a privileged port
120      */
121     if (bind_resv_port(*sock, (u_short *) 0) < 0)
122       plog(XLOG_ERROR, "can't bind privileged port");
123
124     /*
125      * Find mountd port to connect to.
126      * Connect to mountd.
127      * Create a tcp client.
128      */
129     if ((sin->sin_port = htons(pmap_getport(sin, MOUNTPROG, mnt_version, IPPROTO_TCP))) != 0) {
130       if (connect(*sock, (struct sockaddr *) sin, sizeof(*sin)) >= 0
131           && ((client = clnttcp_create(sin, MOUNTPROG, mnt_version, sock, 0, 0)) != NULL))
132         return client;
133     }
134     /*
135      * Failed so close socket
136      */
137     (void) close(*sock);
138   }                             /* tcp socket opened */
139   /* TCP failed so try UDP */
140   if ((*sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
141     plog(XLOG_ERROR, "Can't create socket to connect to mountd: %m");
142     *sock = RPC_ANYSOCK;
143     return NULL;
144   }
145   /*
146    * Bind to a privileged port
147    */
148   if (bind_resv_port(*sock, (u_short *) 0) < 0)
149     plog(XLOG_ERROR, "can't bind privileged port");
150
151   /*
152    * Zero out the port - make sure we recompute
153    */
154   sin->sin_port = 0;
155
156   /*
157    * Make a UDP client
158    */
159   if ((client = clntudp_create(sin, MOUNTPROG, mnt_version, *tv, sock)) == NULL) {
160     (void) close(*sock);
161     *sock = RPC_ANYSOCK;
162     return NULL;
163   }
164 #ifdef DEBUG
165   dlog("get_mount_client: Using udp, port %d", sin->sin_port);
166 #endif /* DEBUG */
167   return client;
168 }
169
170
171 /*
172  * find the address of the caller of an RPC procedure.
173  */
174 struct sockaddr_in *
175 amu_svc_getcaller(SVCXPRT *xprt)
176 {
177   return svc_getcaller(xprt);
178 }
179
180
181 /*
182  * Create the nfs service for amd
183  */
184 int
185 create_nfs_service(int *soNFSp, u_short *nfs_portp, SVCXPRT **nfs_xprtp, void (*dispatch_fxn)(struct svc_req *rqstp, SVCXPRT *transp))
186 {
187
188   *soNFSp = socket(AF_INET, SOCK_DGRAM, 0);
189
190   if (*soNFSp < 0 || bind_resv_port(*soNFSp, NULL) < 0) {
191     plog(XLOG_FATAL, "Can't create privileged nfs port");
192     return 1;
193   }
194   if ((*nfs_xprtp = svcudp_create(*soNFSp)) == NULL) {
195     plog(XLOG_FATAL, "cannot create rpc/udp service");
196     return 2;
197   }
198   if ((*nfs_portp = (*nfs_xprtp)->xp_port) >= IPPORT_RESERVED) {
199     plog(XLOG_FATAL, "Can't create privileged nfs port");
200     return 1;
201   }
202   if (!svc_register(*nfs_xprtp, NFS_PROGRAM, NFS_VERSION, dispatch_fxn, 0)) {
203     plog(XLOG_FATAL, "unable to register (NFS_PROGRAM, NFS_VERSION, 0)");
204     return 3;
205   }
206
207   return 0;                     /* all is well */
208 }
209
210
211 /*
212  * Create the amq service for amd (both TCP and UDP)
213  */
214 int
215 create_amq_service(int *udp_soAMQp, SVCXPRT **udp_amqpp, int *tcp_soAMQp, SVCXPRT **tcp_amqpp)
216 {
217   /* first create TCP service */
218   if (tcp_soAMQp) {
219     *tcp_soAMQp = socket(AF_INET, SOCK_STREAM, 0);
220     if (*tcp_soAMQp < 0) {
221       plog(XLOG_FATAL, "cannot create tcp socket for amq service: %m");
222       return 1;
223     }
224
225     /* now create RPC service handle for amq */
226     if (tcp_amqpp &&
227         (*tcp_amqpp = svctcp_create(*tcp_soAMQp, AMQ_SIZE, AMQ_SIZE)) == NULL) {
228       plog(XLOG_FATAL, "cannot create tcp service for amq: soAMQp=%d", *tcp_soAMQp);
229       return 2;
230     }
231   }
232
233   /* next create UDP service */
234   if (udp_soAMQp) {
235     *udp_soAMQp = socket(AF_INET, SOCK_DGRAM, 0);
236     if (*udp_soAMQp < 0) {
237       plog(XLOG_FATAL, "cannot create udp socket for amq service: %m");
238       return 3;
239     }
240
241     /* now create RPC service handle for amq */
242     if (udp_amqpp &&
243         (*udp_amqpp = svcudp_bufcreate(*udp_soAMQp, AMQ_SIZE, AMQ_SIZE)) == NULL) {
244       plog(XLOG_FATAL, "cannot create udp service for amq: soAMQp=%d", *udp_soAMQp);
245       return 4;
246     }
247   }
248
249   return 0;                     /* all is well */
250 }
251
252
253 /*
254  * Ping the portmapper on a remote system by calling the nullproc
255  */
256 enum clnt_stat
257 pmap_ping(struct sockaddr_in *address)
258 {
259   CLIENT *client;
260   enum clnt_stat clnt_stat = RPC_TIMEDOUT; /* assume failure */
261   int socket = RPC_ANYSOCK;
262   struct timeval timeout;
263
264   timeout.tv_sec = 3;
265   timeout.tv_usec = 0;
266   address->sin_port = htons(PMAPPORT);
267   client = clntudp_create(address, PMAPPROG, PMAPVERS, timeout, &socket);
268   if (client != (CLIENT *) NULL) {
269     clnt_stat = clnt_call(client,
270                           PMAPPROC_NULL,
271                           (XDRPROC_T_TYPE) xdr_void,
272                           NULL,
273                           (XDRPROC_T_TYPE) xdr_void,
274                           NULL,
275                           timeout);
276     clnt_destroy(client);
277   }
278   close(socket);
279   address->sin_port = 0;
280
281   return clnt_stat;
282 }
283
284
285 /*
286  * Find the best NFS version for a host and protocol.
287  */
288 u_long
289 get_nfs_version(char *host, struct sockaddr_in *sin, u_long nfs_version, const char *proto)
290 {
291   CLIENT *clnt;
292   int again = 0;
293   enum clnt_stat clnt_stat;
294   struct timeval tv;
295   int sock;
296
297   /*
298    * If not set or set wrong, then try from NFS_VERS_MAX on down. If
299    * set, then try from nfs_version on down.
300    */
301   if (nfs_version <= 0 || nfs_version > NFS_VERS_MAX) {
302     nfs_version = NFS_VERS_MAX;
303     again = 1;
304   }
305   tv.tv_sec = 3;                /* retry every 3 seconds, but also timeout */
306   tv.tv_usec = 0;
307
308   /*
309    * First check if remote portmapper is up (verify if remote host is up).
310    */
311   clnt_stat = pmap_ping(sin);
312   if (clnt_stat == RPC_TIMEDOUT) {
313     plog(XLOG_ERROR, "get_nfs_version: failed to contact portmapper on host \"%s\": %s", host, clnt_sperrno(clnt_stat));
314     return 0;
315   }
316
317 #ifdef HAVE_FS_NFS3
318 try_again:
319 #endif /* HAVE_FS_NFS3 */
320
321   sock = RPC_ANYSOCK;
322   if (STREQ(proto, "tcp"))
323     clnt = clnttcp_create(sin, NFS_PROGRAM, nfs_version, &sock, 0, 0);
324   else if (STREQ(proto, "udp"))
325     clnt = clntudp_create(sin, NFS_PROGRAM, nfs_version, tv, &sock);
326   else
327     clnt = NULL;
328
329   if (clnt == NULL) {
330 #ifdef HAVE_CLNT_SPCREATEERROR
331     plog(XLOG_INFO, "get_nfs_version NFS(%d,%s) failed for %s :%s",
332          (int) nfs_version, proto, host, clnt_spcreateerror(""));
333 #else /* not HAVE_CLNT_SPCREATEERROR */
334     plog(XLOG_INFO, "get_nfs_version NFS(%d,%s) failed for %s",
335          (int) nfs_version, proto, host);
336 #endif /* not HAVE_CLNT_SPCREATEERROR */
337     return 0;
338   }
339
340   /* Try a couple times to verify the CLIENT handle. */
341   tv.tv_sec = 6;
342   clnt_stat = clnt_call(clnt,
343                         NFSPROC_NULL,
344                         (XDRPROC_T_TYPE) xdr_void,
345                         0,
346                         (XDRPROC_T_TYPE) xdr_void,
347                         0,
348                         tv);
349   close(sock);
350   clnt_destroy(clnt);
351   if (clnt_stat != RPC_SUCCESS) {
352     if (again) {
353 #ifdef HAVE_FS_NFS3
354       if (nfs_version == NFS_VERSION3) {
355         plog(XLOG_INFO, "get_nfs_version trying a lower version");
356         nfs_version = NFS_VERSION;
357         again = 0;
358       }
359       goto try_again;
360 #endif /* HAVE_FS_NFS3 */
361     }
362     plog(XLOG_INFO, "get_nfs_version NFS(%d,%s) failed for %s",
363          (int) nfs_version, proto, host);
364     return 0;
365   }
366
367   plog(XLOG_INFO, "get_nfs_version: returning (%d,%s) on host %s",
368        (int) nfs_version, proto, host);
369   return nfs_version;
370 }
371
372
373 /*
374  * AUTOFS FUNCTIONS FOR SOCKETS:
375  */
376 #ifdef HAVE_FS_AUTOFS
377 /*
378  * Create the nfs service for amd
379  */
380 int
381 create_autofs_service(int *soAUTOFSp, u_short *autofs_portp, SVCXPRT **autofs_xprtp, void (*dispatch_fxn)(struct svc_req *rqstp, SVCXPRT *transp))
382 {
383   /* NOT IMPLEMENTED! */
384   return -1;
385 }
386 #endif /* HAVE_FS_AUTOFS */