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 */ 26 27 /* 28 * This is the main program file for the configuration administration 29 * command as set out in manual page cfgadm(1M). It uses the configuration 30 * administration library interface, libcfgadm, as set out in manual 31 * page config_admin(3X). 32 */ 33 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <string.h> 37 #include <locale.h> 38 #include <langinfo.h> 39 #include <time.h> 40 #include <assert.h> 41 #include <sys/types.h> 42 #include <sys/stat.h> 43 #include <sys/param.h> 44 #include <sys/sunddi.h> 45 #include <sys/openpromio.h> 46 #include <sys/ddi_impldefs.h> 47 #include <sys/systeminfo.h> 48 #include <ctype.h> 49 #include <zone.h> 50 51 #include <config_admin.h> 52 #include "cfgadm.h" 53 54 #define S_FREE(x) (((x) != NULL) ? (free(x), (x) = NULL) : (void *)0) 55 #define GET_DYN(a) (strstr((a), CFGA_DYN_SEP)) 56 /* 57 * forward declarations 58 */ 59 static char *basename(char *); 60 static void cfgadm_error(int, char *); 61 static int confirm_interactive(void *, const char *); 62 static int confirm_no(void *, const char *); 63 static int confirm_yes(void *, const char *); 64 static void usage(void); 65 static void usage_field(void); 66 static int extract_list_suboptions(char *, char **, char **, char **, 67 int *, char **, char **, char **); 68 static int message_output(void *appdata_ptr, const char *message); 69 static void *config_calloc_check(size_t, size_t); 70 static cfga_ap_types_t find_arg_type(const char *); 71 static int yesno(char *, char *); 72 73 74 static int compare_ap_id(cfga_list_data_t *, cfga_list_data_t *, match_type_t); 75 static int compare_r_state(cfga_list_data_t *, cfga_list_data_t *, 76 match_type_t); 77 static int compare_o_state(cfga_list_data_t *, cfga_list_data_t *, 78 match_type_t); 79 static int compare_cond(cfga_list_data_t *, cfga_list_data_t *, match_type_t); 80 static int compare_time(cfga_list_data_t *, cfga_list_data_t *, match_type_t); 81 static int compare_info(cfga_list_data_t *, cfga_list_data_t *, match_type_t); 82 static int compare_type(cfga_list_data_t *, cfga_list_data_t *, match_type_t); 83 static int compare_busy(cfga_list_data_t *, cfga_list_data_t *, match_type_t); 84 static int compare_class(cfga_list_data_t *, cfga_list_data_t *, match_type_t); 85 static int compare_null(cfga_list_data_t *, cfga_list_data_t *, match_type_t); 86 static void print_log_id(cfga_list_data_t *, int, char *); 87 static void print_r_state(cfga_list_data_t *, int, char *); 88 static void print_o_state(cfga_list_data_t *, int, char *); 89 static void print_cond(cfga_list_data_t *, int, char *); 90 static void print_time(cfga_list_data_t *, int, char *); 91 static void print_time_p(cfga_list_data_t *, int, char *); 92 static void print_info(cfga_list_data_t *, int, char *); 93 static void print_type(cfga_list_data_t *, int, char *); 94 static void print_busy(cfga_list_data_t *, int, char *); 95 static void print_phys_id(cfga_list_data_t *, int, char *); 96 static void print_class(cfga_list_data_t *, int, char *); 97 static void print_null(cfga_list_data_t *, int, char *); 98 static int count_fields(char *, char); 99 static int process_sort_fields(int, struct sort_el *, char *); 100 static int process_fields(int, struct print_col *, int, char *); 101 static cfga_err_t print_fields(int, struct print_col *, int, int, char *, 102 cfga_list_data_t *, FILE *); 103 static int ldata_compare(const void *, const void *); 104 105 static void arg_got_resp(ap_arg_t *inp, ap_out_t *out_array, int nouts, 106 int dyn_exp); 107 static void out_was_req(ap_out_t *outp, ap_arg_t *in_array, int nargs, 108 int no_dyn); 109 static void report_no_response(ap_arg_t *arg_array, int napids_to_list); 110 111 static cfga_err_t set_log_flt(cfga_list_data_t *p, const char *val); 112 static cfga_err_t set_type_flt(cfga_list_data_t *p, const char *val); 113 static cfga_err_t set_class_flt(cfga_list_data_t *p, const char *val); 114 115 static char *get_dyn(const char *ap_id); 116 static void remove_dyn(char *ap_id); 117 static char *s_strdup(char *str); 118 119 /* 120 * global data 121 */ 122 /* command name for messages */ 123 static char *cmdname; 124 125 /* 126 * control for comparing, printing and filtering cfga_list_data 127 * NOTE:Field names (i.e. member 0 of field_info struct) may not contain '('. 128 * The post filtering code depends on it. 129 * NOTE:A NULL value for the set_filter member indicates that filtering based 130 * on that field is currently not supported. 131 */ 132 static struct field_info all_fields[] = { 133 {"ap_id", "Ap_Id", SZ_EL(ap_log_id), compare_ap_id, print_log_id, set_log_flt}, 134 {"r_state", "Receptacle", STATE_WIDTH, compare_r_state, print_r_state, NULL}, 135 {"o_state", "Occupant", STATE_WIDTH, compare_o_state, print_o_state, NULL}, 136 {"condition", "Condition", COND_WIDTH, compare_cond, print_cond, NULL}, 137 {"status_time", "When", TIME_WIDTH, compare_time, print_time, NULL}, 138 {"status_time_p", "When", TIME_P_WIDTH, compare_time, print_time_p, NULL}, 139 {"info", "Information", SZ_EL(ap_info), compare_info, print_info, NULL}, 140 {"type", "Type", SZ_EL(ap_type), compare_type, print_type, set_type_flt}, 141 {"busy", "Busy", 8, compare_busy, print_busy, NULL}, 142 {"physid", "Phys_Id", SZ_EL(ap_phys_id), compare_ap_id, print_phys_id, NULL}, 143 {"class", "Class", SZ_EL(ap_class), compare_class, print_class, set_class_flt} 144 }; 145 146 #define PREFILT_CLASS_STR "class=" 147 148 typedef struct { 149 cfga_list_data_t ldata; /* Selection criteria */ 150 match_type_t match_type_p[N_FIELDS]; /* Type of match */ 151 } post_filter_t; 152 153 static struct field_info null_field = 154 {"null", "", 0, compare_null, print_null, NULL}; 155 156 static struct sort_el *sort_list; /* Used in ldata_compare() */ 157 static int nsort_list; 158 static char unk_field[] = "%s: field \"%s\" unknown\n"; 159 160 static char aptype_no_dyn[] = "%s: Invalid ap_id: %s\n"; 161 162 /* strings that make up the usage message */ 163 static char *usage_tab[] = { 164 " %s [-f] [-y|-n] [-v] [-o hardware_opts ] -c function ap_id [ap_id...]\n", 165 " %s [-f] [-y|-n] [-v] [-o hardware_opts ] -x function ap_id [ap_id...]\n", 166 " %s [-v] [-s listing_options ] [-o hardware_opts ] [-a]\n" 167 "\t[-l [ap_id|ap_type...]]\n", 168 " %s [-v] [-o hardware_opts ] -t ap_id [ap_id...]\n", 169 " %s [-v] [-o hardware_opts ] -h [ap_id|ap_type...]\n", 170 }; 171 172 /* Type of matches currently supported by the select sub-option */ 173 static match_cvt_t match_type_array[] = { 174 {"partial", CFGA_MATCH_PARTIAL}, 175 {"exact", CFGA_MATCH_EXACT} 176 }; 177 178 #define N_MATCH_TYPES (sizeof (match_type_array)/sizeof (match_type_array[0])) 179 180 static cfga_err_t setup_filter(const char *selectp, const char *matchp, 181 post_filter_t *post_filtp, char **prefilt_optpp); 182 static cfga_err_t parse_select_opt(const char *selectp, 183 post_filter_t *post_filtp, match_type_t match_type); 184 static int do_config_list(int, char *[], cfga_list_data_t *, int, char *, 185 char *, char *, int, char *, post_filter_t *, int); 186 static void do_post_filter(ap_out_t *outp, post_filter_t *post_filtp, int *jp); 187 188 189 /* 190 * main - the main routine of cfgadm, processes the command line 191 * and dispatches functions off to libraries. 192 */ 193 int 194 main( 195 int argc, 196 char *argv[]) 197 { 198 extern char *optarg; 199 extern int optind; 200 int c; 201 char *subopts; 202 char *subvalue; 203 char *const *ap_args = NULL; 204 cfga_cmd_t sc_opt = NULL; 205 struct cfga_confirm confirm; 206 struct cfga_msg message; 207 int ret = CFGA_ERROR; 208 int i; 209 char *estrp = NULL; 210 cfga_op_t action = CFGA_OP_NONE; 211 char *plat_opts = NULL; 212 char *act_arg = NULL; 213 enum confirm confarg = CONFIRM_DEFAULT; 214 char *list_opts = NULL; 215 cfga_flags_t flags = 0; 216 int arg_error = 0; 217 int dyn_exp = 0; 218 219 estrp = NULL; 220 if (argc > 0) 221 cmdname = basename(argv[0]); 222 else 223 cmdname = "cfgadm"; 224 (void) setlocale(LC_ALL, ""); 225 #if !defined(TEXT_DOMAIN) 226 #define TEXT_DOMAIN "SYS_TEST" 227 #endif 228 (void) textdomain(TEXT_DOMAIN); 229 230 while ((c = getopt(argc, argv, OPTIONS)) != EOF) { 231 static char dup_action[] = 232 "%s: more than one action specified (-c,-l,-t,-x)\n"; 233 static char dup_option[] = 234 "%s: more than one -%c option specified\n"; 235 switch (c) { 236 case 'a': 237 if (dyn_exp) { 238 arg_error = 1; 239 (void) fprintf(stderr, gettext(dup_option), 240 cmdname, c); 241 } 242 dyn_exp = 1; 243 break; 244 case 'c': 245 if (action != CFGA_OP_NONE) { 246 arg_error = 1; 247 (void) fprintf(stderr, gettext(dup_action), 248 cmdname); 249 } 250 action = CFGA_OP_CHANGE_STATE; 251 subopts = optarg; 252 subvalue = NULL; 253 /* 254 * Reject -c suboption if they are unrecognized 255 * or more than one or have a associated value. 256 */ 257 if ((sc_opt = getsubopt(&subopts, state_opts, 258 &subvalue)) == -1 || *subopts != '\0' || 259 subvalue != NULL) { 260 arg_error = 1; 261 break; 262 } 263 break; 264 case 'f': 265 if ((flags & CFGA_FLAG_FORCE) != 0) { 266 arg_error = 1; 267 (void) fprintf(stderr, gettext(dup_option), 268 cmdname, c); 269 } 270 flags |= CFGA_FLAG_FORCE; 271 break; 272 case 'h': 273 if (action != CFGA_OP_NONE) { 274 arg_error = 1; 275 (void) fprintf(stderr, gettext(dup_action), 276 cmdname); 277 } 278 action = CFGA_OP_HELP; 279 break; 280 case 'l': 281 if (action != CFGA_OP_NONE) { 282 arg_error = 1; 283 (void) fprintf(stderr, gettext(dup_action), 284 cmdname); 285 } 286 action = CFGA_OP_LIST; 287 break; 288 case 'n': 289 if (confarg != CONFIRM_DEFAULT) { 290 arg_error = 1; 291 (void) fprintf(stderr, gettext(dup_option), 292 cmdname, c); 293 } 294 confarg = CONFIRM_NO; 295 break; 296 case 'o': 297 if (plat_opts != NULL) { 298 arg_error = 1; 299 (void) fprintf(stderr, gettext(dup_option), 300 cmdname, c); 301 } 302 plat_opts = optarg; 303 break; 304 case 's': 305 if (list_opts != NULL) { 306 arg_error = 1; 307 (void) fprintf(stderr, gettext(dup_option), 308 cmdname, c); 309 } 310 list_opts = optarg; 311 break; 312 case 't': 313 if (action != CFGA_OP_NONE) { 314 arg_error = 1; 315 (void) fprintf(stderr, gettext(dup_action), 316 cmdname); 317 } 318 action = CFGA_OP_TEST; 319 break; 320 case 'x': 321 if (action != CFGA_OP_NONE) { 322 arg_error = 1; 323 (void) fprintf(stderr, gettext(dup_action), 324 cmdname); 325 } 326 action = CFGA_OP_PRIVATE; 327 act_arg = optarg; 328 break; 329 case 'v': 330 if ((flags & CFGA_FLAG_VERBOSE) != 0) { 331 arg_error = 1; 332 (void) fprintf(stderr, gettext(dup_option), 333 cmdname, c); 334 } 335 flags |= CFGA_FLAG_VERBOSE; 336 break; 337 case 'y': 338 if (confarg != CONFIRM_DEFAULT) { 339 arg_error = 1; 340 (void) fprintf(stderr, gettext(dup_option), 341 cmdname, c); 342 } 343 confarg = CONFIRM_YES; 344 break; 345 case '?': /* getopts issues message is this case */ 346 default: /* catch programming errors */ 347 arg_error = 1; 348 break; 349 } 350 } 351 352 /* default action is list */ 353 if (action == CFGA_OP_NONE) 354 action = CFGA_OP_LIST; 355 356 /* -s and -a option only for list */ 357 if (action != CFGA_OP_LIST && (list_opts != NULL || dyn_exp)) { 358 arg_error = 1; 359 } 360 361 if (arg_error) { 362 usage(); 363 exit(EXIT_ARGERROR); 364 /*NOTREACHED*/ 365 } 366 367 if (getzoneid() != GLOBAL_ZONEID) { 368 cfgadm_error(CFGA_NOTSUPP, 369 gettext("cfgadm can only be run from the global zone")); 370 exit(EXIT_NOTSUPP); 371 } 372 373 ap_args = &argv[optind]; 374 375 /* 376 * If neither -n of -y was specified, interactive confirmation 377 * is used. Check if the program has terminal I/O and 378 * enforce -n if not. 379 */ 380 (void) memset(&confirm, 0, sizeof (confirm)); 381 if (action == CFGA_OP_CHANGE_STATE || action == CFGA_OP_PRIVATE) { 382 if (confarg == CONFIRM_DEFAULT && 383 !(isatty(fileno(stdin)) && isatty(fileno(stderr)))) 384 confarg = CONFIRM_NO; 385 switch (confarg) { 386 case CONFIRM_DEFAULT: 387 confirm.confirm = confirm_interactive; 388 break; 389 case CONFIRM_NO: 390 confirm.confirm = confirm_no; 391 break; 392 case CONFIRM_YES: 393 confirm.confirm = confirm_yes; 394 break; 395 default: /* paranoia */ 396 abort(); 397 /*NOTREACHED*/ 398 } 399 } 400 401 /* 402 * set up message output routine 403 */ 404 message.message_routine = message_output; 405 406 switch (action) { 407 case CFGA_OP_CHANGE_STATE: 408 /* Sanity check - requires an argument */ 409 if ((argc - optind) <= 0) { 410 usage(); 411 break; 412 } 413 /* Sanity check - args cannot be ap_types */ 414 for (i = 0; i < (argc - optind); i++) { 415 if (find_arg_type(ap_args[i]) == AP_TYPE) { 416 usage(); 417 exit(EXIT_ARGERROR); 418 /*NOTREACHED*/ 419 } 420 } 421 ret = config_change_state(sc_opt, argc - optind, ap_args, 422 plat_opts, &confirm, &message, &estrp, flags); 423 if (ret != CFGA_OK) 424 cfgadm_error(ret, estrp); 425 break; 426 case CFGA_OP_PRIVATE: 427 /* Sanity check - requires an argument */ 428 if ((argc - optind) <= 0) { 429 usage(); 430 break; 431 } 432 /* Sanity check - args cannot be ap_types */ 433 for (i = 0; i < (argc - optind); i++) { 434 if (find_arg_type(ap_args[i]) == AP_TYPE) { 435 usage(); 436 exit(EXIT_ARGERROR); 437 /*NOTREACHED*/ 438 } 439 } 440 441 ret = config_private_func(act_arg, argc - optind, ap_args, 442 plat_opts, &confirm, &message, &estrp, flags); 443 444 if (ret != CFGA_OK) 445 cfgadm_error(ret, estrp); 446 break; 447 case CFGA_OP_TEST: 448 /* Sanity check - requires an argument */ 449 if ((argc - optind) <= 0) { 450 usage(); 451 break; 452 } 453 454 if ((flags & ~CFGA_FLAG_VERBOSE) != 0) { 455 usage(); 456 exit(EXIT_ARGERROR); 457 /*NOTREACHED*/ 458 } 459 460 /* Sanity check - args cannot be ap_types */ 461 for (i = 0; i < (argc - optind); i++) { 462 if (find_arg_type(ap_args[i]) == AP_TYPE) { 463 usage(); 464 exit(EXIT_ARGERROR); 465 /*NOTREACHED*/ 466 } 467 } 468 ret = config_test(argc - optind, ap_args, plat_opts, &message, 469 &estrp, flags); 470 if (ret != CFGA_OK) 471 cfgadm_error(ret, estrp); 472 break; 473 case CFGA_OP_HELP: 474 475 if ((flags & ~CFGA_FLAG_VERBOSE) != 0) { 476 usage(); 477 exit(EXIT_ARGERROR); 478 /*NOTREACHED*/ 479 } 480 481 /* always do usage? */ 482 usage(); 483 ret = config_help(argc - optind, ap_args, &message, plat_opts, 484 flags); 485 if (ret != CFGA_OK) 486 cfgadm_error(ret, estrp); 487 break; 488 489 case CFGA_OP_LIST: { 490 /* 491 * Note that we leak the strdup strings below (we never free 492 * them). This is ok in this context since cfgadm is 493 * a short lived process that will exit shortly freeing 494 * the memory. 495 */ 496 cfga_list_data_t *list_array = NULL; 497 int nlist = 0; 498 char *sort_fields = s_strdup(DEF_SORT_FIELDS); 499 char *cols = s_strdup(DEF_COLS); 500 char *cols2 = s_strdup(DEF_COLS2); 501 int noheadings = 0; 502 char *delim = s_strdup(DEF_DELIM); 503 int exitcode = EXIT_OK; 504 int i; 505 int type = 0; 506 char *selectp = NULL, *matchp = NULL, *prefilt_optp = NULL; 507 post_filter_t *post_filtp = NULL; 508 509 if ((flags & ~CFGA_FLAG_VERBOSE) != 0) { 510 usage(); 511 exit(EXIT_ARGERROR); 512 /*NOTREACHED*/ 513 } 514 515 if (flags & CFGA_FLAG_VERBOSE) { 516 cols = s_strdup(DEF_COLS_VERBOSE); 517 cols2 = s_strdup(DEF_COLS2_VERBOSE); 518 } 519 520 if (list_opts != NULL && !extract_list_suboptions(list_opts, 521 &sort_fields, &cols, &cols2, &noheadings, &delim, 522 &selectp, &matchp)) { 523 usage_field(); 524 exit(EXIT_ARGERROR); 525 /*NOTREACHED*/ 526 } 527 528 /* 529 * Scan any args and see if there are any ap_types. 530 * If there are we get all attachment point stats and 531 * then filter what gets printed. 532 */ 533 534 type = 0; 535 for (i = 0; i < (argc - optind); i++) { 536 if (find_arg_type(ap_args[i]) == AP_TYPE) { 537 type = 1; 538 /* ap_types cannot have dynamic components */ 539 if (get_dyn(ap_args[i]) != NULL) { 540 (void) fprintf(stderr, 541 gettext(aptype_no_dyn), 542 cmdname, ap_args[i]); 543 exit(EXIT_ARGERROR); 544 /*NOTREACHED*/ 545 } 546 break; 547 } 548 } 549 550 /* Setup filter */ 551 post_filtp = config_calloc_check(1, sizeof (*post_filtp)); 552 if (post_filtp == NULL) { 553 exit(EXIT_OPFAILED); 554 /*NOTREACHED*/ 555 } 556 if (setup_filter(selectp, matchp, post_filtp, &prefilt_optp) 557 != CFGA_OK) { 558 S_FREE(post_filtp); 559 exit(EXIT_ARGERROR); 560 /*NOTREACHED*/ 561 } 562 563 list_array = NULL; 564 exitcode = EXIT_OK; 565 566 /* 567 * Check for args. No args means find all libs 568 * and call the cfga_list_ext routine with no ap_ids specified. 569 * With args, if any one of the args are ap_types we 570 * again find all attachment points as in the 571 * no-args case above and then select which attachment points 572 * are actually displayed. 573 */ 574 if (((argc - optind) == 0) || (type == 1)) { 575 /* 576 * No args, or atleast 1 ap_type arg 577 */ 578 ret = config_list_ext(0, NULL, &list_array, 579 &nlist, plat_opts, prefilt_optp, &estrp, 580 dyn_exp ? CFGA_FLAG_LIST_ALL : 0); 581 } else { 582 /* 583 * If the args are all ap_ids (no ap_types) we call the 584 * cfga_list_ext routine with those specific ap_ids. 585 */ 586 ret = config_list_ext(argc - optind, ap_args, 587 &list_array, &nlist, plat_opts, prefilt_optp, 588 &estrp, dyn_exp ? CFGA_FLAG_LIST_ALL : 0); 589 } 590 591 S_FREE(prefilt_optp); 592 593 if (ret == CFGA_OK) { 594 595 if (do_config_list( 596 (argc - optind), &argv[optind], list_array, nlist, 597 sort_fields, cols, cols2, noheadings, delim, 598 post_filtp, dyn_exp) != CFGA_OK) { 599 exitcode = EXIT_ARGERROR; 600 } else { 601 exitcode = EXIT_OK; 602 } 603 604 S_FREE(list_array); 605 S_FREE(post_filtp); 606 607 if (estrp != NULL && *estrp != '\0') 608 cfgadm_error(CFGA_NOTSUPP, estrp); 609 if (exitcode != EXIT_OK) { 610 exit(exitcode); 611 /*NOTREACHED*/ 612 } 613 } else { 614 615 S_FREE(post_filtp); 616 cfgadm_error(ret, estrp); 617 } 618 break; 619 } 620 default: /* paranoia */ 621 abort(); 622 /*NOTREACHED*/ 623 } 624 625 if (ret == CFGA_NOTSUPP) { 626 return (EXIT_NOTSUPP); 627 } else if (ret != CFGA_OK) { 628 return (EXIT_OPFAILED); 629 } else { 630 return (EXIT_OK); 631 } 632 /*NOTREACHED*/ 633 } 634 635 /* 636 * usage - outputs the usage help message. 637 */ 638 static void 639 usage(void) 640 { 641 int i; 642 643 (void) fprintf(stderr, "%s\n", gettext("Usage:")); 644 for (i = 0; i < sizeof (usage_tab)/sizeof (usage_tab[0]); i++) { 645 (void) fprintf(stderr, gettext(usage_tab[i]), cmdname); 646 } 647 } 648 649 /* 650 * Emit an error message. 651 * As a side-effect the hardware specific error message is deallocated 652 * as described in config_admin(3X). 653 */ 654 static void 655 cfgadm_error(int errnum, char *estrp) 656 { 657 const char *ep; 658 659 ep = config_strerror(errnum); 660 if (ep == NULL) 661 ep = gettext("configuration administration unknown error"); 662 if (estrp != NULL && *estrp != '\0') { 663 (void) fprintf(stderr, "%s: %s: %s\n", cmdname, ep, estrp); 664 } else { 665 (void) fprintf(stderr, "%s: %s\n", cmdname, ep); 666 } 667 if (estrp != NULL) 668 free((void *)estrp); 669 if (errnum == CFGA_INVAL) 670 usage(); 671 } 672 673 /* 674 * confirm_interactive - prompt user for confirmation 675 */ 676 static int 677 confirm_interactive( 678 void *appdata_ptr, 679 const char *message) 680 { 681 static char yeschr[YESNO_STR_MAX + 2]; 682 static char nochr[YESNO_STR_MAX + 2]; 683 static int inited = 0; 684 int isyes; 685 686 #ifdef lint 687 appdata_ptr = appdata_ptr; 688 #endif /* lint */ 689 /* 690 * First time through initialisation. In the original 691 * version of this command this function is only called once, 692 * but this function is generalized for the future. 693 */ 694 if (!inited) { 695 (void) strncpy(yeschr, nl_langinfo(YESSTR), YESNO_STR_MAX + 1); 696 (void) strncpy(nochr, nl_langinfo(NOSTR), YESNO_STR_MAX + 1); 697 inited = 1; 698 } 699 700 do { 701 (void) fprintf(stderr, "%s (%s/%s)? ", message, yeschr, nochr); 702 isyes = yesno(yeschr, nochr); 703 } while (isyes == -1); 704 return (isyes); 705 } 706 707 /* 708 * If any text is input it must sub-string match either yes or no. 709 * Failure of this match is indicated by return of -1. 710 * If an empty line is input, this is taken as no. 711 */ 712 static int 713 yesno( 714 char *yesp, 715 char *nop) 716 { 717 int i, b; 718 char ans[YESNO_STR_MAX + 1]; 719 720 i = 0; 721 722 /*CONSTCOND*/ 723 while (1) { 724 b = getc(stdin); /* more explicit that rm.c version */ 725 if (b == '\n' || b == '\0' || b == EOF) { 726 if (i < YESNO_STR_MAX) /* bug fix to rm.c version */ 727 ans[i] = 0; 728 break; 729 } 730 if (i < YESNO_STR_MAX) 731 ans[i] = b; 732 i++; 733 } 734 if (i >= YESNO_STR_MAX) { 735 i = YESNO_STR_MAX; 736 ans[YESNO_STR_MAX] = 0; 737 } 738 /* changes to rm.c version follow */ 739 if (i == 0) 740 return (0); 741 if (strncmp(nop, ans, i) == 0) 742 return (0); 743 if (strncmp(yesp, ans, i) == 0) 744 return (1); 745 return (-1); 746 } 747 748 /*ARGSUSED*/ 749 static int 750 confirm_no( 751 void *appdata_ptr, 752 const char *message) 753 { 754 return (0); 755 } 756 757 /*ARGSUSED*/ 758 static int 759 confirm_yes( 760 void *appdata_ptr, 761 const char *message) 762 { 763 return (1); 764 } 765 766 /* 767 * Find base name of filename. 768 */ 769 static char * 770 basename( 771 char *cp) 772 { 773 char *sp; 774 775 if ((sp = strrchr(cp, '/')) != NULL) 776 return (sp + 1); 777 return (cp); 778 } 779 780 /*ARGSUSED*/ 781 static int 782 message_output( 783 void *appdata_ptr, 784 const char *message) 785 { 786 (void) fprintf(stderr, "%s", message); 787 return (CFGA_OK); 788 789 } 790 791 /* 792 * extract_list_suboptions - process list option string 793 */ 794 static int 795 extract_list_suboptions( 796 char *arg, 797 char **sortpp, 798 char **colspp, 799 char **cols2pp, 800 int *noheadingsp, 801 char **delimpp, 802 char **selectpp, 803 char **matchpp) 804 { 805 char *value = NULL; 806 int subopt = 0; 807 int err = 0; 808 809 while (*arg != '\0') { 810 static char need_value[] = 811 "%s: sub-option \"%s\" requires a value\n"; 812 static char no_value[] = 813 "%s: sub-option \"%s\" does not take a value\n"; 814 static char unk_subopt[] = 815 "%s: sub-option \"%s\" unknown\n"; 816 char **pptr; 817 818 subopt = getsubopt(&arg, list_options, &value); 819 switch (subopt) { 820 case LIST_SORT: 821 pptr = sortpp; 822 goto valcom; 823 case LIST_COLS: 824 pptr = colspp; 825 goto valcom; 826 case LIST_COLS2: 827 pptr = cols2pp; 828 goto valcom; 829 case LIST_SELECT: 830 pptr = selectpp; 831 goto valcom; 832 case LIST_MATCH: 833 pptr = matchpp; 834 goto valcom; 835 case LIST_DELIM: 836 pptr = delimpp; 837 valcom: 838 if (value == NULL) { 839 (void) fprintf(stderr, gettext(need_value), 840 cmdname, list_options[subopt]); 841 err = 1; 842 } else 843 *pptr = value; 844 break; 845 case LIST_NOHEADINGS: 846 if (value != NULL) { 847 (void) fprintf(stderr, gettext(no_value), 848 cmdname, list_options[subopt]); 849 err = 1; 850 } else 851 *noheadingsp = 1; 852 break; 853 default: 854 (void) fprintf(stderr, gettext(unk_subopt), 855 cmdname, value); 856 err = 1; 857 break; 858 } 859 } 860 return (err == 0); 861 } 862 863 static cfga_err_t 864 setup_prefilter(post_filter_t *post_filtp, char **prefilt_optpp) 865 { 866 size_t len; 867 const char *clopt = PREFILT_CLASS_STR; 868 int idx; 869 870 871 *prefilt_optpp = NULL; 872 873 /* Get the index for the "class" field */ 874 for (idx = 0; idx < N_FIELDS; idx++) { 875 if (strcmp(all_fields[idx].name, PREFILT_CLASS_STR) == 0) 876 break; 877 } 878 879 /* 880 * Currently pre-filter available only for class fld w/ EXACT match 881 */ 882 if (idx >= N_FIELDS || 883 post_filtp->match_type_p[idx] != CFGA_MATCH_EXACT) { 884 return (CFGA_OK); 885 } 886 887 len = strlen(clopt) + strlen(post_filtp->ldata.ap_class) + 1; 888 if ((*prefilt_optpp = config_calloc_check(1, len)) == NULL) { 889 return (CFGA_LIB_ERROR); 890 } 891 892 (void) strcpy(*prefilt_optpp, clopt); 893 (void) strcat(*prefilt_optpp, post_filtp->ldata.ap_class); 894 895 /* 896 * Since it is being pre-filtered, this attribute does not need 897 * post-filtering. 898 */ 899 post_filtp->match_type_p[idx] = CFGA_MATCH_NOFILTER; 900 if (all_fields[idx].set_filter != NULL) { 901 (void) all_fields[idx].set_filter(&post_filtp->ldata, ""); 902 } 903 904 return (CFGA_OK); 905 } 906 907 static cfga_err_t 908 set_attrval( 909 const char *attr, 910 const char *val, 911 post_filter_t *post_filtp, 912 match_type_t match_type) 913 { 914 int fld = 0; 915 cfga_err_t ret = CFGA_ERROR; 916 917 for (fld = 0; fld < N_FIELDS; fld++) { 918 if (strcmp(attr, all_fields[fld].name) == 0) 919 break; 920 } 921 922 /* Valid field or is the select option supported for this field */ 923 if (fld >= N_FIELDS || all_fields[fld].set_filter == NULL) { 924 return (CFGA_ATTR_INVAL); 925 } 926 927 if ((ret = all_fields[fld].set_filter(&post_filtp->ldata, val)) 928 == CFGA_OK) { 929 post_filtp->match_type_p[fld] = match_type; 930 } 931 932 return (ret); 933 934 } 935 936 static char inval_optarg[] = 937 "%s: invalid value \"%s\" for %s suboption.\n"; 938 939 /* 940 * Parses the "select" string and fills in the post_filter structure 941 */ 942 static cfga_err_t 943 parse_select_opt( 944 const char *selectp, 945 post_filter_t *post_filtp, 946 match_type_t match_type) 947 { 948 parse_state_t state = CFGA_PSTATE_INIT; 949 char *cp = NULL, *optstr = NULL, *attr = NULL, *val = NULL; 950 int bal = 0; /* Tracks balancing */ 951 char chr; 952 cfga_err_t ret; 953 954 955 if (selectp == NULL || post_filtp == NULL) { 956 return (CFGA_ERROR); 957 } 958 959 optstr = config_calloc_check(1, strlen(selectp) + 1); 960 if (optstr == NULL) { 961 return (CFGA_LIB_ERROR); 962 } 963 964 (void) strcpy(optstr, selectp); 965 966 /* Init */ 967 ret = CFGA_ATTR_INVAL; 968 bal = 0; 969 cp = attr = optstr; 970 state = CFGA_PSTATE_INIT; 971 972 for (; *cp != '\0'; cp++) { 973 switch (state) { 974 case CFGA_PSTATE_INIT: 975 if (*cp != LEFT_PAREN) 976 break; 977 *cp = '\0'; 978 val = cp + 1; 979 bal = 1; 980 state = CFGA_PSTATE_ATTR_DONE; 981 break; 982 case CFGA_PSTATE_ATTR_DONE: 983 chr = *cp; 984 switch (chr) { 985 case LEFT_PAREN: 986 bal++; 987 break; 988 case RIGHT_PAREN: 989 bal--; 990 if (bal == 0) { 991 *cp = '\0'; 992 state = CFGA_PSTATE_VAL_DONE; 993 } 994 break; 995 } 996 break; 997 case CFGA_PSTATE_VAL_DONE: 998 if (*cp != ':') { 999 state = CFGA_PSTATE_ERR; 1000 goto out; 1001 } 1002 1003 *cp = '\0'; 1004 if (set_attrval(attr, val, post_filtp, 1005 match_type) != CFGA_OK) { 1006 state = CFGA_PSTATE_ERR; 1007 goto out; 1008 } 1009 state = CFGA_PSTATE_INIT; 1010 attr = cp + 1; 1011 break; 1012 default: 1013 state = CFGA_PSTATE_ERR; 1014 /* FALLTHROUGH */ 1015 case CFGA_PSTATE_ERR: 1016 goto out; 1017 } 1018 } 1019 1020 /*FALLTHRU*/ 1021 out: 1022 if (state == CFGA_PSTATE_VAL_DONE) { 1023 ret = set_attrval(attr, val, post_filtp, match_type); 1024 } else { 1025 ret = CFGA_ATTR_INVAL; 1026 } 1027 1028 if (ret != CFGA_OK) { 1029 (void) fprintf(stderr, gettext(inval_optarg), cmdname, 1030 selectp, list_options[LIST_SELECT]); 1031 } 1032 1033 S_FREE(optstr); 1034 return (ret); 1035 } 1036 1037 1038 1039 static cfga_err_t 1040 setup_filter( 1041 const char *selectp, 1042 const char *matchp, 1043 post_filter_t *post_filtp, 1044 char **prefilt_optpp) 1045 { 1046 cfga_err_t ret = CFGA_ERROR; 1047 match_type_t match_type = CFGA_MATCH_NOFILTER; 1048 int i; 1049 1050 static char match_needs_select[] = 1051 "%s: %s suboption can only be used with %s suboption.\n"; 1052 1053 1054 *prefilt_optpp = NULL; 1055 1056 /* 1057 * Initial: no filtering. 1058 * CFGA_MATCH_NOFILTER is NOT a valid user input 1059 */ 1060 for (i = 0; i < N_FIELDS; i++) { 1061 post_filtp->match_type_p[i] = CFGA_MATCH_NOFILTER; 1062 } 1063 1064 /* Determine type of match */ 1065 if (matchp == NULL && selectp == NULL) { 1066 /* No filtering */ 1067 return (CFGA_OK); 1068 } else if (matchp == NULL && selectp != NULL) { 1069 match_type = CFGA_DEFAULT_MATCH; 1070 } else if (matchp != NULL && selectp == NULL) { 1071 /* If only match specified, select criteria also needed */ 1072 (void) fprintf(stderr, gettext(match_needs_select), 1073 cmdname, list_options[LIST_MATCH], 1074 list_options[LIST_SELECT]); 1075 return (CFGA_ERROR); 1076 } else { 1077 for (i = 0; i < N_MATCH_TYPES; i++) { 1078 if (strcmp(matchp, match_type_array[i].str) == 0) { 1079 match_type = match_type_array[i].type; 1080 break; 1081 } 1082 } 1083 if (i >= N_MATCH_TYPES) { 1084 (void) fprintf(stderr, gettext(inval_optarg), cmdname, 1085 matchp, list_options[LIST_MATCH]); 1086 return (CFGA_ERROR); 1087 } 1088 } 1089 1090 if ((ret = parse_select_opt(selectp, post_filtp, match_type)) 1091 != CFGA_OK) { 1092 return (ret); 1093 } 1094 1095 /* Handle pre-filtering. */ 1096 if ((ret = setup_prefilter(post_filtp, prefilt_optpp)) != CFGA_OK) { 1097 /* Cleanup */ 1098 for (i = 0; i < N_FIELDS; i++) { 1099 post_filtp->match_type_p[i] = CFGA_MATCH_NOFILTER; 1100 } 1101 return (ret); 1102 } 1103 1104 1105 return (CFGA_OK); 1106 } 1107 1108 /* 1109 * compare_ap_id - compare two ap_id's 1110 * 1111 * For partial matches, argument order is significant. The filtering criterion 1112 * should be the first argument. 1113 */ 1114 1115 static int 1116 compare_ap_id( 1117 cfga_list_data_t *p1, 1118 cfga_list_data_t *p2, 1119 match_type_t match_type) 1120 { 1121 1122 switch (match_type) { 1123 case CFGA_MATCH_NOFILTER: 1124 return (0); /* No filtering. all pass */ 1125 case CFGA_MATCH_PARTIAL: 1126 return (strncmp(p1->ap_log_id, p2->ap_log_id, 1127 strlen(p1->ap_log_id))); 1128 case CFGA_MATCH_EXACT: 1129 return (strcmp(p1->ap_log_id, p2->ap_log_id)); 1130 case CFGA_MATCH_ORDER: 1131 default: 1132 return (config_ap_id_cmp(p1->ap_log_id, p2->ap_log_id)); 1133 } 1134 } 1135 1136 /* 1137 * print_log_id - print logical ap_id 1138 */ 1139 static void 1140 print_log_id( 1141 cfga_list_data_t *p, 1142 int width, 1143 char *lp) 1144 { 1145 (void) sprintf(lp, "%-*.*s", width, sizeof (p->ap_log_id), 1146 p->ap_log_id); 1147 } 1148 1149 /* 1150 * set_log_flt - Setup filter for logical ap_id 1151 */ 1152 static cfga_err_t 1153 set_log_flt( 1154 cfga_list_data_t *p, 1155 const char *val) 1156 { 1157 if (strlen(val) > sizeof (p->ap_log_id) - 1) 1158 return (CFGA_ATTR_INVAL); 1159 1160 (void) strcpy(p->ap_log_id, val); 1161 1162 return (CFGA_OK); 1163 } 1164 1165 /* 1166 * set_type_flt - Setup filter for type field 1167 */ 1168 1169 static cfga_err_t 1170 set_type_flt( 1171 cfga_list_data_t *p, 1172 const char *val) 1173 { 1174 if (strlen(val) > sizeof (p->ap_type) - 1) 1175 return (CFGA_ATTR_INVAL); 1176 1177 (void) strcpy(p->ap_type, val); 1178 1179 return (CFGA_OK); 1180 } 1181 1182 /* 1183 * set_class_flt - Setup filter for class field 1184 */ 1185 static cfga_err_t 1186 set_class_flt( 1187 cfga_list_data_t *p, 1188 const char *val) 1189 { 1190 if (strlen(val) > sizeof (p->ap_class) - 1) 1191 return (CFGA_ATTR_INVAL); 1192 1193 (void) strcpy(p->ap_class, val); 1194 1195 return (CFGA_OK); 1196 } 1197 1198 1199 /* 1200 * compare_r_state - compare receptacle state of two ap_id's 1201 */ 1202 static int 1203 compare_r_state( 1204 cfga_list_data_t *p1, 1205 cfga_list_data_t *p2, 1206 match_type_t match_type) 1207 { 1208 switch (match_type) { 1209 case CFGA_MATCH_NOFILTER: /* no filtering. pass all */ 1210 return (0); 1211 case CFGA_MATCH_ORDER: 1212 default: 1213 return (p1->ap_r_state - p2->ap_r_state); 1214 } 1215 } 1216 1217 /* 1218 * compare_o_state - compare occupant state of two ap_id's 1219 */ 1220 static int 1221 compare_o_state( 1222 cfga_list_data_t *p1, 1223 cfga_list_data_t *p2, 1224 match_type_t match_type) 1225 { 1226 switch (match_type) { 1227 case CFGA_MATCH_NOFILTER: /* no filtering. all pass */ 1228 return (0); 1229 case CFGA_MATCH_ORDER: 1230 default: 1231 return (p1->ap_o_state - p2->ap_o_state); 1232 } 1233 } 1234 1235 /* 1236 * compare_busy - compare busy field of two ap_id's 1237 */ 1238 static int 1239 compare_busy( 1240 cfga_list_data_t *p1, 1241 cfga_list_data_t *p2, 1242 match_type_t match_type) 1243 { 1244 1245 switch (match_type) { 1246 case CFGA_MATCH_NOFILTER: /* no filtering. all pass */ 1247 return (0); 1248 case CFGA_MATCH_ORDER: 1249 default: 1250 return (p1->ap_busy - p2->ap_busy); 1251 } 1252 } 1253 1254 /* 1255 * print_r_state - print receptacle state 1256 */ 1257 static void 1258 print_r_state( 1259 cfga_list_data_t *p, 1260 int width, 1261 char *lp) 1262 { 1263 char *cp; 1264 1265 switch (p->ap_r_state) { 1266 case CFGA_STAT_EMPTY: 1267 cp = "empty"; 1268 break; 1269 case CFGA_STAT_CONNECTED: 1270 cp = "connected"; 1271 break; 1272 case CFGA_STAT_DISCONNECTED: 1273 cp = "disconnected"; 1274 break; 1275 default: 1276 cp = "???"; 1277 break; 1278 } 1279 (void) sprintf(lp, "%-*s", width, cp); 1280 } 1281 1282 /* 1283 * print_o_state - print occupant state 1284 */ 1285 static void 1286 print_o_state( 1287 cfga_list_data_t *p, 1288 int width, 1289 char *lp) 1290 { 1291 char *cp; 1292 1293 switch (p->ap_o_state) { 1294 case CFGA_STAT_UNCONFIGURED: 1295 cp = "unconfigured"; 1296 break; 1297 case CFGA_STAT_CONFIGURED: 1298 cp = "configured"; 1299 break; 1300 default: 1301 cp = "???"; 1302 break; 1303 } 1304 (void) sprintf(lp, "%-*s", width, cp); 1305 } 1306 1307 /* 1308 * compare_cond - compare condition field of two ap_id's 1309 */ 1310 static int 1311 compare_cond( 1312 cfga_list_data_t *p1, 1313 cfga_list_data_t *p2, 1314 match_type_t match_type) 1315 { 1316 1317 switch (match_type) { 1318 case CFGA_MATCH_NOFILTER: 1319 return (0); 1320 case CFGA_MATCH_ORDER: 1321 default: 1322 return (p1->ap_cond - p2->ap_cond); 1323 } 1324 } 1325 1326 /* 1327 * print_cond - print attachment point condition 1328 */ 1329 static void 1330 print_cond( 1331 cfga_list_data_t *p, 1332 int width, 1333 char *lp) 1334 { 1335 char *cp; 1336 1337 switch (p->ap_cond) { 1338 case CFGA_COND_UNKNOWN: 1339 cp = "unknown"; 1340 break; 1341 case CFGA_COND_UNUSABLE: 1342 cp = "unusable"; 1343 break; 1344 case CFGA_COND_FAILING: 1345 cp = "failing"; 1346 break; 1347 case CFGA_COND_FAILED: 1348 cp = "failed"; 1349 break; 1350 case CFGA_COND_OK: 1351 cp = "ok"; 1352 break; 1353 default: 1354 cp = "???"; 1355 break; 1356 } 1357 (void) sprintf(lp, "%-*s", width, cp); 1358 } 1359 1360 /* 1361 * compare_time - compare time field of two ap_id's 1362 */ 1363 static int 1364 compare_time( 1365 cfga_list_data_t *p1, 1366 cfga_list_data_t *p2, 1367 match_type_t match_type) 1368 { 1369 switch (match_type) { 1370 case CFGA_MATCH_NOFILTER: 1371 return (0); 1372 case CFGA_MATCH_ORDER: 1373 default: 1374 return (p1->ap_status_time - p2->ap_status_time); 1375 } 1376 } 1377 1378 1379 /* 1380 * print_time - print time from cfga_list_data. 1381 * Time print based on ls(1). 1382 */ 1383 static void 1384 print_time( 1385 cfga_list_data_t *p, 1386 int width, 1387 char *lp) 1388 { 1389 static time_t year, now; 1390 time_t stime; 1391 char time_buf[50]; /* array to hold day and time */ 1392 1393 if (year == 0) { 1394 now = time((long *)NULL); 1395 year = now - 6L*30L*24L*60L*60L; /* 6 months ago */ 1396 now = now + 60; 1397 } 1398 stime = p->ap_status_time; 1399 if (stime == (time_t)-1) { 1400 (void) sprintf(lp, "%-*s", width, gettext("unavailable")); 1401 return; 1402 } 1403 1404 if ((stime < year) || (stime > now)) { 1405 (void) strftime(time_buf, sizeof (time_buf), 1406 dcgettext(NULL, FORMAT1, LC_TIME), localtime(&stime)); 1407 } else { 1408 (void) strftime(time_buf, sizeof (time_buf), 1409 dcgettext(NULL, FORMAT2, LC_TIME), localtime(&stime)); 1410 } 1411 (void) sprintf(lp, "%-*s", width, time_buf); 1412 } 1413 1414 /* 1415 * print_time_p - print time from cfga_list_data. 1416 */ 1417 static void 1418 print_time_p( 1419 cfga_list_data_t *p, 1420 int width, 1421 char *lp) 1422 { 1423 struct tm *tp; 1424 char tstr[TIME_P_WIDTH+1]; 1425 1426 tp = localtime(&p->ap_status_time); 1427 (void) sprintf(tstr, "%04d%02d%02d%02d%02d%02d", tp->tm_year + 1900, 1428 tp->tm_mon + 1, tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec); 1429 (void) sprintf(lp, "%-*s", width, tstr); 1430 } 1431 1432 /* 1433 * compare_info - compare info from two cfga_list_data structs 1434 */ 1435 static int 1436 compare_info( 1437 cfga_list_data_t *p1, 1438 cfga_list_data_t *p2, 1439 match_type_t match_type) 1440 { 1441 switch (match_type) { 1442 case CFGA_MATCH_NOFILTER: 1443 return (0); 1444 case CFGA_MATCH_ORDER: 1445 default: 1446 return (strncmp(p1->ap_info, p2->ap_info, 1447 sizeof (p2->ap_info))); 1448 } 1449 } 1450 1451 /* 1452 * print_info - print info from cfga_list_data struct 1453 */ 1454 static void 1455 print_info( 1456 cfga_list_data_t *p, 1457 int width, 1458 char *lp) 1459 { 1460 (void) sprintf(lp, "%-*.*s", width, sizeof (p->ap_info), p->ap_info); 1461 } 1462 1463 /* 1464 * compare_type - compare type from two cfga_list_data structs 1465 * 1466 * For partial matches, argument order is significant. The filtering criterion 1467 * should be the first argument. 1468 */ 1469 static int 1470 compare_type( 1471 cfga_list_data_t *p1, 1472 cfga_list_data_t *p2, 1473 match_type_t match_type) 1474 { 1475 switch (match_type) { 1476 case CFGA_MATCH_NOFILTER: 1477 return (0); 1478 case CFGA_MATCH_PARTIAL: 1479 return (strncmp(p1->ap_type, p2->ap_type, strlen(p1->ap_type))); 1480 case CFGA_MATCH_EXACT: 1481 case CFGA_MATCH_ORDER: 1482 default: 1483 return (strncmp(p1->ap_type, p2->ap_type, 1484 sizeof (p2->ap_type))); 1485 } 1486 } 1487 1488 /* 1489 * print_type - print type from cfga_list_data struct 1490 */ 1491 static void 1492 print_type( 1493 cfga_list_data_t *p, 1494 int width, 1495 char *lp) 1496 { 1497 (void) sprintf(lp, "%-*.*s", width, sizeof (p->ap_type), p->ap_type); 1498 } 1499 1500 1501 /* 1502 * compare_class - compare class from two cfga_list_data structs 1503 * 1504 * For partial matches, argument order is significant. The filtering criterion 1505 * should be the first argument. 1506 */ 1507 static int 1508 compare_class( 1509 cfga_list_data_t *p1, 1510 cfga_list_data_t *p2, 1511 match_type_t match_type) 1512 { 1513 1514 switch (match_type) { 1515 case CFGA_MATCH_NOFILTER: 1516 return (0); 1517 case CFGA_MATCH_PARTIAL: 1518 return (strncmp(p1->ap_class, p2->ap_class, 1519 strlen(p1->ap_class))); 1520 case CFGA_MATCH_EXACT: 1521 case CFGA_MATCH_ORDER: 1522 default: 1523 return (strncmp(p1->ap_class, p2->ap_class, 1524 sizeof (p2->ap_class))); 1525 } 1526 } 1527 1528 /* 1529 * print_class - print class from cfga_list_data struct 1530 */ 1531 static void 1532 print_class( 1533 cfga_list_data_t *p, 1534 int width, 1535 char *lp) 1536 { 1537 (void) sprintf(lp, "%-*.*s", width, sizeof (p->ap_class), p->ap_class); 1538 } 1539 /* 1540 * print_busy - print busy from cfga_list_data struct 1541 */ 1542 /* ARGSUSED */ 1543 static void 1544 print_busy( 1545 cfga_list_data_t *p, 1546 int width, 1547 char *lp) 1548 { 1549 if (p->ap_busy) 1550 (void) sprintf(lp, "%-*.*s", width, width, "y"); 1551 else 1552 (void) sprintf(lp, "%-*.*s", width, width, "n"); 1553 } 1554 1555 /* 1556 * print_phys_id - print physical ap_id 1557 */ 1558 static void 1559 print_phys_id( 1560 cfga_list_data_t *p, 1561 int width, 1562 char *lp) 1563 { 1564 (void) sprintf(lp, "%-*.*s", width, sizeof (p->ap_phys_id), 1565 p->ap_phys_id); 1566 } 1567 1568 1569 /* 1570 * find_field - find the named field 1571 */ 1572 static struct field_info * 1573 find_field(char *fname) 1574 { 1575 struct field_info *fldp; 1576 1577 for (fldp = all_fields; fldp < &all_fields[N_FIELDS]; fldp++) 1578 if (strcmp(fname, fldp->name) == 0) 1579 return (fldp); 1580 return (NULL); 1581 } 1582 1583 /* 1584 * usage_field - print field usage 1585 */ 1586 static void 1587 usage_field() 1588 { 1589 struct field_info *fldp = NULL; 1590 const char *sep; 1591 static char field_list[] = "%s: print or sort fields must be one of:"; 1592 1593 (void) fprintf(stderr, gettext(field_list), cmdname); 1594 sep = ""; 1595 1596 for (fldp = all_fields; fldp < &all_fields[N_FIELDS]; fldp++) { 1597 (void) fprintf(stderr, "%s %s", sep, fldp->name); 1598 sep = ","; 1599 } 1600 (void) fprintf(stderr, "\n"); 1601 } 1602 1603 /* 1604 * compare_null - null comparison routine 1605 */ 1606 /*ARGSUSED*/ 1607 static int 1608 compare_null( 1609 cfga_list_data_t *p1, 1610 cfga_list_data_t *p2, 1611 match_type_t match_type) 1612 { 1613 return (0); 1614 } 1615 1616 /* 1617 * print_null - print out a field of spaces 1618 */ 1619 /*ARGSUSED*/ 1620 static void 1621 print_null( 1622 cfga_list_data_t *p, 1623 int width, 1624 char *lp) 1625 { 1626 (void) sprintf(lp, "%-*s", width, ""); 1627 } 1628 1629 /* 1630 * do_config_list - directs the output of the listing functions 1631 */ 1632 static int 1633 do_config_list( 1634 int l_argc, 1635 char *l_argv[], 1636 cfga_list_data_t *statlist, 1637 int nlist, 1638 char *sortp, 1639 char *colsp, 1640 char *cols2p, 1641 int noheadings, 1642 char *delimp, 1643 post_filter_t *post_filtp, 1644 int dyn_exp) 1645 { 1646 int nprcols = 0, ncols2 = 0; 1647 struct print_col *prnt_list = NULL; 1648 int napids_to_list = 0; 1649 FILE *fp = NULL; 1650 int f_err; 1651 cfga_list_data_t **sel_boards = NULL; 1652 int nsel = 0; 1653 int i, j; 1654 cfga_err_t ret; 1655 1656 ap_arg_t *arg_array = NULL; 1657 ap_out_t *out_array = NULL; 1658 1659 1660 sort_list = NULL; 1661 f_err = 0; 1662 fp = stdout; 1663 nsort_list = count_fields(sortp, FDELIM); 1664 if (nsort_list != 0) { 1665 sort_list = config_calloc_check(nsort_list, 1666 sizeof (*sort_list)); 1667 if (sort_list == NULL) { 1668 ret = CFGA_LIB_ERROR; 1669 goto out; 1670 } 1671 f_err |= process_sort_fields(nsort_list, sort_list, sortp); 1672 } else 1673 sort_list = NULL; 1674 1675 nprcols = count_fields(colsp, FDELIM); 1676 if ((ncols2 = count_fields(cols2p, FDELIM)) > nprcols) 1677 nprcols = ncols2; 1678 if (nprcols != 0) { 1679 prnt_list = config_calloc_check(nprcols, sizeof (*prnt_list)); 1680 if (prnt_list == NULL) { 1681 ret = CFGA_LIB_ERROR; 1682 goto out; 1683 } 1684 f_err |= process_fields(nprcols, prnt_list, 0, colsp); 1685 if (ncols2 != 0) 1686 f_err |= process_fields(nprcols, prnt_list, 1, cols2p); 1687 } else 1688 prnt_list = NULL; 1689 1690 if (f_err) { 1691 usage_field(); 1692 ret = CFGA_ERROR; 1693 goto out; 1694 } 1695 1696 /* Create an array of all user args (if any) */ 1697 if (l_argc != 0) { 1698 int i, j; 1699 1700 napids_to_list = 0; 1701 1702 for (i = 0; i < l_argc; i++) { 1703 napids_to_list += count_fields(l_argv[i], ARG_DELIM); 1704 } 1705 1706 arg_array = config_calloc_check(napids_to_list, 1707 sizeof (*arg_array)); 1708 if (arg_array == NULL) { 1709 ret = CFGA_LIB_ERROR; 1710 goto out; 1711 } 1712 1713 for (i = 0, j = 0; i < l_argc; i++) { 1714 int n; 1715 1716 n = count_fields(l_argv[i], ARG_DELIM); 1717 if (n == 0) { 1718 continue; 1719 } else if (n == 1) { 1720 arg_array[j].arg = l_argv[i]; 1721 arg_array[j].resp = 0; 1722 j++; 1723 } else { 1724 char *cp, *ncp; 1725 1726 cp = l_argv[i]; 1727 for (;;) { 1728 arg_array[j].arg = cp; 1729 arg_array[j].resp = 0; 1730 j++; 1731 ncp = strchr(cp, ARG_DELIM); 1732 if (ncp == NULL) 1733 break; 1734 *ncp = '\0'; 1735 cp = ncp + 1; 1736 } 1737 } 1738 } 1739 assert(j == napids_to_list); 1740 } else { 1741 napids_to_list = 0; 1742 arg_array = NULL; 1743 } 1744 1745 assert(nlist != 0); 1746 1747 out_array = config_calloc_check(nlist, sizeof (*out_array)); 1748 if (out_array == NULL) { 1749 ret = CFGA_LIB_ERROR; 1750 goto out; 1751 } 1752 1753 1754 /* create a list of output stat data */ 1755 for (i = 0; i < nlist; i++) { 1756 out_array[i].ldatap = &statlist[i]; 1757 out_array[i].req = 0; 1758 } 1759 1760 /* 1761 * Mark all user input which got atleast 1 stat data in response 1762 */ 1763 for (i = 0; i < napids_to_list; i++) { 1764 arg_got_resp(&arg_array[i], out_array, nlist, dyn_exp); 1765 } 1766 1767 /* 1768 * Process output data 1769 */ 1770 nsel = 0; 1771 for (i = 0; i < nlist; i++) { 1772 /* 1773 * Mark all the stats which were actually requested by user 1774 */ 1775 out_was_req(&out_array[i], arg_array, napids_to_list, 0); 1776 if (out_array[i].req == 0 && dyn_exp) { 1777 /* 1778 * Try again without the dynamic component for the 1779 * if dynamic expansion was requested. 1780 */ 1781 out_was_req(&out_array[i], arg_array, 1782 napids_to_list, 1); 1783 } 1784 1785 /* 1786 * post filter data which was actually requested 1787 */ 1788 if (out_array[i].req == 1) { 1789 do_post_filter(&out_array[i], post_filtp, &nsel); 1790 } 1791 } 1792 1793 sel_boards = config_calloc_check(nsel, sizeof (*sel_boards)); 1794 if (sel_boards == NULL) { 1795 ret = CFGA_LIB_ERROR; 1796 goto out; 1797 } 1798 1799 for (i = 0, j = 0; i < nlist; i++) { 1800 if (out_array[i].req == 1) { 1801 sel_boards[j] = out_array[i].ldatap; 1802 j++; 1803 } 1804 } 1805 1806 assert(j == nsel); 1807 1808 /* 1809 * Print headings even if no list entries - Bug or feature ? 1810 */ 1811 if (!noheadings && prnt_list != NULL) { 1812 if ((ret = print_fields(nprcols, prnt_list, 1, 0, 1813 delimp, NULL, fp)) != CFGA_OK) { 1814 goto out; 1815 } 1816 if (ncols2 != 0) { 1817 if ((ret = print_fields(nprcols, prnt_list, 1, 1818 1, delimp, NULL, fp)) != CFGA_OK) { 1819 goto out; 1820 } 1821 } 1822 } 1823 1824 if (nsel != 0) { 1825 if (sort_list != NULL && nsel > 1) { 1826 qsort(sel_boards, nsel, sizeof (sel_boards[0]), 1827 ldata_compare); 1828 } 1829 1830 if (prnt_list != NULL) { 1831 for (i = 0; i < nsel; i++) { 1832 if ((ret = print_fields(nprcols, 1833 prnt_list, 0, 0, delimp, sel_boards[i], fp)) 1834 != CFGA_OK) 1835 goto out; 1836 if (ncols2 != 0) { 1837 if ((ret = print_fields( 1838 nprcols, prnt_list, 0, 1, delimp, 1839 sel_boards[i], fp)) != CFGA_OK) 1840 goto out; 1841 } 1842 } 1843 } 1844 } 1845 /* 1846 * Go thru the argument list and notify user about args 1847 * which did not have a match 1848 */ 1849 report_no_response(arg_array, napids_to_list); 1850 ret = CFGA_OK; 1851 /*FALLTHRU*/ 1852 out: 1853 S_FREE(sel_boards); 1854 S_FREE(arg_array); 1855 S_FREE(out_array); 1856 1857 S_FREE(sort_list); 1858 S_FREE(prnt_list); 1859 1860 return (ret); 1861 } 1862 1863 1864 /* 1865 * Mark all user inputs which got a response 1866 */ 1867 static void 1868 arg_got_resp(ap_arg_t *inp, ap_out_t *out_array, int nouts, int dyn_exp) 1869 { 1870 int i; 1871 cfga_ap_types_t type; 1872 1873 1874 if (nouts == 0) { 1875 return; 1876 } 1877 1878 type = find_arg_type(inp->arg); 1879 1880 /* 1881 * Go through list of output stats and check if argument 1882 * produced that output 1883 */ 1884 for (i = 0; i < nouts; i++) { 1885 if (type == PHYSICAL_AP_ID) { 1886 if (config_ap_id_cmp(out_array[i].ldatap->ap_phys_id, 1887 inp->arg) == 0) { 1888 break; 1889 } 1890 } else if (type == LOGICAL_AP_ID) { 1891 if (config_ap_id_cmp(out_array[i].ldatap->ap_log_id, 1892 inp->arg) == 0) { 1893 break; 1894 } 1895 } else if (type == AP_TYPE) { 1896 /* 1897 * An AP_TYPE argument cannot generate dynamic 1898 * attachment point stats unless dynamic expansion was 1899 * requested by user. 1900 */ 1901 if (!dyn_exp && get_dyn(out_array[i].ldatap->ap_log_id) 1902 != NULL) { 1903 continue; 1904 } 1905 1906 if (strncmp(out_array[i].ldatap->ap_log_id, inp->arg, 1907 strlen(inp->arg)) == 0) { 1908 break; 1909 } 1910 } else { 1911 return; 1912 } 1913 } 1914 1915 if (i < nouts) { 1916 inp->resp = 1; 1917 } 1918 } 1919 1920 /* Mark all stat data which were requested by user */ 1921 static void 1922 out_was_req(ap_out_t *outp, ap_arg_t *in_array, int nargs, int no_dyn) 1923 { 1924 int i; 1925 cfga_ap_types_t type = UNKNOWN_AP; 1926 char physid[MAXPATHLEN], logid[MAXPATHLEN]; 1927 1928 1929 /* If no user args, all output is acceptable */ 1930 if (nargs == 0) { 1931 outp->req = 1; 1932 return; 1933 } 1934 1935 1936 (void) snprintf(physid, sizeof (physid), "%s", 1937 outp->ldatap->ap_phys_id); 1938 (void) snprintf(logid, sizeof (logid), "%s", outp->ldatap->ap_log_id); 1939 1940 /* 1941 * Do comparison with or without dynamic component as requested by 1942 * user. 1943 */ 1944 if (no_dyn) { 1945 /* Remove the dynamic component */ 1946 remove_dyn(physid); 1947 remove_dyn(logid); 1948 } 1949 1950 for (i = 0; i < nargs; i++) { 1951 type = find_arg_type(in_array[i].arg); 1952 if (type == PHYSICAL_AP_ID) { 1953 1954 if (config_ap_id_cmp(in_array[i].arg, physid) == 0) { 1955 break; 1956 } 1957 } else if (type == LOGICAL_AP_ID) { 1958 1959 if (config_ap_id_cmp(in_array[i].arg, logid) == 0) { 1960 break; 1961 } 1962 } else if (type == AP_TYPE) { 1963 /* 1964 * Aptypes cannot generate dynamic attachment 1965 * points unless dynamic expansion is specified. 1966 * in which case this routine would be called a 1967 * 2nd time with the no_dyn flag set and there 1968 * would be no dynamic ap_ids. 1969 */ 1970 if (get_dyn(logid) != NULL) { 1971 continue; 1972 } 1973 1974 if (strncmp(in_array[i].arg, logid, 1975 strlen(in_array[i].arg)) == 0) { 1976 break; 1977 } 1978 } else { 1979 continue; 1980 } 1981 } 1982 1983 if (i < nargs) { 1984 /* Ok, this output was requested */ 1985 outp->req = 1; 1986 } 1987 1988 } 1989 1990 static void 1991 do_post_filter(ap_out_t *outp, post_filter_t *post_filtp, int *nselp) 1992 { 1993 int i; 1994 1995 if (outp->req != 1) { 1996 return; 1997 } 1998 1999 /* 2000 * For fields without filtering (CFGA_MATCH_NOFILTER), 2001 * compare always returns 0 (success) 2002 */ 2003 for (i = 0; i < N_FIELDS; i++) { 2004 /* 2005 * Note: Order is important for partial match (via strncmp). 2006 * The first argument for compare must be the filter. 2007 */ 2008 if (all_fields[i].compare(&post_filtp->ldata, outp->ldatap, 2009 post_filtp->match_type_p[i])) { 2010 outp->req = 0; /* Blocked by filter */ 2011 return; 2012 } 2013 } 2014 2015 /* 2016 * Passed through filter 2017 */ 2018 (*nselp)++; 2019 } 2020 2021 static void 2022 report_no_response(ap_arg_t *arg_array, int nargs) 2023 { 2024 int i; 2025 2026 if (nargs == 0) { 2027 return; 2028 } 2029 2030 2031 /* 2032 * nop if no user arguments 2033 */ 2034 for (i = 0; i < nargs; i++) { 2035 if (arg_array[i].resp == 0) { 2036 (void) fprintf(stderr, 2037 gettext("%s: No matching library found\n"), 2038 arg_array[i].arg); 2039 } 2040 } 2041 } 2042 2043 /* 2044 * ldata_compare - compare two attachment point list data structures. 2045 */ 2046 static int 2047 ldata_compare( 2048 const void *vb1, 2049 const void *vb2) 2050 { 2051 int i; 2052 int res = -1; 2053 cfga_list_data_t *b1, *b2; 2054 2055 2056 b1 = *(cfga_list_data_t **)vb1; 2057 b2 = *(cfga_list_data_t **)vb2; 2058 2059 for (i = 0; i < nsort_list; i++) { 2060 res = (*(sort_list[i].fld->compare))(b1, b2, CFGA_MATCH_ORDER); 2061 if (res != 0) { 2062 if (sort_list[i].reverse) 2063 res = -res; 2064 break; 2065 } 2066 } 2067 2068 return (res); 2069 } 2070 2071 /* 2072 * count_fields - Count the number of fields, using supplied delimiter. 2073 */ 2074 static int 2075 count_fields(char *fspec, char delim) 2076 { 2077 char *cp = NULL; 2078 int n; 2079 2080 if (fspec == 0 || *fspec == '\0') 2081 return (0); 2082 n = 1; 2083 for (cp = fspec; *cp != '\0'; cp++) 2084 if (*cp == delim) 2085 n++; 2086 return (n); 2087 } 2088 2089 /* 2090 * get_field 2091 * This function is not a re-implementation of strtok(). 2092 * There can be null fields - strtok() eats spans of delimiters. 2093 */ 2094 static char * 2095 get_field(char **fspp) 2096 { 2097 char *cp = NULL, *fld; 2098 2099 fld = *fspp; 2100 2101 if (fld != NULL && *fld == '\0') 2102 fld = NULL; 2103 2104 if (fld != NULL) { 2105 cp = strchr(*fspp, FDELIM); 2106 if (cp == NULL) { 2107 *fspp = NULL; 2108 } else { 2109 *cp = '\0'; 2110 *fspp = cp + 1; 2111 if (*fld == '\0') 2112 fld = NULL; 2113 } 2114 } 2115 return (fld); 2116 } 2117 2118 /* 2119 * process_fields - 2120 */ 2121 static int 2122 process_fields( 2123 int ncol, 2124 struct print_col *list, 2125 int line2, 2126 char *fmt) 2127 { 2128 struct print_col *pp = NULL; 2129 struct field_info *fldp = NULL; 2130 char *fmtx; 2131 char *fldn; 2132 int err; 2133 2134 err = 0; 2135 fmtx = fmt; 2136 for (pp = list; pp < &list[ncol]; pp++) { 2137 fldn = get_field(&fmtx); 2138 fldp = &null_field; 2139 if (fldn != NULL) { 2140 struct field_info *tfldp; 2141 2142 tfldp = find_field(fldn); 2143 if (tfldp != NULL) { 2144 fldp = tfldp; 2145 } else { 2146 (void) fprintf(stderr, gettext(unk_field), 2147 cmdname, fldn); 2148 err = 1; 2149 } 2150 } 2151 if (line2) { 2152 pp->line2 = fldp; 2153 if (fldp->width > pp->width) 2154 pp->width = fldp->width; 2155 } else { 2156 pp->line1 = fldp; 2157 pp->width = fldp->width; 2158 } 2159 } 2160 return (err); 2161 } 2162 2163 /* 2164 * process_sort_fields - 2165 */ 2166 static int 2167 process_sort_fields( 2168 int nsort, 2169 struct sort_el *list, 2170 char *fmt) 2171 { 2172 int i; 2173 int rev; 2174 struct field_info *fldp = NULL; 2175 char *fmtx; 2176 char *fldn; 2177 int err; 2178 2179 err = 0; 2180 fmtx = fmt; 2181 for (i = 0; i < nsort; i++) { 2182 fldn = get_field(&fmtx); 2183 fldp = &null_field; 2184 rev = 0; 2185 if (fldn != NULL) { 2186 struct field_info *tfldp = NULL; 2187 2188 if (*fldn == '-') { 2189 rev = 1; 2190 fldn++; 2191 } 2192 tfldp = find_field(fldn); 2193 if (tfldp != NULL) { 2194 fldp = tfldp; 2195 } else { 2196 (void) fprintf(stderr, gettext(unk_field), 2197 cmdname, fldn); 2198 err = 1; 2199 } 2200 } 2201 list[i].reverse = rev; 2202 list[i].fld = fldp; 2203 } 2204 return (err); 2205 } 2206 2207 /* 2208 * print_fields - 2209 */ 2210 static cfga_err_t 2211 print_fields( 2212 int ncol, 2213 struct print_col *list, 2214 int heading, 2215 int line2, 2216 char *delim, 2217 cfga_list_data_t *bdp, 2218 FILE *fp) 2219 { 2220 char *del = NULL; 2221 struct print_col *pp = NULL; 2222 struct field_info *fldp = NULL; 2223 static char *outline, *end; 2224 char *lp; 2225 2226 if (outline == NULL) { 2227 int out_len, delim_len; 2228 2229 delim_len = strlen(delim); 2230 out_len = 0; 2231 for (pp = list; pp < &list[ncol]; pp++) { 2232 out_len += pp->width; 2233 out_len += delim_len; 2234 } 2235 out_len -= delim_len; 2236 outline = config_calloc_check(out_len + 1, 1); 2237 if (outline == NULL) { 2238 return (CFGA_LIB_ERROR); 2239 } 2240 end = &outline[out_len + 1]; 2241 } 2242 2243 lp = outline; 2244 del = ""; 2245 for (pp = list; pp < &list[ncol]; pp++) { 2246 fldp = line2 ? pp->line2 : pp->line1; 2247 (void) snprintf(lp, end - lp, "%s", del); 2248 lp += strlen(lp); 2249 if (heading) { 2250 (void) snprintf(lp, end - lp, "%-*s", 2251 fldp->width, fldp->heading); 2252 } else { 2253 (*fldp->printfn)(bdp, fldp->width, lp); 2254 } 2255 lp += strlen(lp); 2256 del = delim; 2257 } 2258 2259 /* 2260 * Trim trailing spaces 2261 */ 2262 while (--lp >= outline && *lp == ' ') 2263 *lp = '\0'; 2264 (void) fprintf(fp, "%s\n", outline); 2265 return (CFGA_OK); 2266 } 2267 2268 /* 2269 * config_calloc_check - perform allocation, check result and 2270 * set error indicator 2271 */ 2272 static void * 2273 config_calloc_check( 2274 size_t nelem, 2275 size_t elsize) 2276 { 2277 void *p; 2278 static char alloc_fail[] = 2279 "%s: memory allocation failed (%d*%d bytes)\n"; 2280 2281 2282 p = calloc(nelem, elsize); 2283 if (p == NULL) { 2284 (void) fprintf(stderr, gettext(alloc_fail), cmdname, 2285 nelem, elsize); 2286 } 2287 return (p); 2288 } 2289 2290 /* 2291 * find_arg_type - determine if an argument is an ap_id or an ap_type. 2292 */ 2293 static cfga_ap_types_t 2294 find_arg_type(const char *ap_id) 2295 { 2296 struct stat sbuf; 2297 cfga_ap_types_t type; 2298 char *mkr = NULL, *cp; 2299 int size_ap = 0, size_mkr = 0, digit = 0, i = 0; 2300 char path[MAXPATHLEN]; 2301 char apbuf[MAXPATHLEN]; 2302 size_t len; 2303 2304 2305 /* 2306 * sanity checks 2307 */ 2308 if (ap_id == NULL || *ap_id == '\0') { 2309 return (UNKNOWN_AP); 2310 } 2311 2312 /* 2313 * Mask the dynamic component if any 2314 */ 2315 if ((cp = GET_DYN(ap_id)) != NULL) { 2316 len = cp - ap_id; 2317 } else { 2318 len = strlen(ap_id); 2319 } 2320 2321 if (len >= sizeof (apbuf)) { 2322 return (UNKNOWN_AP); 2323 } 2324 2325 (void) strncpy(apbuf, ap_id, len); 2326 apbuf[len] = '\0'; 2327 2328 /* 2329 * If it starts with a slash and is stat-able 2330 * its a physical. 2331 */ 2332 if (*apbuf == '/' && stat(apbuf, &sbuf) == 0) { 2333 return (PHYSICAL_AP_ID); 2334 } 2335 2336 /* 2337 * Is this a symlink in CFGA_DEV_DIR ? 2338 */ 2339 (void) snprintf(path, sizeof (path), "%s/%s", CFGA_DEV_DIR, apbuf); 2340 2341 if (lstat(path, &sbuf) == 0 && S_ISLNK(sbuf.st_mode) && 2342 stat(path, &sbuf) == 0) { 2343 return (LOGICAL_AP_ID); 2344 } 2345 2346 /* 2347 * Check for ":" which is always present in an ap_id but not maybe 2348 * present or absent in an ap_type. 2349 * We need to check that the characters right before the : are digits 2350 * since an ap_id is of the form <name><instance>:<specific ap name> 2351 */ 2352 if ((mkr = strchr(apbuf, ':')) == NULL) { 2353 type = AP_TYPE; 2354 } else { 2355 size_ap = strlen(apbuf); 2356 size_mkr = strlen(mkr); 2357 mkr = apbuf; 2358 2359 digit = 0; 2360 for (i = size_ap - size_mkr - 1; i > 0; i--) { 2361 if ((int)isdigit(mkr[i])) { 2362 digit++; 2363 break; 2364 } 2365 } 2366 if (digit == 0) { 2367 type = AP_TYPE; 2368 } else { 2369 type = LOGICAL_AP_ID; 2370 } 2371 } 2372 2373 return (type); 2374 } 2375 2376 2377 static char * 2378 get_dyn(const char *ap_id) 2379 { 2380 if (ap_id == NULL) { 2381 return (NULL); 2382 } 2383 2384 return (strstr(ap_id, CFGA_DYN_SEP)); 2385 } 2386 2387 /* 2388 * removes the dynamic component 2389 */ 2390 static void 2391 remove_dyn(char *ap_id) 2392 { 2393 char *cp; 2394 2395 if (ap_id == NULL) { 2396 return; 2397 } 2398 2399 cp = strstr(ap_id, CFGA_DYN_SEP); 2400 if (cp != NULL) { 2401 *cp = '\0'; 2402 } 2403 } 2404 2405 2406 static char * 2407 s_strdup(char *str) 2408 { 2409 char *dup; 2410 2411 /* 2412 * sometimes NULL strings may be passed in (see DEF_COLS2). This 2413 * is not an error. 2414 */ 2415 if (str == NULL) { 2416 return (NULL); 2417 } 2418 2419 dup = strdup(str); 2420 if (dup == NULL) { 2421 (void) fprintf(stderr, 2422 "%s \"%s\"\n", gettext("Cannot copy string"), str); 2423 return (NULL); 2424 } 2425 2426 return (dup); 2427 } 2428