lib/libshare/nfs.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2011 Gunnar Beutner
  25  * Copyright (c) 2012 Cyril Plisko. All rights reserved.
  26  */
  27
  28 #include <stdio.h>
  29 #include <strings.h>
  30 #include <fcntl.h>
  31 #include <sys/wait.h>
  32 #include <unistd.h>
  33 #include <libzfs.h>
  34 #include <libshare.h>
  35 #include "libshare_impl.h"
  36
  37 static boolean_t nfs_available(void);
  38
  39 static sa_fstype_t *nfs_fstype;
  40
  41 /*
  42  * nfs_exportfs_temp_fd refers to a temporary copy of the output
  43  * from exportfs -v.
  44  */
  45 static int nfs_exportfs_temp_fd = -1;
  46
  47 typedef int (*nfs_shareopt_callback_t)(const char *opt, const char *value,
  48     void *cookie);
  49
  50 typedef int (*nfs_host_callback_t)(const char *sharepath, const char *host,
  51     const char *security, const char *access, void *cookie);
  52
  53 /*
  54  * Invokes the specified callback function for each Solaris share option
  55  * listed in the specified string.
  56  */
  57 static int
  58 foreach_nfs_shareopt(const char *shareopts,
  59     nfs_shareopt_callback_t callback, void *cookie)
  60 {
  61         char *shareopts_dup, *opt, *cur, *value;
  62         int was_nul, rc;
  63
  64         if (shareopts == NULL)
  65                 return (SA_OK);
  66
  67         shareopts_dup = strdup(shareopts);
  68
  69         if (shareopts_dup == NULL)
  70                 return (SA_NO_MEMORY);
  71
  72         opt = shareopts_dup;
  73         was_nul = 0;
  74
  75         while (1) {
  76                 cur = opt;
  77
  78                 while (*cur != ',' && *cur != '\0')
  79                         cur++;
  80
  81                 if (*cur == '\0')
  82                         was_nul = 1;
  83
  84                 *cur = '\0';
  85
  86                 if (cur > opt) {
  87                         value = strchr(opt, '=');
  88
  89                         if (value != NULL) {
  90                                 *value = '\0';
  91                                 value++;
  92                         }
  93
  94                         rc = callback(opt, value, cookie);
  95
  96                         if (rc != SA_OK) {
  97                                 free(shareopts_dup);
  98                                 return (rc);
  99                         }
 100                 }
 101
 102                 opt = cur + 1;
 103
 104                 if (was_nul)
 105                         break;
 106         }
 107
 108         free(shareopts_dup);
 109
 110         return (0);
 111 }
 112
 113 typedef struct nfs_host_cookie_s {
 114         nfs_host_callback_t callback;
 115         const char *sharepath;
 116         void *cookie;
 117         const char *security;
 118 } nfs_host_cookie_t;
 119
 120 /*
 121  * Helper function for foreach_nfs_host. This function checks whether the
 122  * current share option is a host specification and invokes a callback
 123  * function with information about the host.
 124  */
 125 static int
 126 foreach_nfs_host_cb(const char *opt, const char *value, void *pcookie)
 127 {
 128         int rc;
 129         const char *access;
 130         char *host_dup, *host, *next;
 131         nfs_host_cookie_t *udata = (nfs_host_cookie_t *)pcookie;
 132
 133 #ifdef DEBUG
 134         fprintf(stderr, "foreach_nfs_host_cb: key=%s, value=%s\n", opt, value);
 135 #endif
 136
 137         if (strcmp(opt, "sec") == 0)
 138                 udata->security = value;
 139
 140         if (strcmp(opt, "rw") == 0 || strcmp(opt, "ro") == 0) {
 141                 if (value == NULL)
 142                         value = "*";
 143
 144                 access = opt;
 145
 146                 host_dup = strdup(value);
 147
 148                 if (host_dup == NULL)
 149                         return (SA_NO_MEMORY);
 150
 151                 host = host_dup;
 152
 153                 do {
 154                         next = strchr(host, ':');
 155                         if (next != NULL) {
 156                                 *next = '\0';
 157                                 next++;
 158                         }
 159
 160                         rc = udata->callback(udata->sharepath, host,
 161                             udata->security, access, udata->cookie);
 162
 163                         if (rc != SA_OK) {
 164                                 free(host_dup);
 165
 166                                 return (rc);
 167                         }
 168
 169                         host = next;
 170                 } while (host != NULL);
 171
 172                 free(host_dup);
 173         }
 174
 175         return (SA_OK);
 176 }
 177
 178 /*
 179  * Invokes a callback function for all NFS hosts that are set for a share.
 180  */
 181 static int
 182 foreach_nfs_host(sa_share_impl_t impl_share, nfs_host_callback_t callback,
 183     void *cookie)
 184 {
 185         nfs_host_cookie_t udata;
 186         char *shareopts;
 187
 188         udata.callback = callback;
 189         udata.sharepath = impl_share->sharepath;
 190         udata.cookie = cookie;
 191         udata.security = "sys";
 192
 193         shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;
 194
 195         return foreach_nfs_shareopt(shareopts, foreach_nfs_host_cb,
 196             &udata);
 197 }
 198
 199 /*
 200  * Converts a Solaris NFS host specification to its Linux equivalent.
 201  */
 202 static int
 203 get_linux_hostspec(const char *solaris_hostspec, char **plinux_hostspec)
 204 {
 205         /*
 206          * For now we just support CIDR masks (e.g. @192.168.0.0/16) and host
 207          * wildcards (e.g. *.example.org).
 208          */
 209         if (solaris_hostspec[0] == '@') {
 210                 /*
 211                  * Solaris host specifier, e.g. @192.168.0.0/16; we just need
 212                  * to skip the @ in this case
 213                  */
 214                 *plinux_hostspec = strdup(solaris_hostspec + 1);
 215         } else {
 216                 *plinux_hostspec = strdup(solaris_hostspec);
 217         }
 218
 219         if (*plinux_hostspec == NULL) {
 220                 return (SA_NO_MEMORY);
 221         }
 222
 223         return (SA_OK);
 224 }
 225
 226 /*
 227  * Used internally by nfs_enable_share to enable sharing for a single host.
 228  */
 229 static int
 230 nfs_enable_share_one(const char *sharepath, const char *host,
 231     const char *security, const char *access, void *pcookie)
 232 {
 233         int rc;
 234         char *linuxhost, *hostpath, *opts;
 235         const char *linux_opts = (const char *)pcookie;
 236         char *argv[6];
 237
 238         /* exportfs -i -o sec=XX,rX,<opts> <host>:<sharepath> */
 239
 240         rc = get_linux_hostspec(host, &linuxhost);
 241
 242         if (rc < 0)
 243                 exit(1);
 244
 245         hostpath = malloc(strlen(linuxhost) + 1 + strlen(sharepath) + 1);
 246
 247         if (hostpath == NULL) {
 248                 free(linuxhost);
 249
 250                 exit(1);
 251         }
 252
 253         sprintf(hostpath, "%s:%s", linuxhost, sharepath);
 254
 255         free(linuxhost);
 256
 257         if (linux_opts == NULL)
 258                 linux_opts = "";
 259
 260         opts = malloc(4 + strlen(security) + 4 + strlen(linux_opts) + 1);
 261
 262         if (opts == NULL)
 263                 exit(1);
 264
 265         sprintf(opts, "sec=%s,%s,%s", security, access, linux_opts);
 266
 267 #ifdef DEBUG
 268         fprintf(stderr, "sharing %s with opts %s\n", hostpath, opts);
 269 #endif
 270
 271         argv[0] = "/usr/sbin/exportfs";
 272         argv[1] = "-i";
 273         argv[2] = "-o";
 274         argv[3] = opts;
 275         argv[4] = hostpath;
 276         argv[5] = NULL;
 277
 278         rc = libzfs_run_process(argv[0], argv, 0);
 279
 280         free(hostpath);
 281         free(opts);
 282
 283         if (rc < 0)
 284                 return (SA_SYSTEM_ERR);
 285         else
 286                 return (SA_OK);
 287 }
 288
 289 /*
 290  * Adds a Linux share option to an array of NFS options.
 291  */
 292 static int
 293 add_linux_shareopt(char **plinux_opts, const char *key, const char *value)
 294 {
 295         size_t len = 0;
 296         char *new_linux_opts;
 297
 298         if (*plinux_opts != NULL)
 299                 len = strlen(*plinux_opts);
 300
 301         new_linux_opts = realloc(*plinux_opts, len + 1 + strlen(key) +
 302             (value ? 1 + strlen(value) : 0) + 1);
 303
 304         if (new_linux_opts == NULL)
 305                 return (SA_NO_MEMORY);
 306
 307         new_linux_opts[len] = '\0';
 308
 309         if (len > 0)
 310                 strcat(new_linux_opts, ",");
 311
 312         strcat(new_linux_opts, key);
 313
 314         if (value != NULL) {
 315                 strcat(new_linux_opts, "=");
 316                 strcat(new_linux_opts, value);
 317         }
 318
 319         *plinux_opts = new_linux_opts;
 320
 321         return (SA_OK);
 322 }
 323
 324 /*
 325  * Validates and converts a single Solaris share option to its Linux
 326  * equivalent.
 327  */
 328 static int
 329 get_linux_shareopts_cb(const char *key, const char *value, void *cookie)
 330 {
 331         char **plinux_opts = (char **)cookie;
 332
 333         /* host-specific options, these are taken care of elsewhere */
 334         if (strcmp(key, "ro") == 0 || strcmp(key, "rw") == 0 ||
 335             strcmp(key, "sec") == 0)
 336                 return (SA_OK);
 337
 338         if (strcmp(key, "anon") == 0)
 339                 key = "anonuid";
 340
 341         if (strcmp(key, "root_mapping") == 0) {
 342                 (void) add_linux_shareopt(plinux_opts, "root_squash", NULL);
 343                 key = "anonuid";
 344         }
 345
 346         if (strcmp(key, "nosub") == 0)
 347                 key = "subtree_check";
 348
 349         if (strcmp(key, "insecure") != 0 && strcmp(key, "secure") != 0 &&
 350             strcmp(key, "async") != 0 && strcmp(key, "sync") != 0 &&
 351             strcmp(key, "no_wdelay") != 0 && strcmp(key, "wdelay") != 0 &&
 352             strcmp(key, "nohide") != 0 && strcmp(key, "hide") != 0 &&
 353             strcmp(key, "crossmnt") != 0 &&
 354             strcmp(key, "no_subtree_check") != 0 &&
 355             strcmp(key, "subtree_check") != 0 &&
 356             strcmp(key, "insecure_locks") != 0 &&
 357             strcmp(key, "secure_locks") != 0 &&
 358             strcmp(key, "no_auth_nlm") != 0 && strcmp(key, "auth_nlm") != 0 &&
 359             strcmp(key, "no_acl") != 0 && strcmp(key, "mountpoint") != 0 &&
 360             strcmp(key, "mp") != 0 && strcmp(key, "fsuid") != 0 &&
 361             strcmp(key, "refer") != 0 && strcmp(key, "replicas") != 0 &&
 362             strcmp(key, "root_squash") != 0 &&
 363             strcmp(key, "no_root_squash") != 0 &&
 364             strcmp(key, "all_squash") != 0 &&
 365             strcmp(key, "no_all_squash") != 0 && strcmp(key, "fsid") != 0 &&
 366             strcmp(key, "anonuid") != 0 && strcmp(key, "anongid") != 0) {
 367                 return (SA_SYNTAX_ERR);
 368         }
 369
 370         (void) add_linux_shareopt(plinux_opts, key, value);
 371
 372         return (SA_OK);
 373 }
 374
 375 /*
 376  * Takes a string containing Solaris share options (e.g. "sync,no_acl") and
 377  * converts them to a NULL-terminated array of Linux NFS options.
 378  */
 379 static int
 380 get_linux_shareopts(const char *shareopts, char **plinux_opts)
 381 {
 382         int rc;
 383
 384         assert(plinux_opts != NULL);
 385
 386         *plinux_opts = NULL;
 387
 388         /* default options for Solaris shares */
 389         (void) add_linux_shareopt(plinux_opts, "no_subtree_check", NULL);
 390         (void) add_linux_shareopt(plinux_opts, "no_root_squash", NULL);
 391         (void) add_linux_shareopt(plinux_opts, "mountpoint", NULL);
 392
 393         rc = foreach_nfs_shareopt(shareopts, get_linux_shareopts_cb,
 394             plinux_opts);
 395
 396         if (rc != SA_OK) {
 397                 free(*plinux_opts);
 398                 *plinux_opts = NULL;
 399         }
 400
 401         return (rc);
 402 }
 403
 404 /*
 405  * Enables NFS sharing for the specified share.
 406  */
 407 static int
 408 nfs_enable_share(sa_share_impl_t impl_share)
 409 {
 410         char *shareopts, *linux_opts;
 411         int rc;
 412
 413         if (!nfs_available()) {
 414                 return (SA_SYSTEM_ERR);
 415         }
 416
 417         shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;
 418
 419         if (shareopts == NULL)
 420                 return (SA_OK);
 421
 422         rc = get_linux_shareopts(shareopts, &linux_opts);
 423
 424         if (rc != SA_OK)
 425                 return (rc);
 426
 427         rc = foreach_nfs_host(impl_share, nfs_enable_share_one, linux_opts);
 428
 429         free(linux_opts);
 430
 431         return (rc);
 432 }
 433
 434 /*
 435  * Used internally by nfs_disable_share to disable sharing for a single host.
 436  */
 437 static int
 438 nfs_disable_share_one(const char *sharepath, const char *host,
 439     const char *security, const char *access, void *cookie)
 440 {
 441         int rc;
 442         char *linuxhost, *hostpath;
 443         char *argv[4];
 444
 445         rc = get_linux_hostspec(host, &linuxhost);
 446
 447         if (rc < 0)
 448                 exit(1);
 449
 450         hostpath = malloc(strlen(linuxhost) + 1 + strlen(sharepath) + 1);
 451
 452         if (hostpath == NULL) {
 453                 free(linuxhost);
 454                 exit(1);
 455         }
 456
 457         sprintf(hostpath, "%s:%s", linuxhost, sharepath);
 458
 459         free(linuxhost);
 460
 461 #ifdef DEBUG
 462         fprintf(stderr, "unsharing %s\n", hostpath);
 463 #endif
 464
 465         argv[0] = "/usr/sbin/exportfs";
 466         argv[1] = "-u";
 467         argv[2] = hostpath;
 468         argv[3] = NULL;
 469
 470         rc = libzfs_run_process(argv[0], argv, 0);
 471
 472         free(hostpath);
 473
 474         if (rc < 0)
 475                 return (SA_SYSTEM_ERR);
 476         else
 477                 return (SA_OK);
 478 }
 479
 480 /*
 481  * Disables NFS sharing for the specified share.
 482  */
 483 static int
 484 nfs_disable_share(sa_share_impl_t impl_share)
 485 {
 486         if (!nfs_available()) {
 487                 /*
 488                  * The share can't possibly be active, so nothing
 489                  * needs to be done to disable it.
 490                  */
 491                 return (SA_OK);
 492         }
 493
 494         return (foreach_nfs_host(impl_share, nfs_disable_share_one, NULL));
 495 }
 496
 497 /*
 498  * Checks whether the specified NFS share options are syntactically correct.
 499  */
 500 static int
 501 nfs_validate_shareopts(const char *shareopts)
 502 {
 503         char *linux_opts;
 504         int rc;
 505
 506         rc = get_linux_shareopts(shareopts, &linux_opts);
 507
 508         if (rc != SA_OK)
 509                 return (rc);
 510
 511         free(linux_opts);
 512
 513         return (SA_OK);
 514 }
 515
 516 /*
 517  * Checks whether a share is currently active.
 518  */
 519 static boolean_t
 520 nfs_is_share_active(sa_share_impl_t impl_share)
 521 {
 522         char line[512];
 523         char *tab, *cur;
 524         FILE *nfs_exportfs_temp_fp;
 525
 526         if (!nfs_available())
 527                 return (B_FALSE);
 528
 529         nfs_exportfs_temp_fp = fdopen(dup(nfs_exportfs_temp_fd), "r");
 530
 531         if (nfs_exportfs_temp_fp == NULL ||
 532             fseek(nfs_exportfs_temp_fp, 0, SEEK_SET) < 0) {
 533                 fclose(nfs_exportfs_temp_fp);
 534                 return (B_FALSE);
 535         }
 536
 537         while (fgets(line, sizeof (line), nfs_exportfs_temp_fp) != NULL) {
 538                 /*
 539                  * exportfs uses separate lines for the share path
 540                  * and the export options when the share path is longer
 541                  * than a certain amount of characters; this ignores
 542                  * the option lines
 543                  */
 544                 if (line[0] == '\t')
 545                         continue;
 546
 547                 tab = strchr(line, '\t');
 548
 549                 if (tab != NULL) {
 550                         *tab = '\0';
 551                         cur = tab - 1;
 552                 } else {
 553                         /*
 554                          * there's no tab character, which means the
 555                          * NFS options are on a separate line; we just
 556                          * need to remove the new-line character
 557                          * at the end of the line
 558                          */
 559                         cur = line + strlen(line) - 1;
 560                 }
 561
 562                 /* remove trailing spaces and new-line characters */
 563                 while (cur >= line && (*cur == ' ' || *cur == '\n'))
 564                         *cur-- = '\0';
 565
 566                 if (strcmp(line, impl_share->sharepath) == 0) {
 567                         fclose(nfs_exportfs_temp_fp);
 568                         return (B_TRUE);
 569                 }
 570         }
 571
 572         fclose(nfs_exportfs_temp_fp);
 573
 574         return (B_FALSE);
 575 }
 576
 577 /*
 578  * Called to update a share's options. A share's options might be out of
 579  * date if the share was loaded from disk (i.e. /etc/dfs/sharetab) and the
 580  * "sharenfs" dataset property has changed in the meantime. This function
 581  * also takes care of re-enabling the share if necessary.
 582  */
 583 static int
 584 nfs_update_shareopts(sa_share_impl_t impl_share, const char *resource,
 585     const char *shareopts)
 586 {
 587         char *shareopts_dup;
 588         boolean_t needs_reshare = B_FALSE;
 589         char *old_shareopts;
 590
 591         FSINFO(impl_share, nfs_fstype)->active =
 592             nfs_is_share_active(impl_share);
 593
 594         old_shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;
 595
 596         if (strcmp(shareopts, "on") == 0)
 597                 shareopts = "rw";
 598
 599         if (FSINFO(impl_share, nfs_fstype)->active && old_shareopts != NULL &&
 600             strcmp(old_shareopts, shareopts) != 0) {
 601                 needs_reshare = B_TRUE;
 602                 nfs_disable_share(impl_share);
 603         }
 604
 605         shareopts_dup = strdup(shareopts);
 606
 607         if (shareopts_dup == NULL)
 608                 return (SA_NO_MEMORY);
 609
 610         if (old_shareopts != NULL)
 611                 free(old_shareopts);
 612
 613         FSINFO(impl_share, nfs_fstype)->shareopts = shareopts_dup;
 614
 615         if (needs_reshare)
 616                 nfs_enable_share(impl_share);
 617
 618         return (SA_OK);
 619 }
 620
 621 /*
 622  * Clears a share's NFS options. Used by libshare to
 623  * clean up shares that are about to be free()'d.
 624  */
 625 static void
 626 nfs_clear_shareopts(sa_share_impl_t impl_share)
 627 {
 628         free(FSINFO(impl_share, nfs_fstype)->shareopts);
 629         FSINFO(impl_share, nfs_fstype)->shareopts = NULL;
 630 }
 631
 632 static const sa_share_ops_t nfs_shareops = {
 633         .enable_share = nfs_enable_share,
 634         .disable_share = nfs_disable_share,
 635
 636         .validate_shareopts = nfs_validate_shareopts,
 637         .update_shareopts = nfs_update_shareopts,
 638         .clear_shareopts = nfs_clear_shareopts,
 639 };
 640
 641 /*
 642  * nfs_check_exportfs() checks that the exportfs command runs
 643  * and also maintains a temporary copy of the output from
 644  * exportfs -v.
 645  * To update this temporary copy simply call this function again.
 646  *
 647  * TODO : Use /var/lib/nfs/etab instead of our private copy.
 648  *        But must implement locking to prevent concurrent access.
 649  *
 650  * TODO : The temporary file descriptor is never closed since
 651  *        there is no libshare_nfs_fini() function.
 652  */
 653 static int
 654 nfs_check_exportfs(void)
 655 {
 656         pid_t pid;
 657         int rc, status;
 658         static char nfs_exportfs_tempfile[] = "/tmp/exportfs.XXXXXX";
 659
 660         /*
 661          * Close any existing temporary copies of output from exportfs.
 662          * We have already called unlink() so file will be deleted.
 663          */
 664         if (nfs_exportfs_temp_fd >= 0)
 665                 close(nfs_exportfs_temp_fd);
 666
 667         nfs_exportfs_temp_fd = mkstemp(nfs_exportfs_tempfile);
 668
 669         if (nfs_exportfs_temp_fd < 0)
 670                 return (SA_SYSTEM_ERR);
 671
 672         unlink(nfs_exportfs_tempfile);
 673
 674         fcntl(nfs_exportfs_temp_fd, F_SETFD, FD_CLOEXEC);
 675
 676         pid = fork();
 677
 678         if (pid < 0) {
 679                 (void) close(nfs_exportfs_temp_fd);
 680                 nfs_exportfs_temp_fd = -1;
 681                 return (SA_SYSTEM_ERR);
 682         }
 683
 684         if (pid > 0) {
 685                 while ((rc = waitpid(pid, &status, 0)) <= 0 && errno == EINTR);
 686
 687                 if (rc <= 0) {
 688                         (void) close(nfs_exportfs_temp_fd);
 689                         nfs_exportfs_temp_fd = -1;
 690                         return (SA_SYSTEM_ERR);
 691                 }
 692
 693                 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
 694                         (void) close(nfs_exportfs_temp_fd);
 695                         nfs_exportfs_temp_fd = -1;
 696                         return (SA_CONFIG_ERR);
 697                 }
 698
 699                 return (SA_OK);
 700         }
 701
 702         /* child */
 703
 704         /* exportfs -v */
 705
 706         if (dup2(nfs_exportfs_temp_fd, STDOUT_FILENO) < 0)
 707                 exit(1);
 708
 709         rc = execlp("/usr/sbin/exportfs", "exportfs", "-v", NULL);
 710
 711         if (rc < 0) {
 712                 exit(1);
 713         }
 714
 715         exit(0);
 716 }
 717
 718 /*
 719  * Provides a convenient wrapper for determing nfs availability
 720  */
 721 static boolean_t
 722 nfs_available(void)
 723 {
 724         if (nfs_exportfs_temp_fd == -1)
 725                 (void) nfs_check_exportfs();
 726
 727         return ((nfs_exportfs_temp_fd != -1) ? B_TRUE : B_FALSE);
 728 }
 729
 730 /*
 731  * Initializes the NFS functionality of libshare.
 732  */
 733 void
 734 libshare_nfs_init(void)
 735 {
 736         nfs_fstype = register_fstype("nfs", &nfs_shareops);
 737 }