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 <errno.h>
  10 #include <rpc/rpc.h>
  11 #include <rpc/pmap_prot.h>
  12 #include <rpc/pmap_clnt.h>
  13 #include <sys/socket.h>
  14 #include <sys/stat.h>
  15 #include <netinet/in.h>
  16 #include <arpa/inet.h>
  17
  18 #include "conn.h"
  19
  20 extern int verbose;
  21
  22 /* Map an NFS version into the corresponding Mountd version */
  23 u_long nfsvers_to_mnt(const u_long vers)
  24 {
  25         static const u_long nfs_to_mnt[] = { 0, 0, 1, 3 };
  26         if (vers <= 3)
  27                 return nfs_to_mnt[vers];
  28         return 0;
  29 }
  30
  31 /* Map a Mountd version into the corresponding NFS version */
  32 u_long mntvers_to_nfs(const u_long vers)
  33 {
  34         static const u_long mnt_to_nfs[] = { 0, 2, 2, 3 };
  35         if (vers <= 3)
  36                 return mnt_to_nfs[vers];
  37         return 0;
  38 }
  39
  40 /*
  41  * Create a socket that is locally bound to a
  42  * reserve or non-reserve port. For any failures,
  43  * RPC_ANYSOCK is returned which will cause
  44  * the RPC code to create the socket instead.
  45  */
  46 int get_socket(struct sockaddr_in *saddr, u_int p_prot, int resvp)
  47 {
  48         int so, cc, type;
  49         struct sockaddr_in laddr;
  50         socklen_t namelen = sizeof(laddr);
  51
  52         type = (p_prot == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM);
  53         if ((so = socket (AF_INET, type, p_prot)) < 0) {
  54                 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
  55                 rpc_createerr.cf_error.re_errno = errno;
  56                 if (verbose) {
  57                         fprintf(stderr,
  58                                 "mount: Unable to create %s socket: errno %d (%s)\n",
  59                                 p_prot == IPPROTO_UDP ? "UDP" : "TCP",
  60                                 errno, strerror(errno));
  61                 }
  62                 return RPC_ANYSOCK;
  63         }
  64         laddr.sin_family = AF_INET;
  65         laddr.sin_port = 0;
  66         laddr.sin_addr.s_addr = htonl(INADDR_ANY);
  67         if (resvp) {
  68                 if (bindresvport(so, &laddr) < 0) {
  69                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
  70                         rpc_createerr.cf_error.re_errno = errno;
  71                         if (verbose) {
  72                                 fprintf(stderr,
  73                                         "mount: Unable to bindresvport %s socket: errno %d (%s)\n",
  74                                         p_prot == IPPROTO_UDP ? "UDP" : "TCP",
  75                                         errno, strerror(errno));
  76                         }
  77                         close(so);
  78                         return RPC_ANYSOCK;
  79                 }
  80         } else {
  81                 cc = bind(so, (struct sockaddr *)&laddr, namelen);
  82                 if (cc < 0) {
  83                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
  84                         rpc_createerr.cf_error.re_errno = errno;
  85                         if (verbose) {
  86                                 fprintf(stderr,
  87                                         "mount: Unable to bind to %s socket: errno %d (%s)\n",
  88                                         p_prot == IPPROTO_UDP ? "UDP" : "TCP",
  89                                         errno, strerror(errno));
  90                         }
  91                         close(so);
  92                         return RPC_ANYSOCK;
  93                 }
  94         }
  95         if (type == SOCK_STREAM) {
  96                 cc = connect(so, (struct sockaddr *)saddr, namelen);
  97                 if (cc < 0) {
  98                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
  99                         rpc_createerr.cf_error.re_errno = errno;
 100                         if (verbose) {
 101                                 fprintf(stderr,
 102                                         "mount: Unable to connect to %s:%d, errno %d (%s)\n",
 103                                         inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port),
 104                                         errno, strerror(errno));
 105                         }
 106                         close(so);
 107                         return RPC_ANYSOCK;
 108                 }
 109         }
 110         return so;
 111 }
 112
 113 /*
 114  * Sigh... getport() doesn't actually check the version number.
 115  * In order to make sure that the server actually supports the service
 116  * we're requesting, we open and RPC client, and fire off a NULL
 117  * RPC call.
 118  */
 119 int
 120 clnt_ping(struct sockaddr_in *saddr, const u_long prog, const u_long vers,
 121           const u_int prot)
 122 {
 123         CLIENT *clnt=NULL;
 124         int sock, stat;
 125         static char clnt_res;
 126
 127         rpc_createerr.cf_stat = stat = errno = 0;
 128         sock = get_socket(saddr, prot, FALSE);
 129         if (sock == RPC_ANYSOCK && errno == ETIMEDOUT) {
 130                 /*
 131                  * TCP timeout. Bubble up the error to see
 132                  * how it should be handled.
 133                  */
 134                 rpc_createerr.cf_stat = RPC_TIMEDOUT;
 135                 goto out_bad;
 136         }
 137
 138         switch(prot) {
 139         case IPPROTO_UDP:
 140                 clnt = clntudp_bufcreate(saddr, prog, vers,
 141                                          RETRY_TIMEOUT, &sock,
 142                                          RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 143                 break;
 144         case IPPROTO_TCP:
 145                 clnt = clnttcp_create(saddr, prog, vers, &sock,
 146                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 147                 break;
 148         default:
 149                 goto out_bad;
 150         }
 151         if (!clnt)
 152                 goto out_bad;
 153         memset(&clnt_res, 0, sizeof(clnt_res));
 154         stat = clnt_call(clnt, NULLPROC,
 155                          (xdrproc_t)xdr_void, (caddr_t)NULL,
 156                          (xdrproc_t)xdr_void, (caddr_t)&clnt_res,
 157                          TIMEOUT);
 158         if (stat) {
 159                 clnt_geterr(clnt, &rpc_createerr.cf_error);
 160                 rpc_createerr.cf_stat = stat;
 161         }
 162         clnt_destroy(clnt);
 163         if (sock != -1)
 164                 close(sock);
 165
 166         if (stat == RPC_SUCCESS)
 167                 return 1;
 168
 169  out_bad:
 170         return 0;
 171 }
 172
 173 CLIENT *mnt_openclnt(clnt_addr_t *mnt_server, int *msock)
 174 {
 175         struct sockaddr_in *mnt_saddr = &mnt_server->saddr;
 176         struct pmap *mnt_pmap = &mnt_server->pmap;
 177         CLIENT *clnt = NULL;
 178
 179         /* contact the mount daemon via TCP */
 180         mnt_saddr->sin_port = htons((u_short)mnt_pmap->pm_port);
 181         *msock = get_socket(mnt_saddr, mnt_pmap->pm_prot, TRUE);
 182
 183         switch (mnt_pmap->pm_prot) {
 184         case IPPROTO_UDP:
 185                 clnt = clntudp_bufcreate(mnt_saddr,
 186                                          mnt_pmap->pm_prog, mnt_pmap->pm_vers,
 187                                          RETRY_TIMEOUT, msock,
 188                                          MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 189                 break;
 190         case IPPROTO_TCP:
 191                 clnt = clnttcp_create(mnt_saddr,
 192                                       mnt_pmap->pm_prog, mnt_pmap->pm_vers,
 193                                       msock,
 194                                       MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 195                 break;
 196         }
 197         if (clnt) {
 198                 /* try to mount hostname:dirname */
 199                 clnt->cl_auth = authunix_create_default();
 200                 return clnt;
 201         }
 202         return NULL;
 203 }
 204
 205 void mnt_closeclnt(CLIENT *clnt, int msock)
 206 {
 207         auth_destroy(clnt->cl_auth);
 208         clnt_destroy(clnt);
 209         close(msock);
 210 }
 211