usr/src/cmd/dfs.cmds/sharectl/sharectl.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 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  * Copyright 2012 Milan Jurik. All rights reserved.
  26  * Copyright 2016 Nexenta Systems, Inc.
  27  */
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <unistd.h>
  34 #include <getopt.h>
  35 #include <libgen.h>
  36
  37 #include "libshare.h"
  38 #include <sharemgr.h>
  39
  40 #include <libintl.h>
  41 #include <locale.h>
  42
  43 static int run_command(char *, int, char **, sa_handle_t);
  44 static void sub_command_help(char *proto);
  45
  46 static void
  47 global_help()
  48 {
  49         (void) printf(gettext("usage: sharectl <subcommand> [<options>]\n"));
  50         sub_command_help(NULL);
  51 }
  52
  53 int
  54 main(int argc, char *argv[])
  55 {
  56         int c;
  57         int help = 0;
  58         int rval;
  59         char *command;
  60         sa_handle_t handle;
  61
  62         /*
  63          * make sure locale and gettext domain is setup
  64          */
  65         (void) setlocale(LC_ALL, "");
  66         (void) textdomain(TEXT_DOMAIN);
  67
  68         handle = sa_init(SA_INIT_CONTROL_API);
  69
  70         while ((c = getopt(argc, argv, "h?")) != EOF) {
  71                 switch (c) {
  72                 case '?':
  73                 case 'h':
  74                         help = 1;
  75                         break;
  76                 default:
  77                         (void) printf(gettext("Invalid option: %c\n"), c);
  78                 }
  79         }
  80         if (optind == argc || help) {
  81                 /* no subcommand */
  82                 global_help();
  83                 exit(0);
  84         }
  85         optind = 1;
  86
  87         /*
  88          * now have enough to parse rest of command line
  89          */
  90         command = argv[optind];
  91         rval = run_command(command, argc - optind, argv + optind, handle);
  92
  93         sa_fini(handle);
  94         return (rval);
  95 }
  96
  97 char *
  98 sc_get_usage(sc_usage_t index)
  99 {
 100         char *ret = NULL;
 101
 102         switch (index) {
 103         case USAGE_CTL_DELSECT:
 104                 ret = gettext("delsect\t<section> <proto>");
 105                 break;
 106         case USAGE_CTL_GET:
 107                 ret = gettext("get\t[-p <property>]... <proto>");
 108                 break;
 109         case USAGE_CTL_SET:
 110                 ret = gettext("set\t{-p <property>=<value>}... <proto>");
 111                 break;
 112         case USAGE_CTL_STATUS:
 113                 ret = gettext("status\t[<proto>]...");
 114                 break;
 115         }
 116         return (ret);
 117 }
 118
 119 /*ARGSUSED*/
 120 static int
 121 sc_get(sa_handle_t handle, int flags, int argc, char *argv[])
 122 {
 123         char *proto = NULL;
 124         struct options *optlist = NULL;
 125         int ret = SA_OK;
 126         int c;
 127         sa_protocol_properties_t propset, propsect;
 128         sa_property_t prop;
 129         char *section, *value, *name;
 130         int first = 1;
 131
 132         while ((c = getopt(argc, argv, "?hp:")) != EOF) {
 133                 switch (c) {
 134                 case 'p':
 135                         ret = add_opt(&optlist, optarg, 1);
 136                         if (ret != SA_OK) {
 137                                 (void) printf(gettext(
 138                                     "Problem with property: %s\n"), optarg);
 139                                 return (SA_NO_MEMORY);
 140                         }
 141                         break;
 142                 default:
 143                         (void) printf(gettext("usage: %s\n"),
 144                             sc_get_usage(USAGE_CTL_GET));
 145                         return (SA_SYNTAX_ERR);
 146                 case '?':
 147                 case 'h':
 148                         (void) printf(gettext("usage: %s\n"),
 149                             sc_get_usage(USAGE_CTL_GET));
 150                         return (SA_OK);
 151                 }
 152         }
 153
 154         if (optind >= argc) {
 155                 (void) printf(gettext("usage: %s\n"),
 156                     sc_get_usage(USAGE_CTL_GET));
 157                 (void) printf(gettext("\tprotocol must be specified.\n"));
 158                 return (SA_INVALID_PROTOCOL);
 159         }
 160
 161         proto = argv[optind];
 162         if (!sa_valid_protocol(proto)) {
 163                 (void) printf(gettext("Invalid protocol specified: %s\n"),
 164                     proto);
 165                 return (SA_INVALID_PROTOCOL);
 166         }
 167         propset = sa_proto_get_properties(proto);
 168         if (propset == NULL)
 169                 return (ret);
 170
 171         if (optlist == NULL) {
 172                 /* Display all known properties for this protocol */
 173                 for (propsect = sa_get_protocol_section(propset, NULL);
 174                     propsect != NULL;
 175                     propsect = sa_get_next_protocol_section(propsect, NULL)) {
 176                         section = sa_get_property_attr(propsect,
 177                             "name");
 178                         /*
 179                          * If properties are organized into sections, as
 180                          * in the SMB client, print the section name.
 181                          */
 182                         if (sa_proto_get_featureset(proto) &
 183                             SA_FEATURE_HAS_SECTIONS) {
 184                                 if (!first)
 185                                         (void) printf("\n");
 186                                 first = 0;
 187                                 (void) printf("[%s]\n",
 188                                     section != NULL ? section : "");
 189                         }
 190                         if (section != NULL)
 191                                 sa_free_attr_string(section);
 192
 193                         /* Display properties for this section */
 194                         for (prop = sa_get_protocol_property(propsect, NULL);
 195                             prop != NULL;
 196                             prop = sa_get_next_protocol_property(prop, NULL)) {
 197
 198                                 /* get and display the property and value */
 199                                 name = sa_get_property_attr(prop, "type");
 200                                 if (name != NULL) {
 201                                         value = sa_get_property_attr(prop,
 202                                             "value");
 203                                         (void) printf(gettext("%s=%s\n"), name,
 204                                             value != NULL ? value : "");
 205                                 }
 206                                 if (value != NULL)
 207                                         sa_free_attr_string(value);
 208                                 if (name != NULL)
 209                                         sa_free_attr_string(name);
 210                         }
 211                 }
 212         } else {
 213                 struct options *opt;
 214
 215                 /* list the specified option(s) */
 216                 for (opt = optlist; opt != NULL; opt = opt->next) {
 217                         int printed = 0;
 218
 219                         for (propsect = sa_get_protocol_section(propset, NULL);
 220                             propsect != NULL;
 221                             propsect = sa_get_next_protocol_section(propsect,
 222                             NULL)) {
 223
 224                                 section = sa_get_property_attr(propsect,
 225                                     "name");
 226                                 for (prop = sa_get_protocol_property(propsect,
 227                                     opt->optname);
 228                                     prop != NULL;
 229                                     prop = sa_get_next_protocol_property(
 230                                     propsect, opt->optname)) {
 231                                         value = sa_get_property_attr(prop,
 232                                             "value");
 233                                         if (sa_proto_get_featureset(proto) &
 234                                             SA_FEATURE_HAS_SECTIONS) {
 235                                                 (void) printf(
 236                                                     gettext("[%s] %s=%s\n"),
 237                                                     section != NULL ?
 238                                                     section : "", opt->optname,
 239                                                     value != NULL ? value : "");
 240                                         } else {
 241                                                 (void) printf(
 242                                                     gettext("%s=%s\n"),
 243                                                     opt->optname,
 244                                                     value != NULL ? value : "");
 245                                         }
 246                                         if (value != NULL)
 247                                                 sa_free_attr_string(value);
 248                                         printed = 1;
 249                                 }
 250                                 if (section != NULL)
 251                                         sa_free_attr_string(section);
 252                         }
 253                         if (!printed) {
 254                                 (void) printf(gettext("%s: not defined\n"),
 255                                     opt->optname);
 256                                 ret = SA_NO_SUCH_PROP;
 257                         }
 258                 }
 259         }
 260         return (ret);
 261 }
 262
 263 /*ARGSUSED*/
 264 static int
 265 sc_set(sa_handle_t handle, int flags, int argc, char *argv[])
 266 {
 267         char *proto = NULL;
 268         struct options *optlist = NULL;
 269         sa_protocol_properties_t propsect;
 270         int ret = SA_OK;
 271         int c;
 272         int err;
 273         sa_protocol_properties_t propset;
 274         sa_property_t prop;
 275
 276         while ((c = getopt(argc, argv, "?hp:")) != EOF) {
 277                 switch (c) {
 278                 case 'p':
 279                         ret = add_opt(&optlist, optarg, 0);
 280                         if (ret != SA_OK) {
 281                                 (void) printf(gettext(
 282                                     "Problem with property: %s\n"), optarg);
 283                                 return (SA_NO_MEMORY);
 284                         }
 285                         break;
 286                 default:
 287                         (void) printf(gettext("usage: %s\n"),
 288                             sc_get_usage(USAGE_CTL_SET));
 289                         return (SA_SYNTAX_ERR);
 290                 case '?':
 291                 case 'h':
 292                         (void) printf(gettext("usage: %s\n"),
 293                             sc_get_usage(USAGE_CTL_SET));
 294                         return (SA_OK);
 295                 }
 296         }
 297
 298         if (optind >= argc) {
 299                 (void) printf(gettext("usage: %s\n"),
 300                     sc_get_usage(USAGE_CTL_SET));
 301                 (void) printf(gettext("\tprotocol must be specified.\n"));
 302                 return (SA_INVALID_PROTOCOL);
 303         }
 304
 305         proto = argv[optind];
 306         if (!sa_valid_protocol(proto)) {
 307                 (void) printf(gettext("Invalid protocol specified: %s\n"),
 308                     proto);
 309                 return (SA_INVALID_PROTOCOL);
 310         }
 311         propset = sa_proto_get_properties(proto);
 312         if (propset == NULL)
 313                 return (ret);
 314
 315         if (optlist == NULL) {
 316                 (void) printf(gettext("usage: %s\n"),
 317                     sc_get_usage(USAGE_CTL_SET));
 318                 (void) printf(gettext(
 319                     "\tat least one property and value "
 320                     "must be specified\n"));
 321         } else {
 322                 struct options *opt;
 323                 char *section = NULL;
 324                 /* fetch and change the specified option(s) */
 325                 for (opt = optlist; opt != NULL; opt = opt->next) {
 326                         if (strncmp("section", opt->optname, 7) == 0) {
 327                                 free(section);
 328                                 section = strdup(opt->optvalue);
 329                                 continue;
 330                         }
 331                         if (sa_proto_get_featureset(proto) &
 332                             SA_FEATURE_HAS_SECTIONS) {
 333                                 propsect = sa_get_protocol_section(propset,
 334                                     section);
 335                                 prop = sa_get_protocol_property(propsect,
 336                                     opt->optname);
 337                         } else {
 338                                 prop = sa_get_protocol_property(propset,
 339                                     opt->optname);
 340                         }
 341                         if (prop == NULL && sa_proto_get_featureset(proto) &
 342                             SA_FEATURE_ADD_PROPERTIES) {
 343                                 sa_property_t sect;
 344                                 sect = sa_create_section(section, NULL);
 345                                 sa_set_section_attr(sect, "type", proto);
 346                                 (void) sa_add_protocol_property(propset, sect);
 347                                 prop = sa_create_property(
 348                                     opt->optname, opt->optvalue);
 349                                 (void) sa_add_protocol_property(sect, prop);
 350                         }
 351                         if (prop != NULL) {
 352                                 /*
 353                                  * "err" is used in order to prevent
 354                                  * setting ret to SA_OK if there has
 355                                  * been a real error. We want to be
 356                                  * able to return an error status on
 357                                  * exit in that case. Error messages
 358                                  * are printed for each error, so we
 359                                  * only care on exit that there was an
 360                                  * error and not the specific error
 361                                  * value.
 362                                  */
 363                                 err = sa_set_protocol_property(prop, section,
 364                                     opt->optvalue);
 365                                 if (err != SA_OK) {
 366                                         (void) printf(gettext(
 367                                             "Could not set property"
 368                                             " %s: %s\n"),
 369                                             opt->optname, sa_errorstr(err));
 370                                         ret = err;
 371                                 }
 372                         } else {
 373                                 (void) printf(gettext("%s: not defined\n"),
 374                                     opt->optname);
 375                                 ret = SA_NO_SUCH_PROP;
 376                         }
 377                 }
 378         }
 379         return (ret);
 380 }
 381
 382 static void
 383 show_status(char *proto)
 384 {
 385         char *status;
 386         uint64_t features;
 387
 388         status = sa_get_protocol_status(proto);
 389         features = sa_proto_get_featureset(proto);
 390         (void) printf("%s\t%s", proto, status ? gettext(status) : "-");
 391         free(status);
 392         /*
 393          * Need to flag a client only protocol so test suites can
 394          * remove it from consideration.
 395          */
 396         if (!(features & SA_FEATURE_SERVER))
 397                 (void) printf(" client");
 398         (void) printf("\n");
 399 }
 400
 401 static int
 402 valid_proto(char **protos, int num, char *proto)
 403 {
 404         int i;
 405         for (i = 0; i < num; i++)
 406                 if (strcmp(protos[i], proto) == 0)
 407                         return (1);
 408         return (0);
 409 }
 410
 411 /*ARGSUSED*/
 412 static int
 413 sc_status(sa_handle_t handle, int flags, int argc, char *argv[])
 414 {
 415         char **protos;
 416         int ret = SA_OK;
 417         int c;
 418         int i;
 419         int num_proto;
 420         int verbose = 0;
 421
 422         while ((c = getopt(argc, argv, "?hv")) != EOF) {
 423                 switch (c) {
 424                 case 'v':
 425                         verbose++;
 426                         break;
 427                 case '?':
 428                 case 'h':
 429                         (void) printf(gettext("usage: %s\n"),
 430                             sc_get_usage(USAGE_CTL_STATUS));
 431                         return (SA_OK);
 432                 default:
 433                         (void) printf(gettext("usage: %s\n"),
 434                             sc_get_usage(USAGE_CTL_STATUS));
 435                         return (SA_SYNTAX_ERR);
 436                 }
 437         }
 438
 439         num_proto = sa_get_protocols(&protos);
 440         if (optind == argc) {
 441                 /* status for all protocols */
 442                 for (i = 0; i < num_proto; i++) {
 443                         show_status(protos[i]);
 444                 }
 445         } else {
 446                 for (i = optind; i < argc; i++) {
 447                         if (valid_proto(protos, num_proto, argv[i])) {
 448                                 show_status(argv[i]);
 449                         } else {
 450                                 (void) printf(gettext("Invalid protocol: %s\n"),
 451                                     argv[i]);
 452                                 ret = SA_INVALID_PROTOCOL;
 453                         }
 454                 }
 455         }
 456         free(protos);
 457         return (ret);
 458 }
 459
 460 /*ARGSUSED*/
 461 static int
 462 sc_delsect(sa_handle_t handle, int flags, int argc, char *argv[])
 463 {
 464         char *proto = NULL;
 465         char *section = NULL;
 466         sa_protocol_properties_t propset;
 467         sa_protocol_properties_t propsect;
 468         int ret = SA_OK;
 469         int c;
 470
 471         while ((c = getopt(argc, argv, "?h")) != EOF) {
 472                 switch (c) {
 473                 default:
 474                         ret = SA_SYNTAX_ERR;
 475                         /*FALLTHROUGH*/
 476                 case '?':
 477                 case 'h':
 478                         (void) printf(gettext("usage: %s\n"),
 479                             sc_get_usage(USAGE_CTL_DELSECT));
 480                         return (ret);
 481                 }
 482                 /*NOTREACHED*/
 483         }
 484
 485         section = argv[optind++];
 486
 487         if (optind >= argc) {
 488                 (void) printf(gettext("usage: %s\n"),
 489                     sc_get_usage(USAGE_CTL_DELSECT));
 490                 (void) printf(gettext(
 491                     "\tsection and protocol must be specified.\n"));
 492                 return (SA_INVALID_PROTOCOL);
 493         }
 494
 495         proto = argv[optind];
 496         if (!sa_valid_protocol(proto)) {
 497                 (void) printf(gettext("Invalid protocol specified: %s\n"),
 498                     proto);
 499                 return (SA_INVALID_PROTOCOL);
 500         }
 501
 502         if ((sa_proto_get_featureset(proto) & SA_FEATURE_HAS_SECTIONS) == 0) {
 503                 (void) printf(gettext("Protocol %s does not have sections\n"),
 504                     proto);
 505                 return (SA_NOT_SUPPORTED);
 506         }
 507
 508         propset = sa_proto_get_properties(proto);
 509         if (propset == NULL) {
 510                 (void) printf(gettext("Cannot get properties for %s\n"),
 511                     proto);
 512                 return (SA_NO_PROPERTIES);
 513         }
 514
 515         propsect = sa_get_protocol_section(propset, section);
 516         if (propsect == NULL) {
 517                 (void) printf(gettext("Cannot find section %s for proto %s\n"),
 518                     section, proto);
 519                 return (SA_NO_SUCH_SECTION);
 520         }
 521
 522         ret = sa_proto_delete_section(proto, section);
 523
 524         return (ret);
 525 }
 526
 527 static sa_command_t commands[] = {
 528         {"delsect", 0, sc_delsect, USAGE_CTL_DELSECT},
 529         {"get", 0, sc_get, USAGE_CTL_GET},
 530         {"set", 0, sc_set, USAGE_CTL_SET},
 531         {"status", 0, sc_status, USAGE_CTL_STATUS},
 532         {NULL, 0, NULL, 0},
 533 };
 534
 535 /*ARGSUSED*/
 536 void
 537 sub_command_help(char *proto)
 538 {
 539         int i;
 540
 541         for (i = 0; commands[i].cmdname != NULL; i++) {
 542                 if (!(commands[i].flags & (CMD_ALIAS|CMD_NODISPLAY)))
 543                         (void) printf("\t%s\n",
 544                             sc_get_usage((sc_usage_t)commands[i].cmdidx));
 545         }
 546 }
 547
 548 sa_command_t *
 549 sa_lookup(char *cmd)
 550 {
 551         int i;
 552         size_t len;
 553
 554         len = strlen(cmd);
 555         for (i = 0; commands[i].cmdname != NULL; i++) {
 556                 if (strncmp(cmd, commands[i].cmdname, len) == 0)
 557                         return (&commands[i]);
 558         }
 559         return (NULL);
 560 }
 561
 562 static int
 563 run_command(char *command, int argc, char *argv[], sa_handle_t handle)
 564 {
 565         sa_command_t *cmdvec;
 566         int ret;
 567
 568         /*
 569          * To get here, we know there should be a command due to the
 570          * preprocessing done earlier.  Need to find the protocol
 571          * that is being affected. If no protocol, then it is ALL
 572          * protocols.
 573          *
 574          * ??? do we really need the protocol at this level? it may be
 575          * sufficient to let the commands look it up if needed since
 576          * not all commands do proto specific things
 577          *
 578          * Known sub-commands are handled at this level. An unknown
 579          * command will be passed down to the shared object that
 580          * actually implements it. We can do this since the semantics
 581          * of the common sub-commands is well defined.
 582          */
 583
 584         cmdvec = sa_lookup(command);
 585         if (cmdvec == NULL) {
 586                 (void) printf(gettext("command %s not found\n"), command);
 587                 exit(1);
 588         }
 589         /*
 590          * need to check priviledges and restrict what can be done
 591          * based on least priviledge and sub-command.
 592          */
 593         ret = cmdvec->cmdfunc(handle, 0, argc, argv);
 594         return (ret);
 595 }