mount.nfs: use nfs_error instead of fprintf in get_socket()

[nfs-utils.git] / utils / mount / network.c

diff --git a/utils/mount/network.c b/utils/mount/network.c
index c092571044b0c31d61cec3f7862c16a93c8f8650..af37ef62f06a9f26de7b9390f69aeb37428e53b1 100644 (file)
--- a/utils/mount/network.c
+++ b/utils/mount/network.c
@@ -53,6 +53,10 @@
 #define NFS_PORT 2049
 #endif
 
+#if SIZEOF_SOCKLEN_T - 0 == 0
+#define socklen_t unsigned int
+#endif
+
 extern int nfs_mount_data_version;
 extern char *progname;
 extern int verbose;
@@ -154,6 +158,85 @@ int nfs_gethostbyname(const char *hostname, struct sockaddr_in *saddr)
        return 1;
 }
 
+/*
+ * Create a socket that is locally bound to a reserved or non-reserved
+ * port. For any failures, RPC_ANYSOCK is returned which will cause 
+ * the RPC code to create the socket instead. 
+ */
+static int get_socket(struct sockaddr_in *saddr, unsigned int p_prot,
+                       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(so, (struct sockaddr *)saddr, namelen);
+               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
@@ -510,3 +593,78 @@ void mnt_closeclnt(CLIENT *clnt, int msock)
        clnt_destroy(clnt);
        close(msock);
 }
+
+/*
+ * 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.
+ */
+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 = errno = 0;
+       sock = get_socket(saddr, prot, FALSE, TRUE);
+       if (sock == RPC_ANYSOCK) {
+               if (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;
+}