utils/mount/network.c

   1 /*
   2  * network.c -- Provide common network functions for NFS mount/umount
   3  *
   4  * Copyright (C) 2007 Oracle.  All rights reserved.
   5  * Copyright (C) 2007 Chuck Lever <chuck.lever@oracle.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public
  18  * License along with this program; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 021110-1307, USA.
  21  *
  22  */
  23
  24 #include <ctype.h>
  25 #include <unistd.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <errno.h>
  30 #include <netdb.h>
  31 #include <time.h>
  32 #include <rpc/rpc.h>
  33 #include <rpc/pmap_prot.h>
  34 #include <rpc/pmap_clnt.h>
  35 #include <sys/socket.h>
  36
  37 #include "conn.h"
  38 #include "xcommon.h"
  39 #include "mount.h"
  40 #include "nls.h"
  41 #include "nfs_mount.h"
  42 #include "mount_constants.h"
  43 #include "network.h"
  44
  45 #ifdef HAVE_RPCSVC_NFS_PROT_H
  46 #include <rpcsvc/nfs_prot.h>
  47 #else
  48 #include <linux/nfs.h>
  49 #define nfsstat nfs_stat
  50 #endif
  51
  52 #ifndef NFS_PORT
  53 #define NFS_PORT 2049
  54 #endif
  55
  56 #if SIZEOF_SOCKLEN_T - 0 == 0
  57 #define socklen_t unsigned int
  58 #endif
  59
  60 extern int nfs_mount_data_version;
  61 extern char *progname;
  62 extern int verbose;
  63
  64 static const unsigned long nfs_to_mnt[] = {
  65         0,
  66         0,
  67         1,
  68         3,
  69 };
  70
  71 static const unsigned long mnt_to_nfs[] = {
  72         0,
  73         2,
  74         2,
  75         3,
  76 };
  77
  78 /*
  79  * Map an NFS version into the corresponding Mountd version
  80  */
  81 unsigned long nfsvers_to_mnt(const unsigned long vers)
  82 {
  83         if (vers <= 3)
  84                 return nfs_to_mnt[vers];
  85         return 0;
  86 }
  87
  88 /*
  89  * Map a Mountd version into the corresponding NFS version
  90  */
  91 static unsigned long mntvers_to_nfs(const unsigned long vers)
  92 {
  93         if (vers <= 3)
  94                 return mnt_to_nfs[vers];
  95         return 0;
  96 }
  97
  98 static const unsigned int probe_udp_only[] = {
  99         IPPROTO_UDP,
 100         0,
 101 };
 102
 103 static const unsigned int probe_udp_first[] = {
 104         IPPROTO_UDP,
 105         IPPROTO_TCP,
 106         0,
 107 };
 108
 109 static const unsigned int probe_tcp_first[] = {
 110         IPPROTO_TCP,
 111         IPPROTO_UDP,
 112         0,
 113 };
 114
 115 static const unsigned long probe_nfs2_only[] = {
 116         2,
 117         0,
 118 };
 119
 120 static const unsigned long probe_nfs3_first[] = {
 121         3,
 122         2,
 123         0,
 124 };
 125
 126 static const unsigned long probe_mnt1_first[] = {
 127         1,
 128         2,
 129         0,
 130 };
 131
 132 static const unsigned long probe_mnt3_first[] = {
 133         3,
 134         1,
 135         2,
 136         0,
 137 };
 138
 139 int nfs_gethostbyname(const char *hostname, struct sockaddr_in *saddr)
 140 {
 141         struct hostent *hp;
 142
 143         saddr->sin_family = AF_INET;
 144         if (!inet_aton(hostname, &saddr->sin_addr)) {
 145                 if ((hp = gethostbyname(hostname)) == NULL) {
 146                         nfs_error(_("%s: can't get address for %s\n"),
 147                                         progname, hostname);
 148                         return 0;
 149                 } else {
 150                         if (hp->h_length > sizeof(*saddr)) {
 151                                 nfs_error(_("%s: got bad hp->h_length\n"),
 152                                                 progname);
 153                                 hp->h_length = sizeof(*saddr);
 154                         }
 155                         memcpy(&saddr->sin_addr, hp->h_addr, hp->h_length);
 156                 }
 157         }
 158         return 1;
 159 }
 160
 161 /*
 162  * Create a socket that is locally bound to a reserved or non-reserved
 163  * port. For any failures, RPC_ANYSOCK is returned which will cause
 164  * the RPC code to create the socket instead.
 165  */
 166 static int get_socket(struct sockaddr_in *saddr, unsigned int p_prot,
 167                         int resvp, int conn)
 168 {
 169         int so, cc, type;
 170         struct sockaddr_in laddr;
 171         socklen_t namelen = sizeof(laddr);
 172
 173         type = (p_prot == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM);
 174         if ((so = socket (AF_INET, type, p_prot)) < 0)
 175                 goto err_socket;
 176
 177         laddr.sin_family = AF_INET;
 178         laddr.sin_port = 0;
 179         laddr.sin_addr.s_addr = htonl(INADDR_ANY);
 180         if (resvp) {
 181                 if (bindresvport(so, &laddr) < 0)
 182                         goto err_bindresvport;
 183         } else {
 184                 cc = bind(so, (struct sockaddr *)&laddr, namelen);
 185                 if (cc < 0)
 186                         goto err_bind;
 187         }
 188         if (type == SOCK_STREAM || (conn && type == SOCK_DGRAM)) {
 189                 cc = connect(so, (struct sockaddr *)saddr, namelen);
 190                 if (cc < 0)
 191                         goto err_connect;
 192         }
 193         return so;
 194
 195 err_socket:
 196         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 197         rpc_createerr.cf_error.re_errno = errno;
 198         if (verbose) {
 199                 nfs_error(_("%s: Unable to create %s socket: errno %d (%s)\n"),
 200                         progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
 201                         errno, strerror(errno));
 202         }
 203         return RPC_ANYSOCK;
 204
 205 err_bindresvport:
 206         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 207         rpc_createerr.cf_error.re_errno = errno;
 208         if (verbose) {
 209                 nfs_error(_("%s: Unable to bindresvport %s socket: errno %d"
 210                                 " (%s)\n"),
 211                         progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
 212                         errno, strerror(errno));
 213         }
 214         close(so);
 215         return RPC_ANYSOCK;
 216
 217 err_bind:
 218         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 219         rpc_createerr.cf_error.re_errno = errno;
 220         if (verbose) {
 221                 nfs_error(_("%s: Unable to bind to %s socket: errno %d (%s)\n"),
 222                         progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
 223                         errno, strerror(errno));
 224         }
 225         close(so);
 226         return RPC_ANYSOCK;
 227
 228 err_connect:
 229         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 230         rpc_createerr.cf_error.re_errno = errno;
 231         if (verbose) {
 232                 nfs_error(_("%s: Unable to connect to %s:%d, errno %d (%s)\n"),
 233                         progname, inet_ntoa(saddr->sin_addr),
 234                         ntohs(saddr->sin_port), errno, strerror(errno));
 235         }
 236         close(so);
 237         return RPC_ANYSOCK;
 238 }
 239
 240 /*
 241  * getport() is very similar to pmap_getport() with the exception that
 242  * this version tries to use an ephemeral port, since reserved ports are
 243  * not needed for GETPORT queries.  This conserves the very limited
 244  * reserved port space, which helps reduce failed socket binds
 245  * during mount storms.
 246  *
 247  * A side effect of calling this function is that rpccreateerr is set.
 248  */
 249 static unsigned short getport(struct sockaddr_in *saddr,
 250                                 unsigned long program,
 251                                 unsigned long version,
 252                                 unsigned int proto)
 253 {
 254         unsigned short port = 0;
 255         int socket;
 256         CLIENT *clnt = NULL;
 257         enum clnt_stat stat;
 258
 259         saddr->sin_port = htons(PMAPPORT);
 260
 261         /*
 262          * Try to get a socket with a non-privileged port.
 263          * clnt*create() will create one anyway if this
 264          * fails.
 265          */
 266         socket = get_socket(saddr, proto, FALSE, FALSE);
 267         if (socket == RPC_ANYSOCK) {
 268                 if (proto == IPPROTO_TCP && errno == ETIMEDOUT) {
 269                         /*
 270                          * TCP SYN timed out, so exit now.
 271                          */
 272                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
 273                 }
 274                 return 0;
 275         }
 276
 277         switch (proto) {
 278         case IPPROTO_UDP:
 279                 clnt = clntudp_bufcreate(saddr,
 280                                          PMAPPROG, PMAPVERS,
 281                                          RETRY_TIMEOUT, &socket,
 282                                          RPCSMALLMSGSIZE,
 283                                          RPCSMALLMSGSIZE);
 284                 break;
 285         case IPPROTO_TCP:
 286                 clnt = clnttcp_create(saddr, PMAPPROG, PMAPVERS, &socket,
 287                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 288                 break;
 289         }
 290         if (clnt != NULL) {
 291                 struct pmap parms = {
 292                         .pm_prog        = program,
 293                         .pm_vers        = version,
 294                         .pm_prot        = proto,
 295                 };
 296
 297                 stat = clnt_call(clnt, PMAPPROC_GETPORT,
 298                                  (xdrproc_t)xdr_pmap, (caddr_t)&parms,
 299                                  (xdrproc_t)xdr_u_short, (caddr_t)&port,
 300                                  TIMEOUT);
 301                 if (stat) {
 302                         clnt_geterr(clnt, &rpc_createerr.cf_error);
 303                         rpc_createerr.cf_stat = stat;
 304                 }
 305                 clnt_destroy(clnt);
 306                 if (stat != RPC_SUCCESS)
 307                         port = 0;
 308                 else if (port == 0)
 309                         rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
 310         }
 311         if (socket != 1)
 312                 close(socket);
 313
 314         return port;
 315 }
 316
 317 /*
 318  * Use the portmapper to discover whether or not the service we want is
 319  * available. The lists 'versions' and 'protos' define ordered sequences
 320  * of service versions and udp/tcp protocols to probe for.
 321  */
 322 static int probe_port(clnt_addr_t *server, const unsigned long *versions,
 323                         const unsigned int *protos)
 324 {
 325         struct sockaddr_in *saddr = &server->saddr;
 326         struct pmap *pmap = &server->pmap;
 327         const unsigned long prog = pmap->pm_prog, *p_vers;
 328         const unsigned int prot = (u_int)pmap->pm_prot, *p_prot;
 329         const u_short port = (u_short) pmap->pm_port;
 330         unsigned long vers = pmap->pm_vers;
 331         unsigned short p_port;
 332
 333         p_prot = prot ? &prot : protos;
 334         p_vers = vers ? &vers : versions;
 335         rpc_createerr.cf_stat = 0;
 336         for (;;) {
 337                 saddr->sin_port = htons(PMAPPORT);
 338                 p_port = getport(saddr, prog, *p_vers, *p_prot);
 339                 if (p_port) {
 340                         if (!port || port == p_port) {
 341                                 saddr->sin_port = htons(p_port);
 342                                 if (verbose) {
 343                                         printf(_("%s: trying %s prog %ld vers "
 344                                                 "%ld prot %s port %d\n"),
 345                                                 progname,
 346                                                 inet_ntoa(saddr->sin_addr),
 347                                                 prog, *p_vers,
 348                                                 *p_prot == IPPROTO_UDP ?
 349                                                         "udp" : "tcp",
 350                                                 p_port);
 351                                 }
 352                                 if (clnt_ping(saddr, prog, *p_vers, *p_prot, NULL))
 353                                         goto out_ok;
 354                                 if (rpc_createerr.cf_stat == RPC_TIMEDOUT)
 355                                         goto out_bad;
 356                         }
 357                 }
 358                 if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED)
 359                         goto out_bad;
 360
 361                 if (!prot) {
 362                         if (*++p_prot)
 363                                 continue;
 364                         p_prot = protos;
 365                 }
 366                 if (vers == pmap->pm_vers) {
 367                         p_vers = versions;
 368                         vers = 0;
 369                 }
 370                 if (vers || !*++p_vers)
 371                         break;
 372         }
 373
 374 out_bad:
 375         return 0;
 376
 377 out_ok:
 378         if (!vers)
 379                 pmap->pm_vers = *p_vers;
 380         if (!prot)
 381                 pmap->pm_prot = *p_prot;
 382         if (!port)
 383                 pmap->pm_port = p_port;
 384         rpc_createerr.cf_stat = 0;
 385         return 1;
 386 }
 387
 388 static int probe_nfsport(clnt_addr_t *nfs_server)
 389 {
 390         struct pmap *pmap = &nfs_server->pmap;
 391
 392         if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
 393                 return 1;
 394
 395         if (nfs_mount_data_version >= 4)
 396                 return probe_port(nfs_server, probe_nfs3_first, probe_tcp_first);
 397         else
 398                 return probe_port(nfs_server, probe_nfs2_only, probe_udp_only);
 399 }
 400
 401 static int probe_mntport(clnt_addr_t *mnt_server)
 402 {
 403         struct pmap *pmap = &mnt_server->pmap;
 404
 405         if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
 406                 return 1;
 407
 408         if (nfs_mount_data_version >= 4)
 409                 return probe_port(mnt_server, probe_mnt3_first, probe_udp_first);
 410         else
 411                 return probe_port(mnt_server, probe_mnt1_first, probe_udp_only);
 412 }
 413
 414 int probe_bothports(clnt_addr_t *mnt_server, clnt_addr_t *nfs_server)
 415 {
 416         struct pmap *nfs_pmap = &nfs_server->pmap;
 417         struct pmap *mnt_pmap = &mnt_server->pmap;
 418         struct pmap save_nfs, save_mnt;
 419         int res;
 420         const unsigned long *probe_vers;
 421
 422         if (mnt_pmap->pm_vers && !nfs_pmap->pm_vers)
 423                 nfs_pmap->pm_vers = mntvers_to_nfs(mnt_pmap->pm_vers);
 424         else if (nfs_pmap->pm_vers && !mnt_pmap->pm_vers)
 425                 mnt_pmap->pm_vers = nfsvers_to_mnt(nfs_pmap->pm_vers);
 426         if (nfs_pmap->pm_vers)
 427                 goto version_fixed;
 428
 429         memcpy(&save_nfs, nfs_pmap, sizeof(save_nfs));
 430         memcpy(&save_mnt, mnt_pmap, sizeof(save_mnt));
 431         probe_vers = (nfs_mount_data_version >= 4) ?
 432                         probe_mnt3_first : probe_mnt1_first;
 433
 434         for (; *probe_vers; probe_vers++) {
 435                 nfs_pmap->pm_vers = mntvers_to_nfs(*probe_vers);
 436                 if ((res = probe_nfsport(nfs_server) != 0)) {
 437                         mnt_pmap->pm_vers = nfsvers_to_mnt(nfs_pmap->pm_vers);
 438                         if ((res = probe_mntport(mnt_server)) != 0)
 439                                 return 1;
 440                         memcpy(mnt_pmap, &save_mnt, sizeof(*mnt_pmap));
 441                 }
 442                 switch (rpc_createerr.cf_stat) {
 443                 case RPC_PROGVERSMISMATCH:
 444                 case RPC_PROGNOTREGISTERED:
 445                         break;
 446                 default:
 447                         goto out_bad;
 448                 }
 449                 memcpy(nfs_pmap, &save_nfs, sizeof(*nfs_pmap));
 450         }
 451
 452 out_bad:
 453         return 0;
 454
 455 version_fixed:
 456         if (!probe_nfsport(nfs_server))
 457                 goto out_bad;
 458         return probe_mntport(mnt_server);
 459 }
 460
 461 static int probe_statd(void)
 462 {
 463         struct sockaddr_in addr;
 464         unsigned short port;
 465
 466         memset(&addr, 0, sizeof(addr));
 467         addr.sin_family = AF_INET;
 468         addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 469         port = getport(&addr, 100024, 1, IPPROTO_UDP);
 470
 471         if (port == 0)
 472                 return 0;
 473         addr.sin_port = htons(port);
 474
 475         if (clnt_ping(&addr, 100024, 1, IPPROTO_UDP, NULL) <= 0)
 476                 return 0;
 477
 478         return 1;
 479 }
 480
 481 /*
 482  * Attempt to start rpc.statd
 483  */
 484 int start_statd(void)
 485 {
 486 #ifdef START_STATD
 487         struct stat stb;
 488 #endif
 489
 490         if (probe_statd())
 491                 return 1;
 492
 493 #ifdef START_STATD
 494         if (stat(START_STATD, &stb) == 0) {
 495                 if (S_ISREG(stb.st_mode) && (stb.st_mode & S_IXUSR)) {
 496                         system(START_STATD);
 497                         if (probe_statd())
 498                                 return 1;
 499                 }
 500         }
 501 #endif
 502
 503         return 0;
 504 }
 505
 506 /*
 507  * nfs_call_umount - ask the server to remove a share from it's rmtab
 508  * @mnt_server: address of RPC MNT program server
 509  * @argp: directory path of share to "unmount"
 510  *
 511  * Returns one if the unmount call succeeded; zero if the unmount
 512  * failed for any reason.
 513  *
 514  * Note that a side effect of calling this function is that rpccreateerr
 515  * is set.
 516  */
 517 int nfs_call_umount(clnt_addr_t *mnt_server, dirpath *argp)
 518 {
 519         CLIENT *clnt;
 520         enum clnt_stat res = 0;
 521         int msock;
 522
 523         switch (mnt_server->pmap.pm_vers) {
 524         case 3:
 525         case 2:
 526         case 1:
 527                 if (!probe_mntport(mnt_server))
 528                         return 0;
 529                 clnt = mnt_openclnt(mnt_server, &msock);
 530                 if (!clnt)
 531                         return 0;
 532                 res = clnt_call(clnt, MOUNTPROC_UMNT,
 533                                 (xdrproc_t)xdr_dirpath, (caddr_t)argp,
 534                                 (xdrproc_t)xdr_void, NULL,
 535                                 TIMEOUT);
 536                 mnt_closeclnt(clnt, msock);
 537                 if (res == RPC_SUCCESS)
 538                         return 1;
 539                 break;
 540         default:
 541                 res = RPC_SUCCESS;
 542                 break;
 543         }
 544
 545         if (res == RPC_SUCCESS)
 546                 return 1;
 547         return 0;
 548 }
 549
 550 CLIENT *mnt_openclnt(clnt_addr_t *mnt_server, int *msock)
 551 {
 552         struct sockaddr_in *mnt_saddr = &mnt_server->saddr;
 553         struct pmap *mnt_pmap = &mnt_server->pmap;
 554         CLIENT *clnt = NULL;
 555
 556         mnt_saddr->sin_port = htons((u_short)mnt_pmap->pm_port);
 557         *msock = get_socket(mnt_saddr, mnt_pmap->pm_prot, TRUE, FALSE);
 558         if (*msock == RPC_ANYSOCK) {
 559                 if (rpc_createerr.cf_error.re_errno == EADDRINUSE)
 560                         /*
 561                          * Probably in-use by a TIME_WAIT connection,
 562                          * It is worth waiting a while and trying again.
 563                          */
 564                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
 565                 return NULL;
 566         }
 567
 568         switch (mnt_pmap->pm_prot) {
 569         case IPPROTO_UDP:
 570                 clnt = clntudp_bufcreate(mnt_saddr,
 571                                          mnt_pmap->pm_prog, mnt_pmap->pm_vers,
 572                                          RETRY_TIMEOUT, msock,
 573                                          MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 574                 break;
 575         case IPPROTO_TCP:
 576                 clnt = clnttcp_create(mnt_saddr,
 577                                       mnt_pmap->pm_prog, mnt_pmap->pm_vers,
 578                                       msock,
 579                                       MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 580                 break;
 581         }
 582         if (clnt) {
 583                 /* try to mount hostname:dirname */
 584                 clnt->cl_auth = authunix_create_default();
 585                 return clnt;
 586         }
 587         return NULL;
 588 }
 589
 590 void mnt_closeclnt(CLIENT *clnt, int msock)
 591 {
 592         auth_destroy(clnt->cl_auth);
 593         clnt_destroy(clnt);
 594         close(msock);
 595 }
 596
 597 /*
 598  * Sigh... getport() doesn't actually check the version number.
 599  * In order to make sure that the server actually supports the service
 600  * we're requesting, we open and RPC client, and fire off a NULL
 601  * RPC call.
 602  */
 603 int clnt_ping(struct sockaddr_in *saddr, const unsigned long prog,
 604                 const unsigned long vers, const unsigned int prot,
 605                 struct sockaddr_in *caddr)
 606 {
 607         CLIENT *clnt = NULL;
 608         int sock, stat;
 609         static char clnt_res;
 610         struct sockaddr dissolve;
 611
 612         rpc_createerr.cf_stat = stat = errno = 0;
 613         sock = get_socket(saddr, prot, FALSE, TRUE);
 614         if (sock == RPC_ANYSOCK) {
 615                 if (errno == ETIMEDOUT) {
 616                         /*
 617                          * TCP timeout. Bubble up the error to see
 618                          * how it should be handled.
 619                          */
 620                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
 621                 }
 622                 return 0;
 623         }
 624
 625         if (caddr) {
 626                 /* Get the address of our end of this connection */
 627                 socklen_t len = sizeof(*caddr);
 628                 if (getsockname(sock, caddr, &len) != 0)
 629                         caddr->sin_family = 0;
 630         }
 631
 632         switch(prot) {
 633         case IPPROTO_UDP:
 634                 /* The socket is connected (so we could getsockname successfully),
 635                  * but some servers on multi-homed hosts reply from
 636                  * the wrong address, so if we stay connected, we lose the reply.
 637                  */
 638                 dissolve.sa_family = AF_UNSPEC;
 639                 connect(sock, &dissolve, sizeof(dissolve));
 640
 641                 clnt = clntudp_bufcreate(saddr, prog, vers,
 642                                          RETRY_TIMEOUT, &sock,
 643                                          RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 644                 break;
 645         case IPPROTO_TCP:
 646                 clnt = clnttcp_create(saddr, prog, vers, &sock,
 647                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 648                 break;
 649         }
 650         if (!clnt) {
 651                 close(sock);
 652                 return 0;
 653         }
 654         memset(&clnt_res, 0, sizeof(clnt_res));
 655         stat = clnt_call(clnt, NULLPROC,
 656                          (xdrproc_t)xdr_void, (caddr_t)NULL,
 657                          (xdrproc_t)xdr_void, (caddr_t)&clnt_res,
 658                          TIMEOUT);
 659         if (stat) {
 660                 clnt_geterr(clnt, &rpc_createerr.cf_error);
 661                 rpc_createerr.cf_stat = stat;
 662         }
 663         clnt_destroy(clnt);
 664         close(sock);
 665
 666         if (stat == RPC_SUCCESS)
 667                 return 1;
 668         else
 669                 return 0;
 670 }