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                 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 176                 rpc_createerr.cf_error.re_errno = errno;
 177                 if (verbose) {
 178                         fprintf(stderr,
 179                                 "mount: Unable to create %s socket: errno %d (%s)\n",
 180                                 p_prot == IPPROTO_UDP ? "UDP" : "TCP",
 181                                 errno, strerror(errno));
 182                 }
 183                 return RPC_ANYSOCK;
 184         }
 185         laddr.sin_family = AF_INET;
 186         laddr.sin_port = 0;
 187         laddr.sin_addr.s_addr = htonl(INADDR_ANY);
 188         if (resvp) {
 189                 if (bindresvport(so, &laddr) < 0) {
 190                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 191                         rpc_createerr.cf_error.re_errno = errno;
 192                         if (verbose) {
 193                                 fprintf(stderr,
 194                                         "mount: Unable to bindresvport %s socket: errno %d (%s)\n",
 195                                         p_prot == IPPROTO_UDP ? "UDP" : "TCP",
 196                                         errno, strerror(errno));
 197                         }
 198                         close(so);
 199                         return RPC_ANYSOCK;
 200                 }
 201         } else {
 202                 cc = bind(so, (struct sockaddr *)&laddr, namelen);
 203                 if (cc < 0) {
 204                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 205                         rpc_createerr.cf_error.re_errno = errno;
 206                         if (verbose) {
 207                                 fprintf(stderr,
 208                                         "mount: Unable to bind to %s socket: errno %d (%s)\n",
 209                                         p_prot == IPPROTO_UDP ? "UDP" : "TCP",
 210                                         errno, strerror(errno));
 211                         }
 212                         close(so);
 213                         return RPC_ANYSOCK;
 214                 }
 215         }
 216         if (type == SOCK_STREAM || (conn && type == SOCK_DGRAM)) {
 217                 cc = connect(so, (struct sockaddr *)saddr, namelen);
 218                 if (cc < 0) {
 219                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 220                         rpc_createerr.cf_error.re_errno = errno;
 221                         if (verbose) {
 222                                 fprintf(stderr,
 223                                         "mount: Unable to connect to %s:%d, errno %d (%s)\n",
 224                                         inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port),
 225                                         errno, strerror(errno));
 226                         }
 227                         close(so);
 228                         return RPC_ANYSOCK;
 229                 }
 230         }
 231         return so;
 232 }
 233
 234 /*
 235  * getport() is very similar to pmap_getport() with the exception that
 236  * this version tries to use an ephemeral port, since reserved ports are
 237  * not needed for GETPORT queries.  This conserves the very limited
 238  * reserved port space, which helps reduce failed socket binds
 239  * during mount storms.
 240  *
 241  * A side effect of calling this function is that rpccreateerr is set.
 242  */
 243 static unsigned short getport(struct sockaddr_in *saddr,
 244                                 unsigned long program,
 245                                 unsigned long version,
 246                                 unsigned int proto)
 247 {
 248         unsigned short port = 0;
 249         int socket;
 250         CLIENT *clnt = NULL;
 251         enum clnt_stat stat;
 252
 253         saddr->sin_port = htons(PMAPPORT);
 254
 255         /*
 256          * Try to get a socket with a non-privileged port.
 257          * clnt*create() will create one anyway if this
 258          * fails.
 259          */
 260         socket = get_socket(saddr, proto, FALSE, FALSE);
 261         if (socket == RPC_ANYSOCK) {
 262                 if (proto == IPPROTO_TCP && errno == ETIMEDOUT) {
 263                         /*
 264                          * TCP SYN timed out, so exit now.
 265                          */
 266                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
 267                 }
 268                 return 0;
 269         }
 270
 271         switch (proto) {
 272         case IPPROTO_UDP:
 273                 clnt = clntudp_bufcreate(saddr,
 274                                          PMAPPROG, PMAPVERS,
 275                                          RETRY_TIMEOUT, &socket,
 276                                          RPCSMALLMSGSIZE,
 277                                          RPCSMALLMSGSIZE);
 278                 break;
 279         case IPPROTO_TCP:
 280                 clnt = clnttcp_create(saddr, PMAPPROG, PMAPVERS, &socket,
 281                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 282                 break;
 283         }
 284         if (clnt != NULL) {
 285                 struct pmap parms = {
 286                         .pm_prog        = program,
 287                         .pm_vers        = version,
 288                         .pm_prot        = proto,
 289                 };
 290
 291                 stat = clnt_call(clnt, PMAPPROC_GETPORT,
 292                                  (xdrproc_t)xdr_pmap, (caddr_t)&parms,
 293                                  (xdrproc_t)xdr_u_short, (caddr_t)&port,
 294                                  TIMEOUT);
 295                 if (stat) {
 296                         clnt_geterr(clnt, &rpc_createerr.cf_error);
 297                         rpc_createerr.cf_stat = stat;
 298                 }
 299                 clnt_destroy(clnt);
 300                 if (stat != RPC_SUCCESS)
 301                         port = 0;
 302                 else if (port == 0)
 303                         rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
 304         }
 305         if (socket != 1)
 306                 close(socket);
 307
 308         return port;
 309 }
 310
 311 /*
 312  * Use the portmapper to discover whether or not the service we want is
 313  * available. The lists 'versions' and 'protos' define ordered sequences
 314  * of service versions and udp/tcp protocols to probe for.
 315  */
 316 static int probe_port(clnt_addr_t *server, const unsigned long *versions,
 317                         const unsigned int *protos)
 318 {
 319         struct sockaddr_in *saddr = &server->saddr;
 320         struct pmap *pmap = &server->pmap;
 321         const unsigned long prog = pmap->pm_prog, *p_vers;
 322         const unsigned int prot = (u_int)pmap->pm_prot, *p_prot;
 323         const u_short port = (u_short) pmap->pm_port;
 324         unsigned long vers = pmap->pm_vers;
 325         unsigned short p_port;
 326
 327         p_prot = prot ? &prot : protos;
 328         p_vers = vers ? &vers : versions;
 329         rpc_createerr.cf_stat = 0;
 330         for (;;) {
 331                 saddr->sin_port = htons(PMAPPORT);
 332                 p_port = getport(saddr, prog, *p_vers, *p_prot);
 333                 if (p_port) {
 334                         if (!port || port == p_port) {
 335                                 saddr->sin_port = htons(p_port);
 336                                 if (verbose) {
 337                                         printf(_("%s: trying %s prog %ld vers "
 338                                                 "%ld prot %s port %d\n"),
 339                                                 progname,
 340                                                 inet_ntoa(saddr->sin_addr),
 341                                                 prog, *p_vers,
 342                                                 *p_prot == IPPROTO_UDP ?
 343                                                         "udp" : "tcp",
 344                                                 p_port);
 345                                 }
 346                                 if (clnt_ping(saddr, prog, *p_vers, *p_prot, NULL))
 347                                         goto out_ok;
 348                                 if (rpc_createerr.cf_stat == RPC_TIMEDOUT)
 349                                         goto out_bad;
 350                         }
 351                 }
 352                 if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED)
 353                         goto out_bad;
 354
 355                 if (!prot) {
 356                         if (*++p_prot)
 357                                 continue;
 358                         p_prot = protos;
 359                 }
 360                 if (vers == pmap->pm_vers) {
 361                         p_vers = versions;
 362                         vers = 0;
 363                 }
 364                 if (vers || !*++p_vers)
 365                         break;
 366         }
 367
 368 out_bad:
 369         return 0;
 370
 371 out_ok:
 372         if (!vers)
 373                 pmap->pm_vers = *p_vers;
 374         if (!prot)
 375                 pmap->pm_prot = *p_prot;
 376         if (!port)
 377                 pmap->pm_port = p_port;
 378         rpc_createerr.cf_stat = 0;
 379         return 1;
 380 }
 381
 382 static int probe_nfsport(clnt_addr_t *nfs_server)
 383 {
 384         struct pmap *pmap = &nfs_server->pmap;
 385
 386         if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
 387                 return 1;
 388
 389         if (nfs_mount_data_version >= 4)
 390                 return probe_port(nfs_server, probe_nfs3_first, probe_tcp_first);
 391         else
 392                 return probe_port(nfs_server, probe_nfs2_only, probe_udp_only);
 393 }
 394
 395 static int probe_mntport(clnt_addr_t *mnt_server)
 396 {
 397         struct pmap *pmap = &mnt_server->pmap;
 398
 399         if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
 400                 return 1;
 401
 402         if (nfs_mount_data_version >= 4)
 403                 return probe_port(mnt_server, probe_mnt3_first, probe_udp_first);
 404         else
 405                 return probe_port(mnt_server, probe_mnt1_first, probe_udp_only);
 406 }
 407
 408 int probe_bothports(clnt_addr_t *mnt_server, clnt_addr_t *nfs_server)
 409 {
 410         struct pmap *nfs_pmap = &nfs_server->pmap;
 411         struct pmap *mnt_pmap = &mnt_server->pmap;
 412         struct pmap save_nfs, save_mnt;
 413         int res;
 414         const unsigned long *probe_vers;
 415
 416         if (mnt_pmap->pm_vers && !nfs_pmap->pm_vers)
 417                 nfs_pmap->pm_vers = mntvers_to_nfs(mnt_pmap->pm_vers);
 418         else if (nfs_pmap->pm_vers && !mnt_pmap->pm_vers)
 419                 mnt_pmap->pm_vers = nfsvers_to_mnt(nfs_pmap->pm_vers);
 420         if (nfs_pmap->pm_vers)
 421                 goto version_fixed;
 422
 423         memcpy(&save_nfs, nfs_pmap, sizeof(save_nfs));
 424         memcpy(&save_mnt, mnt_pmap, sizeof(save_mnt));
 425         probe_vers = (nfs_mount_data_version >= 4) ?
 426                         probe_mnt3_first : probe_mnt1_first;
 427
 428         for (; *probe_vers; probe_vers++) {
 429                 nfs_pmap->pm_vers = mntvers_to_nfs(*probe_vers);
 430                 if ((res = probe_nfsport(nfs_server) != 0)) {
 431                         mnt_pmap->pm_vers = nfsvers_to_mnt(nfs_pmap->pm_vers);
 432                         if ((res = probe_mntport(mnt_server)) != 0)
 433                                 return 1;
 434                         memcpy(mnt_pmap, &save_mnt, sizeof(*mnt_pmap));
 435                 }
 436                 switch (rpc_createerr.cf_stat) {
 437                 case RPC_PROGVERSMISMATCH:
 438                 case RPC_PROGNOTREGISTERED:
 439                         break;
 440                 default:
 441                         goto out_bad;
 442                 }
 443                 memcpy(nfs_pmap, &save_nfs, sizeof(*nfs_pmap));
 444         }
 445
 446 out_bad:
 447         return 0;
 448
 449 version_fixed:
 450         if (!probe_nfsport(nfs_server))
 451                 goto out_bad;
 452         return probe_mntport(mnt_server);
 453 }
 454
 455 static int probe_statd(void)
 456 {
 457         struct sockaddr_in addr;
 458         unsigned short port;
 459
 460         memset(&addr, 0, sizeof(addr));
 461         addr.sin_family = AF_INET;
 462         addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 463         port = getport(&addr, 100024, 1, IPPROTO_UDP);
 464
 465         if (port == 0)
 466                 return 0;
 467         addr.sin_port = htons(port);
 468
 469         if (clnt_ping(&addr, 100024, 1, IPPROTO_UDP, NULL) <= 0)
 470                 return 0;
 471
 472         return 1;
 473 }
 474
 475 /*
 476  * Attempt to start rpc.statd
 477  */
 478 int start_statd(void)
 479 {
 480 #ifdef START_STATD
 481         struct stat stb;
 482 #endif
 483
 484         if (probe_statd())
 485                 return 1;
 486
 487 #ifdef START_STATD
 488         if (stat(START_STATD, &stb) == 0) {
 489                 if (S_ISREG(stb.st_mode) && (stb.st_mode & S_IXUSR)) {
 490                         system(START_STATD);
 491                         if (probe_statd())
 492                                 return 1;
 493                 }
 494         }
 495 #endif
 496
 497         return 0;
 498 }
 499
 500 /*
 501  * nfs_call_umount - ask the server to remove a share from it's rmtab
 502  * @mnt_server: address of RPC MNT program server
 503  * @argp: directory path of share to "unmount"
 504  *
 505  * Returns one if the unmount call succeeded; zero if the unmount
 506  * failed for any reason.
 507  *
 508  * Note that a side effect of calling this function is that rpccreateerr
 509  * is set.
 510  */
 511 int nfs_call_umount(clnt_addr_t *mnt_server, dirpath *argp)
 512 {
 513         CLIENT *clnt;
 514         enum clnt_stat res = 0;
 515         int msock;
 516
 517         switch (mnt_server->pmap.pm_vers) {
 518         case 3:
 519         case 2:
 520         case 1:
 521                 if (!probe_mntport(mnt_server))
 522                         return 0;
 523                 clnt = mnt_openclnt(mnt_server, &msock);
 524                 if (!clnt)
 525                         return 0;
 526                 res = clnt_call(clnt, MOUNTPROC_UMNT,
 527                                 (xdrproc_t)xdr_dirpath, (caddr_t)argp,
 528                                 (xdrproc_t)xdr_void, NULL,
 529                                 TIMEOUT);
 530                 mnt_closeclnt(clnt, msock);
 531                 if (res == RPC_SUCCESS)
 532                         return 1;
 533                 break;
 534         default:
 535                 res = RPC_SUCCESS;
 536                 break;
 537         }
 538
 539         if (res == RPC_SUCCESS)
 540                 return 1;
 541         return 0;
 542 }
 543
 544 CLIENT *mnt_openclnt(clnt_addr_t *mnt_server, int *msock)
 545 {
 546         struct sockaddr_in *mnt_saddr = &mnt_server->saddr;
 547         struct pmap *mnt_pmap = &mnt_server->pmap;
 548         CLIENT *clnt = NULL;
 549
 550         mnt_saddr->sin_port = htons((u_short)mnt_pmap->pm_port);
 551         *msock = get_socket(mnt_saddr, mnt_pmap->pm_prot, TRUE, FALSE);
 552         if (*msock == RPC_ANYSOCK) {
 553                 if (rpc_createerr.cf_error.re_errno == EADDRINUSE)
 554                         /*
 555                          * Probably in-use by a TIME_WAIT connection,
 556                          * It is worth waiting a while and trying again.
 557                          */
 558                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
 559                 return NULL;
 560         }
 561
 562         switch (mnt_pmap->pm_prot) {
 563         case IPPROTO_UDP:
 564                 clnt = clntudp_bufcreate(mnt_saddr,
 565                                          mnt_pmap->pm_prog, mnt_pmap->pm_vers,
 566                                          RETRY_TIMEOUT, msock,
 567                                          MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 568                 break;
 569         case IPPROTO_TCP:
 570                 clnt = clnttcp_create(mnt_saddr,
 571                                       mnt_pmap->pm_prog, mnt_pmap->pm_vers,
 572                                       msock,
 573                                       MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 574                 break;
 575         }
 576         if (clnt) {
 577                 /* try to mount hostname:dirname */
 578                 clnt->cl_auth = authunix_create_default();
 579                 return clnt;
 580         }
 581         return NULL;
 582 }
 583
 584 void mnt_closeclnt(CLIENT *clnt, int msock)
 585 {
 586         auth_destroy(clnt->cl_auth);
 587         clnt_destroy(clnt);
 588         close(msock);
 589 }
 590
 591 /*
 592  * Sigh... getport() doesn't actually check the version number.
 593  * In order to make sure that the server actually supports the service
 594  * we're requesting, we open and RPC client, and fire off a NULL
 595  * RPC call.
 596  */
 597 int clnt_ping(struct sockaddr_in *saddr, const unsigned long prog,
 598                 const unsigned long vers, const unsigned int prot,
 599                 struct sockaddr_in *caddr)
 600 {
 601         CLIENT *clnt = NULL;
 602         int sock, stat;
 603         static char clnt_res;
 604         struct sockaddr dissolve;
 605
 606         rpc_createerr.cf_stat = stat = errno = 0;
 607         sock = get_socket(saddr, prot, FALSE, TRUE);
 608         if (sock == RPC_ANYSOCK) {
 609                 if (errno == ETIMEDOUT) {
 610                         /*
 611                          * TCP timeout. Bubble up the error to see
 612                          * how it should be handled.
 613                          */
 614                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
 615                 }
 616                 return 0;
 617         }
 618
 619         if (caddr) {
 620                 /* Get the address of our end of this connection */
 621                 socklen_t len = sizeof(*caddr);
 622                 if (getsockname(sock, caddr, &len) != 0)
 623                         caddr->sin_family = 0;
 624         }
 625
 626         switch(prot) {
 627         case IPPROTO_UDP:
 628                 /* The socket is connected (so we could getsockname successfully),
 629                  * but some servers on multi-homed hosts reply from
 630                  * the wrong address, so if we stay connected, we lose the reply.
 631                  */
 632                 dissolve.sa_family = AF_UNSPEC;
 633                 connect(sock, &dissolve, sizeof(dissolve));
 634
 635                 clnt = clntudp_bufcreate(saddr, prog, vers,
 636                                          RETRY_TIMEOUT, &sock,
 637                                          RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 638                 break;
 639         case IPPROTO_TCP:
 640                 clnt = clnttcp_create(saddr, prog, vers, &sock,
 641                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 642                 break;
 643         }
 644         if (!clnt) {
 645                 close(sock);
 646                 return 0;
 647         }
 648         memset(&clnt_res, 0, sizeof(clnt_res));
 649         stat = clnt_call(clnt, NULLPROC,
 650                          (xdrproc_t)xdr_void, (caddr_t)NULL,
 651                          (xdrproc_t)xdr_void, (caddr_t)&clnt_res,
 652                          TIMEOUT);
 653         if (stat) {
 654                 clnt_geterr(clnt, &rpc_createerr.cf_error);
 655                 rpc_createerr.cf_stat = stat;
 656         }
 657         clnt_destroy(clnt);
 658         close(sock);
 659
 660         if (stat == RPC_SUCCESS)
 661                 return 1;
 662         else
 663                 return 0;
 664 }