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