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 if (section != NULL) 328 free(section); 329 section = strdup(opt->optvalue); 330 continue; 331 } 332 if (sa_proto_get_featureset(proto) & 333 SA_FEATURE_HAS_SECTIONS) { 334 propsect = sa_get_protocol_section(propset, 335 section); 336 prop = sa_get_protocol_property(propsect, 337 opt->optname); 338 } else { 339 prop = sa_get_protocol_property(propset, 340 opt->optname); 341 } 342 if (prop == NULL && sa_proto_get_featureset(proto) & 343 SA_FEATURE_ADD_PROPERTIES) { 344 sa_property_t sect; 345 sect = sa_create_section(section, NULL); 346 sa_set_section_attr(sect, "type", proto); 347 (void) sa_add_protocol_property(propset, sect); 348 prop = sa_create_property( 349 opt->optname, opt->optvalue); 350 (void) sa_add_protocol_property(sect, prop); 351 } 352 if (prop != NULL) { 353 /* 354 * "err" is used in order to prevent 355 * setting ret to SA_OK if there has 356 * been a real error. We want to be 357 * able to return an error status on 358 * exit in that case. Error messages 359 * are printed for each error, so we 360 * only care on exit that there was an 361 * error and not the specific error 362 * value. 363 */ 364 err = sa_set_protocol_property(prop, section, 365 opt->optvalue); 366 if (err != SA_OK) { 367 (void) printf(gettext( 368 "Could not set property" 369 " %s: %s\n"), 370 opt->optname, sa_errorstr(err)); 371 ret = err; 372 } 373 } else { 374 (void) printf(gettext("%s: not defined\n"), 375 opt->optname); 376 ret = SA_NO_SUCH_PROP; 377 } 378 } 379 } 380 return (ret); 381 } 382 383 static void 384 show_status(char *proto) 385 { 386 char *status; 387 uint64_t features; 388 389 status = sa_get_protocol_status(proto); 390 features = sa_proto_get_featureset(proto); 391 (void) printf("%s\t%s", proto, status ? gettext(status) : "-"); 392 if (status != NULL) 393 free(status); 394 /* 395 * Need to flag a client only protocol so test suites can 396 * remove it from consideration. 397 */ 398 if (!(features & SA_FEATURE_SERVER)) 399 (void) printf(" client"); 400 (void) printf("\n"); 401 } 402 403 static int 404 valid_proto(char **protos, int num, char *proto) 405 { 406 int i; 407 for (i = 0; i < num; i++) 408 if (strcmp(protos[i], proto) == 0) 409 return (1); 410 return (0); 411 } 412 413 /*ARGSUSED*/ 414 static int 415 sc_status(sa_handle_t handle, int flags, int argc, char *argv[]) 416 { 417 char **protos; 418 int ret = SA_OK; 419 int c; 420 int i; 421 int num_proto; 422 int verbose = 0; 423 424 while ((c = getopt(argc, argv, "?hv")) != EOF) { 425 switch (c) { 426 case 'v': 427 verbose++; 428 break; 429 case '?': 430 case 'h': 431 (void) printf(gettext("usage: %s\n"), 432 sc_get_usage(USAGE_CTL_STATUS)); 433 return (SA_OK); 434 default: 435 (void) printf(gettext("usage: %s\n"), 436 sc_get_usage(USAGE_CTL_STATUS)); 437 return (SA_SYNTAX_ERR); 438 } 439 } 440 441 num_proto = sa_get_protocols(&protos); 442 if (optind == argc) { 443 /* status for all protocols */ 444 for (i = 0; i < num_proto; i++) { 445 show_status(protos[i]); 446 } 447 } else { 448 for (i = optind; i < argc; i++) { 449 if (valid_proto(protos, num_proto, argv[i])) { 450 show_status(argv[i]); 451 } else { 452 (void) printf(gettext("Invalid protocol: %s\n"), 453 argv[i]); 454 ret = SA_INVALID_PROTOCOL; 455 } 456 } 457 } 458 if (protos != NULL) 459 free(protos); 460 return (ret); 461 } 462 463 /*ARGSUSED*/ 464 static int 465 sc_delsect(sa_handle_t handle, int flags, int argc, char *argv[]) 466 { 467 char *proto = NULL; 468 char *section = NULL; 469 sa_protocol_properties_t propset; 470 sa_protocol_properties_t propsect; 471 int ret = SA_OK; 472 int c; 473 474 while ((c = getopt(argc, argv, "?h")) != EOF) { 475 switch (c) { 476 default: 477 ret = SA_SYNTAX_ERR; 478 /*FALLTHROUGH*/ 479 case '?': 480 case 'h': 481 (void) printf(gettext("usage: %s\n"), 482 sc_get_usage(USAGE_CTL_DELSECT)); 483 return (ret); 484 } 485 /*NOTREACHED*/ 486 } 487 488 section = argv[optind++]; 489 490 if (optind >= argc) { 491 (void) printf(gettext("usage: %s\n"), 492 sc_get_usage(USAGE_CTL_DELSECT)); 493 (void) printf(gettext( 494 "\tsection and protocol must be specified.\n")); 495 return (SA_INVALID_PROTOCOL); 496 } 497 498 proto = argv[optind]; 499 if (!sa_valid_protocol(proto)) { 500 (void) printf(gettext("Invalid protocol specified: %s\n"), 501 proto); 502 return (SA_INVALID_PROTOCOL); 503 } 504 505 if ((sa_proto_get_featureset(proto) & SA_FEATURE_HAS_SECTIONS) == 0) { 506 (void) printf(gettext("Protocol %s does not have sections\n"), 507 proto); 508 return (SA_NOT_SUPPORTED); 509 } 510 511 propset = sa_proto_get_properties(proto); 512 if (propset == NULL) { 513 (void) printf(gettext("Cannot get properties for %s\n"), 514 proto); 515 return (SA_NO_PROPERTIES); 516 } 517 518 propsect = sa_get_protocol_section(propset, section); 519 if (propsect == NULL) { 520 (void) printf(gettext("Cannot find section %s for proto %s\n"), 521 section, proto); 522 return (SA_NO_SUCH_SECTION); 523 } 524 525 ret = sa_proto_delete_section(proto, section); 526 527 return (ret); 528 } 529 530 static sa_command_t commands[] = { 531 {"delsect", 0, sc_delsect, USAGE_CTL_DELSECT}, 532 {"get", 0, sc_get, USAGE_CTL_GET}, 533 {"set", 0, sc_set, USAGE_CTL_SET}, 534 {"status", 0, sc_status, USAGE_CTL_STATUS}, 535 {NULL, 0, NULL, 0}, 536 }; 537 538 /*ARGSUSED*/ 539 void 540 sub_command_help(char *proto) 541 { 542 int i; 543 544 for (i = 0; commands[i].cmdname != NULL; i++) { 545 if (!(commands[i].flags & (CMD_ALIAS|CMD_NODISPLAY))) 546 (void) printf("\t%s\n", 547 sc_get_usage((sc_usage_t)commands[i].cmdidx)); 548 } 549 } 550 551 sa_command_t * 552 sa_lookup(char *cmd) 553 { 554 int i; 555 size_t len; 556 557 len = strlen(cmd); 558 for (i = 0; commands[i].cmdname != NULL; i++) { 559 if (strncmp(cmd, commands[i].cmdname, len) == 0) 560 return (&commands[i]); 561 } 562 return (NULL); 563 } 564 565 static int 566 run_command(char *command, int argc, char *argv[], sa_handle_t handle) 567 { 568 sa_command_t *cmdvec; 569 int ret; 570 571 /* 572 * To get here, we know there should be a command due to the 573 * preprocessing done earlier. Need to find the protocol 574 * that is being affected. If no protocol, then it is ALL 575 * protocols. 576 * 577 * ??? do we really need the protocol at this level? it may be 578 * sufficient to let the commands look it up if needed since 579 * not all commands do proto specific things 580 * 581 * Known sub-commands are handled at this level. An unknown 582 * command will be passed down to the shared object that 583 * actually implements it. We can do this since the semantics 584 * of the common sub-commands is well defined. 585 */ 586 587 cmdvec = sa_lookup(command); 588 if (cmdvec == NULL) { 589 (void) printf(gettext("command %s not found\n"), command); 590 exit(1); 591 } 592 /* 593 * need to check priviledges and restrict what can be done 594 * based on least priviledge and sub-command. 595 */ 596 ret = cmdvec->cmdfunc(handle, 0, argc, argv); 597 return (ret); 598 } 599