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 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <unistd.h> 26 #include <sys/types.h> 27 #include <sys/socket.h> 28 #include <sys/sockio.h> 29 #include <sys/stat.h> 30 #include <netinet/in.h> 31 #include <arpa/inet.h> 32 #include <net/if.h> 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <strings.h> 36 #include <ctype.h> 37 #include <errno.h> 38 #include <libintl.h> 39 #include <locale.h> 40 #include <fcntl.h> 41 #include <libdlpi.h> 42 #include <libdladm.h> 43 #include <libdlib.h> 44 #include <libdllink.h> 45 #include <sys/ib/ibnex/ibnex_devctl.h> 46 47 #define DATADM_OP_VIEW 0x0000 48 #define DATADM_OP_UPDATE 0x0001 49 #define DATADM_OP_ADD 0x0002 50 #define DATADM_OP_REMOVE 0x0003 51 #define DATADM_NUM_OPS 0x0004 52 #define DATADM_DAT_CONF "/etc/dat/dat.conf" 53 #define DATADM_LINESZ 1024 54 #define DATADM_NUM_SP_TOKENS 7 55 #define DATADM_NUM_DAT_TOKENS 8 56 #define DATADM_DRV_NAME "driver_name" 57 #define DATADM_MAX_TOKENS 16 58 59 /* 60 * generic entry 61 * placed at the top of all entry types 62 */ 63 typedef struct datadm_entry { 64 struct datadm_entry *de_next; 65 } datadm_entry_t; 66 67 /* 68 * list structure 69 * can be manipulated using datadm_walk_list or 70 * datadm_enqueue_entry 71 */ 72 typedef struct datadm_list { 73 datadm_entry_t *dl_head; 74 datadm_entry_t *dl_tail; 75 uint_t dl_count; 76 } datadm_list_t; 77 78 /* 79 * internal representation of the version string in 80 * dat.conf or service_provider.conf. the format is 81 * <dv_name><dv_major>.<dv_minor> 82 */ 83 typedef struct datadm_version { 84 char *dv_name; 85 uint_t dv_major; 86 uint_t dv_minor; 87 } datadm_version_t; 88 89 /* 90 * each sp_entry corresponds to an entry in dat.conf or 91 * service_provider.conf. an sp_entry is processed by the 92 * function datadm_process_sp_entry. 93 */ 94 typedef struct datadm_sp_entry { 95 datadm_entry_t spe_header; 96 char *spe_devname; 97 datadm_version_t spe_api_version; 98 int spe_threadsafe; 99 int spe_default; 100 char *spe_libpath; 101 datadm_version_t spe_sp_version; 102 char *spe_sp_data; 103 int spe_invalid; 104 } datadm_sp_entry_t; 105 106 /* 107 * an hca_entry is created whenever a new hca device is 108 * encountered during sp_entry processing. this structure 109 * contains two lists. the sp_list holds sp entries that 110 * are added when sp entry processing occurs. duplicate 111 * sp entries are not added to this list. the ia_list may 112 * be built statically using the information in dat.conf or 113 * dynamically. similar to the sp_list, 114 * the ia_list contains only unique entries. 115 */ 116 typedef struct datadm_hca_entry { 117 datadm_entry_t he_header; 118 char *he_name; 119 datadm_list_t he_sp_list; 120 datadm_list_t he_ia_list; 121 } datadm_hca_entry_t; 122 123 /* 124 * an ia_entry is created when a new ia name is encountered 125 * during sp_entry processing or when a new ia name is 126 * discovered by datadm_build_ia_lists. ia_entry holds the ia 127 * device's instance number. 128 */ 129 typedef struct datadm_ia_entry { 130 datadm_entry_t iae_header; 131 char iae_name[MAXLINKNAMELEN]; 132 } datadm_ia_entry_t; 133 134 /* 135 * a comment entry represents one of the comment lines at the 136 * top of dat.conf. a list of these lines are saved during the 137 * parsing of dat.conf. these lines are written back to dat.conf 138 * when dat.conf gets regenerated. 139 */ 140 typedef struct datadm_cmnt_entry { 141 datadm_entry_t cmnt_header; 142 char *cmnt_line; 143 } datadm_cmnt_entry_t; 144 145 typedef struct datadm_hca_find_by_name { 146 char *hf_name; 147 datadm_hca_entry_t *hf_hca_entry; 148 } datadm_hca_find_by_name_t; 149 150 /* 151 * 2nd argument to datadm_hca_entry_find. 152 * hf_hca_entry is filled in if an hca_entry with 153 * a matching he_name is found. 154 */ 155 typedef struct datadm_hca_find { 156 datadm_sp_entry_t *hf_sp_entry; 157 datadm_hca_entry_t *hf_hca_entry; 158 } datadm_hca_find_t; 159 160 /* 161 * 2nd argument to datadm_ia_entry_find. 162 * if_ia_entry is filled in if an ia_entry with 163 * a matching ia_name is found. 164 */ 165 typedef struct datadm_ia_find { 166 char *if_ia_name; 167 datadm_ia_entry_t *if_ia_entry; 168 } datadm_ia_find_t; 169 170 /* 171 * this gets passed to datadm_add_plink. 172 */ 173 typedef struct datadm_fill_ia_list { 174 datadm_list_t *ia_hca_list; 175 dladm_handle_t ia_dlh; 176 int ia_ibnex_fd; 177 int ia_sock_fd_v4; 178 int ia_sock_fd_v6; 179 } datadm_fill_ia_list_t; 180 181 /* 182 * this defines the commandline parameters specified 183 * by the user. 184 */ 185 typedef struct datadm_args { 186 char *da_sp_conf; 187 char *da_dat_conf; 188 int da_op_type; 189 } datadm_args_t; 190 191 static datadm_args_t datadm_args; 192 static datadm_list_t datadm_conf_header; 193 static char *datadm_conf_header_default = 194 "#\n" 195 "# Copyright (c) 2003, 2010, Oracle and/or its affiliates. " 196 "All rights reserved.\n" 197 "#\n" 198 "# DAT configuration file.\n" 199 "#\n" 200 "# This file is updated using the datadm(1) command.\n" 201 "# Do not hand edit this file.\n" 202 "# See datadm(1) man page for more details.\n" 203 "#\n" 204 "# The fields in this file are -\n" 205 "#\n" 206 "# IAname version threadsafe default library-path provider-version \\\n" 207 "# instance-data platform-information\n" 208 "#\n"; 209 210 /* 211 * common parsing functions. 212 */ 213 typedef int (*datadm_parse_func_t)(char *, void *); 214 static int datadm_parse_line(char *, char *[], int *); 215 static int datadm_parse_generic_str(char *, char **); 216 static int datadm_parse_nonnull_str(char *, char **); 217 static int datadm_parse_version(char *, datadm_version_t *); 218 static int datadm_parse_devname(char *, datadm_sp_entry_t *); 219 static int datadm_parse_api_version(char *, datadm_sp_entry_t *); 220 static int datadm_parse_threadsafe(char *, datadm_sp_entry_t *); 221 static int datadm_parse_default(char *, datadm_sp_entry_t *); 222 static int datadm_parse_libpath(char *, datadm_sp_entry_t *); 223 static int datadm_parse_sp_version(char *, datadm_sp_entry_t *); 224 static int datadm_parse_sp_data(char *, datadm_sp_entry_t *); 225 static int datadm_parse_ia_name(char *, char *); 226 227 /* 228 * utility functions 229 */ 230 static void datadm_enqueue_entry(datadm_list_t *, datadm_entry_t *); 231 static int datadm_walk_list(datadm_list_t *, 232 int (*)(datadm_entry_t *, void *), void *); 233 static int datadm_str_match(char *, char *); 234 static int datadm_version_match(datadm_version_t *, datadm_version_t *); 235 static int datadm_sp_entry_match(datadm_sp_entry_t *, datadm_sp_entry_t *); 236 237 /* 238 * entry allocation/deallocation 239 */ 240 static datadm_sp_entry_t *datadm_alloc_sp_entry(void); 241 static datadm_ia_entry_t *datadm_alloc_ia_entry(void); 242 static datadm_hca_entry_t *datadm_alloc_hca_entry(void); 243 static datadm_cmnt_entry_t *datadm_alloc_cmnt_entry(void); 244 static void datadm_free_sp_entry(datadm_sp_entry_t *); 245 static void datadm_free_ia_entry(datadm_ia_entry_t *); 246 static void datadm_free_hca_entry(datadm_hca_entry_t *); 247 static void datadm_free_cmnt_entry(datadm_cmnt_entry_t *); 248 249 250 /* 251 * high level parsing functions 252 */ 253 static int datadm_parse_sp_conf(datadm_list_t *); 254 static int datadm_parse_dat_conf(datadm_list_t *); 255 static int datadm_process_sp_entry(datadm_list_t *, datadm_sp_entry_t *, 256 char *); 257 258 /* 259 * ia devices discovery 260 */ 261 static int datadm_build_ia_lists(datadm_list_t *); 262 263 /* 264 * helper function for OP_REMOVE 265 */ 266 static void datadm_invalidate_common_sp_entries(datadm_list_t *, 267 datadm_list_t *); 268 269 /* 270 * output generation 271 */ 272 static int datadm_generate_dat_conf(datadm_list_t *); 273 static int datadm_generate_conf_header(FILE *); 274 static int datadm_generate_conf_entry(FILE *, datadm_ia_entry_t *, 275 datadm_sp_entry_t *); 276 277 /* 278 * datadm operations 279 */ 280 static int datadm_view(void); 281 static int datadm_update(void); 282 static int datadm_add(void); 283 static int datadm_remove(void); 284 285 /* 286 * usage 287 */ 288 static void datadm_usage(void); 289 290 291 /* 292 * parse function tables 293 */ 294 static datadm_parse_func_t datadm_sp_parse_funcs[DATADM_NUM_SP_TOKENS] = { 295 (datadm_parse_func_t)datadm_parse_devname, 296 (datadm_parse_func_t)datadm_parse_api_version, 297 (datadm_parse_func_t)datadm_parse_threadsafe, 298 (datadm_parse_func_t)datadm_parse_default, 299 (datadm_parse_func_t)datadm_parse_libpath, 300 (datadm_parse_func_t)datadm_parse_sp_version, 301 (datadm_parse_func_t)datadm_parse_sp_data 302 }; 303 304 static datadm_parse_func_t datadm_dat_parse_funcs[DATADM_NUM_DAT_TOKENS] = { 305 (datadm_parse_func_t)datadm_parse_ia_name, 306 (datadm_parse_func_t)datadm_parse_api_version, 307 (datadm_parse_func_t)datadm_parse_threadsafe, 308 (datadm_parse_func_t)datadm_parse_default, 309 (datadm_parse_func_t)datadm_parse_libpath, 310 (datadm_parse_func_t)datadm_parse_sp_version, 311 (datadm_parse_func_t)datadm_parse_sp_data, 312 (datadm_parse_func_t)datadm_parse_devname 313 }; 314 315 /* 316 * operation table 317 */ 318 static int (*datadm_ops[DATADM_NUM_OPS])(void) = { 319 datadm_view, 320 datadm_update, 321 datadm_add, 322 datadm_remove 323 }; 324 325 static void 326 datadm_usage(void) 327 { 328 (void) fprintf(stderr, gettext( 329 "usage: datadm -v\n" 330 " -u\n" 331 " -a <service_provider.conf>\n" 332 " -r <service_provider.conf>\n")); 333 } 334 335 static int 336 datadm_parse_generic_str(char *str, char **strptr) 337 { 338 int len; 339 340 len = strlen(str); 341 *strptr = (char *)malloc(len + 1); 342 if (*strptr == NULL) { 343 return (-1); 344 } 345 (void) strcpy(*strptr, str); 346 return (0); 347 } 348 349 /* 350 * this function strips off leading and trailing 351 * whitespaces and returns an error for null or 352 * empty strings. 353 */ 354 static int 355 datadm_parse_nonnull_str(char *str, char **strptr) 356 { 357 int len, i; 358 char *start; 359 360 if (str[0] == '\0') { 361 return (-1); 362 } 363 start = str; 364 for (i = 0; str[i] != '\0'; i++) { 365 if (!isspace(str[i])) { 366 start = &str[i]; 367 break; 368 } 369 } 370 for (; str[i] != '\0'; i++) { 371 if (isspace(str[i])) { 372 str[i] = '\0'; 373 } 374 } 375 len = strlen(start); 376 *strptr = (char *)malloc(len + 1); 377 if (*strptr == NULL) { 378 return (-1); 379 } 380 (void) strcpy(*strptr, start); 381 return (0); 382 } 383 384 /* 385 * parses the api_version and sp_version fields in 386 * dat.conf and service_provider.conf 387 */ 388 static int 389 datadm_parse_version(char *str, datadm_version_t *version) 390 { 391 int i = 0, len; 392 int major_idx, minor_idx; 393 394 len = strlen(str); 395 396 for (i = 0; i < len; i++) { 397 if (isdigit(str[i])) break; 398 } 399 if (i == len) { 400 return (-1); 401 } 402 if (i > 0) { 403 version->dv_name = (char *)malloc(i + 1); 404 bcopy(str, version->dv_name, i); 405 version->dv_name[i] = '\0'; 406 } else { 407 version->dv_name = NULL; 408 } 409 major_idx = i; 410 411 for (; i < len; i++) { 412 if (!isdigit(str[i])) break; 413 } 414 if (i == len) { 415 return (-1); 416 } 417 if (str[i] != '.') { 418 return (-1); 419 } 420 minor_idx = ++i; 421 if (i == len) { 422 return (-1); 423 } 424 for (; i < len; i++) { 425 if (!isdigit(str[i])) break; 426 } 427 if (i != len) { 428 return (-1); 429 } 430 version->dv_major = atoi(str + major_idx); 431 version->dv_minor = atoi(str + minor_idx); 432 return (0); 433 } 434 435 /* 436 * parses the ia_name field in dat.conf 437 */ 438 static int 439 datadm_parse_ia_name(char *str, char *ia_name) 440 { 441 if (strlen(str) >= MAXLINKNAMELEN) 442 return (-1); 443 (void) strlcpy(ia_name, str, MAXLINKNAMELEN); 444 return (0); 445 } 446 447 /* 448 * parses the device name, strips leading and trailing spaces. 449 * the format should be "driver_name=<dev_name>" 450 */ 451 static int 452 datadm_parse_devname(char *str, datadm_sp_entry_t *sp_entry) 453 { 454 int len, dlen, i, j = 0; 455 char *drv_name = DATADM_DRV_NAME; 456 457 len = strlen(str); 458 dlen = strlen(drv_name); 459 460 /* 461 * strip out leading spaces and try to match 462 * the expected string 463 */ 464 for (i = 0; i < len; i++) { 465 if (isspace(str[i]) && j == 0) { 466 continue; 467 } else { 468 if (str[i] == drv_name[j]) { 469 j++; 470 if (j == dlen) { 471 break; 472 } else { 473 continue; 474 } 475 } else { 476 break; 477 } 478 } 479 } 480 481 /* 482 * j must be dlen if the matching string is found 483 */ 484 if (j != dlen) { 485 return (-1); 486 } 487 488 /* 489 * skip past the last char of drv_name 490 */ 491 i++; 492 493 /* 494 * strip the spaces before the '=' 495 */ 496 for (; i < len; i++) { 497 if (!isspace(str[i])) { 498 break; 499 } 500 } 501 502 /* 503 * return if the string is too long or if 504 * the '=' isn't found 505 */ 506 if (i >= len || str[i] != '=') { 507 return (-1); 508 } 509 i++; 510 if (i >= len) { 511 /* 512 * no string after the equal 513 */ 514 return (-1); 515 } 516 return (datadm_parse_nonnull_str(str + i, &sp_entry->spe_devname)); 517 } 518 519 static int 520 datadm_parse_api_version(char *str, datadm_sp_entry_t *sp_entry) 521 { 522 return (datadm_parse_version(str, &sp_entry->spe_api_version)); 523 } 524 525 static int 526 datadm_parse_threadsafe(char *str, datadm_sp_entry_t *sp_entry) 527 { 528 int retval = 0; 529 530 if (strcmp(str, "threadsafe") == 0) { 531 sp_entry->spe_threadsafe = 1; 532 } else if (strcmp(str, "nonthreadsafe") == 0) { 533 sp_entry->spe_threadsafe = 0; 534 } else { 535 retval = -1; 536 } 537 return (retval); 538 } 539 540 static int 541 datadm_parse_default(char *str, datadm_sp_entry_t *sp_entry) 542 { 543 int retval = 0; 544 545 if (strcmp(str, "default") == 0) { 546 sp_entry->spe_default = 1; 547 } else if (strcmp(str, "nondefault") == 0) { 548 sp_entry->spe_default = 0; 549 } else { 550 retval = -1; 551 } 552 return (retval); 553 } 554 555 static int 556 datadm_parse_libpath(char *str, datadm_sp_entry_t *sp_entry) 557 { 558 return (datadm_parse_nonnull_str(str, &sp_entry->spe_libpath)); 559 } 560 561 static int 562 datadm_parse_sp_version(char *str, datadm_sp_entry_t *sp_entry) 563 { 564 return (datadm_parse_version(str, &sp_entry->spe_sp_version)); 565 } 566 567 static int 568 datadm_parse_sp_data(char *str, datadm_sp_entry_t *sp_entry) 569 { 570 return (datadm_parse_generic_str(str, &sp_entry->spe_sp_data)); 571 } 572 573 static void 574 datadm_enqueue_entry(datadm_list_t *list, datadm_entry_t *entry) 575 { 576 if (list->dl_head == NULL) { 577 list->dl_head = entry; 578 list->dl_tail = entry; 579 list->dl_count = 1; 580 } else { 581 list->dl_tail->de_next = entry; 582 list->dl_tail = entry; 583 list->dl_count++; 584 } 585 } 586 587 /* 588 * iterates through the list applying func on each element. 589 * break and return if func returns non-zero. 590 */ 591 static int 592 datadm_walk_list(datadm_list_t *list, int (*func)(datadm_entry_t *, void *), 593 void *arg) 594 { 595 datadm_entry_t *entry; 596 int retval = 0; 597 598 entry = list->dl_head; 599 while (entry != NULL) { 600 retval = (*func)(entry, arg); 601 if (retval != 0) break; 602 entry = entry->de_next; 603 } 604 return (retval); 605 } 606 607 /* 608 * iterates through the list applying free_func to each element. 609 * list becomes empty when the function returns. 610 */ 611 static void 612 datadm_free_list(datadm_list_t *list, void (*free_func)(datadm_entry_t *)) 613 { 614 while (list->dl_head != NULL) { 615 datadm_entry_t *entry; 616 617 entry = list->dl_head; 618 list->dl_head = entry->de_next; 619 (*free_func)(entry); 620 } 621 list->dl_count = 0; 622 list->dl_tail = NULL; 623 } 624 625 static datadm_sp_entry_t * 626 datadm_alloc_sp_entry(void) 627 { 628 datadm_sp_entry_t *sp_entry; 629 630 sp_entry = (datadm_sp_entry_t *)malloc(sizeof (*sp_entry)); 631 if (sp_entry == NULL) { 632 return (NULL); 633 } 634 bzero(sp_entry, sizeof (*sp_entry)); 635 return (sp_entry); 636 } 637 638 static void 639 datadm_free_sp_entry(datadm_sp_entry_t *sp_entry) 640 { 641 if (sp_entry->spe_devname != NULL) { 642 free(sp_entry->spe_devname); 643 sp_entry->spe_devname = NULL; 644 } 645 if (sp_entry->spe_api_version.dv_name != NULL) { 646 free(sp_entry->spe_api_version.dv_name); 647 sp_entry->spe_api_version.dv_name = NULL; 648 } 649 sp_entry->spe_api_version.dv_major = 0; 650 sp_entry->spe_api_version.dv_minor = 0; 651 sp_entry->spe_threadsafe = 0; 652 sp_entry->spe_default = 0; 653 if (sp_entry->spe_libpath != NULL) { 654 free(sp_entry->spe_libpath); 655 sp_entry->spe_libpath = NULL; 656 } 657 if (sp_entry->spe_sp_version.dv_name != NULL) { 658 free(sp_entry->spe_sp_version.dv_name); 659 sp_entry->spe_sp_version.dv_name = NULL; 660 } 661 sp_entry->spe_sp_version.dv_major = 0; 662 sp_entry->spe_sp_version.dv_minor = 0; 663 if (sp_entry->spe_sp_data != NULL) { 664 free(sp_entry->spe_sp_data); 665 sp_entry->spe_sp_data = NULL; 666 } 667 free(sp_entry); 668 } 669 670 static int 671 datadm_str_match(char *s1, char *s2) 672 { 673 if (s1 == NULL || s2 == NULL) { 674 if (s1 != s2) { 675 return (0); 676 } 677 } else { 678 if (strcmp(s1, s2) != 0) { 679 return (0); 680 } 681 } 682 return (1); 683 } 684 685 static int 686 datadm_version_match(datadm_version_t *v1, datadm_version_t *v2) 687 { 688 if (!datadm_str_match(v1->dv_name, v2->dv_name)) { 689 return (0); 690 } 691 if (v1->dv_major != v2->dv_major) { 692 return (0); 693 } 694 if (v1->dv_minor != v2->dv_minor) { 695 return (0); 696 } 697 return (1); 698 } 699 700 static int 701 datadm_sp_entry_match(datadm_sp_entry_t *sp1, datadm_sp_entry_t *sp2) 702 { 703 if (!datadm_str_match(sp1->spe_devname, sp2->spe_devname)) { 704 return (0); 705 } 706 if (!datadm_version_match(&sp1->spe_api_version, 707 &sp2->spe_api_version)) { 708 return (0); 709 } 710 if (sp1->spe_threadsafe != sp2->spe_threadsafe) { 711 return (0); 712 } 713 if (sp2->spe_default != sp2->spe_default) { 714 return (0); 715 } 716 if (!datadm_str_match(sp1->spe_libpath, sp2->spe_libpath)) { 717 return (0); 718 } 719 if (!datadm_version_match(&sp1->spe_sp_version, 720 &sp2->spe_sp_version)) { 721 return (0); 722 } 723 if (!datadm_str_match(sp1->spe_sp_data, sp2->spe_sp_data)) { 724 return (0); 725 } 726 return (1); 727 } 728 729 static datadm_ia_entry_t * 730 datadm_alloc_ia_entry(void) 731 { 732 datadm_ia_entry_t *ia_entry; 733 734 ia_entry = (datadm_ia_entry_t *)malloc(sizeof (*ia_entry)); 735 if (ia_entry == NULL) { 736 return (NULL); 737 } 738 bzero(ia_entry, sizeof (*ia_entry)); 739 return (ia_entry); 740 } 741 742 static void 743 datadm_free_ia_entry(datadm_ia_entry_t *ia_entry) 744 { 745 free(ia_entry); 746 } 747 748 static datadm_hca_entry_t * 749 datadm_alloc_hca_entry(void) 750 { 751 datadm_hca_entry_t *hca_entry; 752 753 hca_entry = (datadm_hca_entry_t *)malloc(sizeof (*hca_entry)); 754 if (hca_entry == NULL) { 755 return (NULL); 756 } 757 bzero(hca_entry, sizeof (*hca_entry)); 758 return (hca_entry); 759 } 760 761 static void 762 datadm_free_hca_entry(datadm_hca_entry_t *hca_entry) 763 { 764 if (hca_entry->he_name != NULL) { 765 free(hca_entry->he_name); 766 hca_entry->he_name = NULL; 767 } 768 datadm_free_list(&hca_entry->he_sp_list, 769 (void (*)(datadm_entry_t *))datadm_free_sp_entry); 770 datadm_free_list(&hca_entry->he_ia_list, 771 (void (*)(datadm_entry_t *))datadm_free_ia_entry); 772 free(hca_entry); 773 } 774 775 static int 776 datadm_hca_entry_match(datadm_hca_entry_t *h1, datadm_hca_entry_t *h2) 777 { 778 if (!datadm_str_match(h1->he_name, h2->he_name)) { 779 return (0); 780 } 781 return (1); 782 } 783 784 static int 785 datadm_hca_entry_find(datadm_hca_entry_t *h1, datadm_hca_find_t *hf) 786 { 787 if (datadm_str_match(h1->he_name, hf->hf_sp_entry->spe_devname)) { 788 hf->hf_hca_entry = h1; 789 return (1); 790 } 791 return (0); 792 } 793 794 static int 795 datadm_ia_entry_find(datadm_ia_entry_t *i1, datadm_ia_find_t *iaf) 796 { 797 if (strcmp(i1->iae_name, iaf->if_ia_name) == 0) { 798 iaf->if_ia_entry = i1; 799 return (1); 800 } 801 return (0); 802 } 803 804 static datadm_cmnt_entry_t * 805 datadm_alloc_cmnt_entry(void) 806 { 807 datadm_cmnt_entry_t *cmnt_entry; 808 809 cmnt_entry = (datadm_cmnt_entry_t *)malloc(sizeof (*cmnt_entry)); 810 if (cmnt_entry == NULL) { 811 return (NULL); 812 } 813 bzero(cmnt_entry, sizeof (*cmnt_entry)); 814 return (cmnt_entry); 815 } 816 817 static void 818 datadm_free_cmnt_entry(datadm_cmnt_entry_t *cmnt_entry) 819 { 820 if (cmnt_entry->cmnt_line != NULL) { 821 free(cmnt_entry->cmnt_line); 822 cmnt_entry->cmnt_line = NULL; 823 } 824 free(cmnt_entry); 825 } 826 827 /* 828 * tokenizes a line and strips off the quotes from quoted strings 829 */ 830 static int 831 datadm_parse_line(char *line_buf, char *tokens[], int *token_count) 832 { 833 int len, i; 834 int count = 0; 835 char *start = NULL; 836 837 /* the line must not be longer than DATADM_LINESZ */ 838 len = strlen(line_buf); 839 if (line_buf[len - 1] != '\n') { 840 return (-1); 841 } 842 /* discard blank lines and comments */ 843 if (len == 1) { 844 *token_count = 0; 845 return (0); 846 } 847 if (len >= 2 && line_buf[0] == '#') { 848 *token_count = 0; 849 return (0); 850 } 851 /* removes the new line */ 852 line_buf[len - 1] = '\0'; 853 len--; 854 855 for (i = 0; i < len; i++) { 856 if (start != NULL) { 857 /* 858 * start points to the start of 859 * a new token. if start is '"', 860 * we should expect a quoted 861 * string. 862 */ 863 if (*start == '\"') { 864 /* 865 * keep scanning until we 866 * hit the end quote. 867 */ 868 if (line_buf[i] != '\"') { 869 continue; 870 } 871 /* 872 * skip past the start quote 873 */ 874 start++; 875 } else { 876 /* 877 * our token is not a quoted 878 * string. our token ends only 879 * when we hit a whitespace. 880 */ 881 if (!isspace(line_buf[i])) { 882 continue; 883 } 884 } 885 /* 886 * nullify the end quote (if any) 887 * and update the tokens array. 888 */ 889 line_buf[i] = '\0'; 890 tokens[count] = start; 891 start = NULL; 892 count++; 893 } else { 894 /* 895 * skip whitespaces 896 */ 897 if (isspace(line_buf[i])) { 898 continue; 899 } else { 900 start = &line_buf[i]; 901 } 902 } 903 if (count == DATADM_MAX_TOKENS) { 904 start = NULL; 905 break; 906 } 907 } 908 if (start != NULL) { 909 tokens[count] = start; 910 start = NULL; 911 count++; 912 } 913 *token_count = count; 914 return (0); 915 } 916 917 /* 918 * attempts to save sp_entry into hca_list. 919 * becomes no-op if sp entry already exists. 920 * new hca entries and ia entries are created as needed. 921 */ 922 static int 923 datadm_process_sp_entry(datadm_list_t *hca_list, datadm_sp_entry_t *sp_entry, 924 char *ia_name) 925 { 926 datadm_hca_find_t hca_find; 927 datadm_ia_find_t ia_find; 928 datadm_hca_entry_t *hca_entry; 929 930 hca_find.hf_sp_entry = sp_entry; 931 hca_find.hf_hca_entry = NULL; 932 (void) datadm_walk_list(hca_list, (int (*)(datadm_entry_t *, void *)) 933 datadm_hca_entry_find, (void *)&hca_find); 934 935 if (hca_find.hf_hca_entry == NULL) { 936 int dlen; 937 938 /* 939 * hca_entry not found, need to create 940 * and insert one. 941 */ 942 hca_entry = datadm_alloc_hca_entry(); 943 if (hca_entry == NULL) { 944 return (-1); 945 } 946 dlen = strlen(sp_entry->spe_devname); 947 hca_entry->he_name = (char *)malloc(dlen + 1); 948 if (hca_entry->he_name == NULL) { 949 datadm_free_hca_entry(hca_entry); 950 return (-1); 951 } 952 (void) strcpy(hca_entry->he_name, sp_entry->spe_devname); 953 datadm_enqueue_entry(hca_list, (datadm_entry_t *)hca_entry); 954 } else { 955 hca_entry = hca_find.hf_hca_entry; 956 } 957 if (ia_name == NULL) { 958 goto put_sp_entry; 959 } 960 ia_find.if_ia_name = ia_name; 961 ia_find.if_ia_entry = NULL; 962 (void) datadm_walk_list(&hca_entry->he_ia_list, 963 (int (*)(datadm_entry_t *, void *))datadm_ia_entry_find, &ia_find); 964 965 if (ia_find.if_ia_entry == NULL) { 966 datadm_ia_entry_t *ia_entry; 967 968 /* 969 * ia_entry not found, need to create 970 * and insert one. 971 */ 972 ia_entry = datadm_alloc_ia_entry(); 973 if (ia_entry == NULL) { 974 return (-1); 975 } 976 (void) strlcpy(ia_entry->iae_name, ia_name, MAXLINKNAMELEN); 977 datadm_enqueue_entry(&hca_entry->he_ia_list, 978 (datadm_entry_t *)ia_entry); 979 } 980 981 put_sp_entry:; 982 983 if (datadm_walk_list(&hca_entry->he_sp_list, 984 (int (*)(datadm_entry_t *, void *))datadm_sp_entry_match, 985 (void *)sp_entry)) { 986 return (1); 987 } else { 988 /* 989 * only insert sp_entry if it is not found. 990 */ 991 datadm_enqueue_entry(&hca_entry->he_sp_list, 992 (datadm_entry_t *)sp_entry); 993 } 994 return (0); 995 } 996 997 /* 998 * parses service_provider.conf 999 */ 1000 static int 1001 datadm_parse_sp_conf(datadm_list_t *hca_list) 1002 { 1003 datadm_sp_entry_t *sp_entry; 1004 FILE *sp_file; 1005 char *sp_conf = datadm_args.da_sp_conf; 1006 char *tokens[DATADM_MAX_TOKENS]; 1007 char line_buf[DATADM_LINESZ]; 1008 int retval = 0; 1009 int token_count = 0; 1010 int line_count = 0; 1011 1012 sp_file = fopen(sp_conf, "r"); 1013 if (sp_file == NULL) { 1014 (void) fprintf(stderr, 1015 gettext("datadm: cannot open %s\n"), sp_conf); 1016 return (-1); 1017 } 1018 1019 for (;;) { 1020 bzero(line_buf, DATADM_LINESZ); 1021 if (fgets(line_buf, DATADM_LINESZ, sp_file) == NULL) { 1022 break; 1023 } 1024 token_count = 0; 1025 line_count++; 1026 retval = datadm_parse_line(line_buf, tokens, &token_count); 1027 if (retval != 0) { 1028 (void) fprintf(stderr, gettext( 1029 "datadm: %s: line %d exceeded max length %d\n"), 1030 sp_conf, line_count, DATADM_LINESZ); 1031 break; 1032 } 1033 if (token_count == 0) continue; 1034 if (token_count == DATADM_NUM_SP_TOKENS) { 1035 int i = 0; 1036 1037 sp_entry = datadm_alloc_sp_entry(); 1038 if (sp_entry == NULL) { 1039 retval = -1; 1040 break; 1041 } 1042 1043 /* 1044 * sp_entry gets filled incrementally by 1045 * each parsing function 1046 */ 1047 for (i = 0; i < DATADM_NUM_SP_TOKENS && 1048 retval == 0; i++) { 1049 retval = (*datadm_sp_parse_funcs[i]) 1050 (tokens[i], (void *)sp_entry); 1051 } 1052 if (retval != 0) { 1053 (void) fprintf(stderr, gettext( 1054 "datadm: parse error: %s, " 1055 "line %d, token: %s\n"), 1056 sp_conf, line_count, tokens[i - 1]); 1057 datadm_free_sp_entry(sp_entry); 1058 sp_entry = NULL; 1059 break; 1060 } 1061 1062 retval = datadm_process_sp_entry(hca_list, 1063 sp_entry, NULL); 1064 if (retval != 0) { 1065 datadm_free_sp_entry(sp_entry); 1066 if (retval == 1) { 1067 retval = 0; 1068 } else { 1069 break; 1070 } 1071 } 1072 } else { 1073 (void) fprintf(stderr, gettext( 1074 "datadm: parse error: %s, line %d, " 1075 "# of tokens: %d, expected %d\n"), sp_conf, 1076 line_count, token_count, DATADM_NUM_SP_TOKENS); 1077 retval = -1; 1078 break; 1079 } 1080 } 1081 if (retval != 0) { 1082 datadm_free_list(hca_list, 1083 (void (*)(datadm_entry_t *))datadm_free_hca_entry); 1084 } 1085 (void) fclose(sp_file); 1086 return (retval); 1087 } 1088 1089 /* 1090 * parses dat.conf 1091 */ 1092 static int 1093 datadm_parse_dat_conf(datadm_list_t *hca_list) 1094 { 1095 boolean_t save_header = B_TRUE; 1096 datadm_sp_entry_t *sp_entry; 1097 FILE *dat_file; 1098 char *dat_conf = datadm_args.da_dat_conf; 1099 char *tokens[DATADM_MAX_TOKENS]; 1100 char line_buf[DATADM_LINESZ]; 1101 int retval = 0; 1102 int token_count = 0; 1103 int line_count = 0; 1104 1105 dat_file = fopen(dat_conf, "r"); 1106 if (dat_file == NULL) { 1107 /* dat.conf not existing is not an error for OP_ADD */ 1108 if (datadm_args.da_op_type == DATADM_OP_ADD) { 1109 return (0); 1110 } 1111 (void) fprintf(stderr, gettext("datadm: cannot open %s\n"), 1112 dat_conf); 1113 return (-1); 1114 } 1115 1116 for (;;) { 1117 bzero(line_buf, DATADM_LINESZ); 1118 if (fgets(line_buf, DATADM_LINESZ, dat_file) == NULL) { 1119 break; 1120 } 1121 token_count = 0; 1122 line_count++; 1123 retval = datadm_parse_line(line_buf, tokens, &token_count); 1124 if (retval != 0) { 1125 (void) fprintf(stderr, gettext( 1126 "datadm: %s: line %d exceeded max length %d\n"), 1127 dat_conf, line_count, DATADM_LINESZ); 1128 break; 1129 } 1130 if (token_count == 0) { 1131 datadm_cmnt_entry_t *cmnt_entry; 1132 int cmnt_len; 1133 1134 /* 1135 * comments are saved only if they are 1136 * at the top of dat.conf. 1137 */ 1138 if (!save_header) continue; 1139 cmnt_entry = datadm_alloc_cmnt_entry(); 1140 if (cmnt_entry == NULL) { 1141 perror("datadm: malloc"); 1142 retval = -1; 1143 break; 1144 } 1145 cmnt_len = strlen(line_buf); 1146 cmnt_entry->cmnt_line = (char *)malloc(cmnt_len + 1); 1147 if (cmnt_entry->cmnt_line == NULL) { 1148 perror("datadm: malloc"); 1149 datadm_free_cmnt_entry(cmnt_entry); 1150 retval = -1; 1151 break; 1152 } 1153 (void) strncpy(cmnt_entry->cmnt_line, 1154 line_buf, cmnt_len); 1155 cmnt_entry->cmnt_line[cmnt_len] = '\0'; 1156 datadm_enqueue_entry(&datadm_conf_header, 1157 (datadm_entry_t *)cmnt_entry); 1158 continue; 1159 } 1160 if (token_count == DATADM_NUM_DAT_TOKENS) { 1161 int i = 0; 1162 char ia_name[MAXLINKNAMELEN]; 1163 1164 /* 1165 * we stop saving comment lines once 1166 * we see the first valid line. 1167 */ 1168 save_header = B_FALSE; 1169 sp_entry = datadm_alloc_sp_entry(); 1170 if (sp_entry == NULL) { 1171 retval = -1; 1172 break; 1173 } 1174 1175 /* 1176 * sp_entry gets filled incrementally by 1177 * each parsing function 1178 */ 1179 for (i = 0; i < DATADM_NUM_DAT_TOKENS && 1180 retval == 0; i++) { 1181 void *arg; 1182 1183 if (i == 0) { 1184 /* 1185 * the first token (ia name) 1186 * does not belong to an 1187 * sp_entry 1188 */ 1189 arg = (void *)ia_name; 1190 } else { 1191 arg = (void *)sp_entry; 1192 } 1193 retval = (*datadm_dat_parse_funcs[i]) 1194 (tokens[i], arg); 1195 } 1196 if (retval != 0) { 1197 (void) fprintf(stderr, gettext( 1198 "datadm: parse error: %s, " 1199 "line %d, token: %s\n"), dat_conf, 1200 line_count, tokens[i - 1]); 1201 datadm_free_sp_entry(sp_entry); 1202 sp_entry = NULL; 1203 break; 1204 } 1205 1206 /* 1207 * we ignore the ibds in dat.conf if we are 1208 * doing update 1209 */ 1210 if (datadm_args.da_op_type == DATADM_OP_UPDATE) { 1211 retval = datadm_process_sp_entry(hca_list, 1212 sp_entry, NULL); 1213 } else { 1214 retval = datadm_process_sp_entry(hca_list, 1215 sp_entry, ia_name); 1216 } 1217 if (retval != 0) { 1218 datadm_free_sp_entry(sp_entry); 1219 if (retval == 1) { 1220 retval = 0; 1221 } else { 1222 break; 1223 } 1224 } 1225 } else { 1226 (void) fprintf(stderr, gettext( 1227 "datadm: parse error: %s, line %d, " 1228 "# of tokens: %d, expected %d\n"), dat_conf, 1229 line_count, token_count, DATADM_NUM_DAT_TOKENS); 1230 retval = -1; 1231 break; 1232 } 1233 } 1234 if (retval != 0) { 1235 datadm_free_list(&datadm_conf_header, 1236 (void (*)(datadm_entry_t *))datadm_free_cmnt_entry); 1237 datadm_free_list(hca_list, 1238 (void (*)(datadm_entry_t *))datadm_free_hca_entry); 1239 } 1240 (void) fclose(dat_file); 1241 return (retval); 1242 } 1243 1244 /* 1245 * used by OP_REMOVE to invalidate common sp entries between hl1 and hl2. 1246 * invalid sp entries will be ignored by datadm_generate_dat_conf. 1247 */ 1248 static void 1249 datadm_invalidate_common_sp_entries(datadm_list_t *hl1, datadm_list_t *hl2) 1250 { 1251 datadm_entry_t *he1, *he2; 1252 1253 he1 = hl1->dl_head; 1254 while (he1 != NULL) { 1255 he2 = hl2->dl_head; 1256 while (he2 != NULL) { 1257 datadm_entry_t *se1, *se2; 1258 1259 if (!datadm_hca_entry_match( 1260 (datadm_hca_entry_t *)he1, 1261 (datadm_hca_entry_t *)he2)) { 1262 he2 = he2->de_next; 1263 continue; 1264 } 1265 se1 = ((datadm_hca_entry_t *)he1)->he_sp_list.dl_head; 1266 while (se1 != NULL) { 1267 se2 = ((datadm_hca_entry_t *)he2)-> 1268 he_sp_list.dl_head; 1269 while (se2 != NULL) { 1270 if (!datadm_sp_entry_match( 1271 (datadm_sp_entry_t *)se1, 1272 (datadm_sp_entry_t *)se2)) { 1273 se2 = se2->de_next; 1274 continue; 1275 } 1276 ((datadm_sp_entry_t *)se1)-> 1277 spe_invalid = 1; 1278 break; 1279 } 1280 se1 = se1->de_next; 1281 } 1282 break; 1283 } 1284 he1 = he1->de_next; 1285 } 1286 } 1287 1288 static int 1289 datadm_hca_entry_find_by_name(datadm_hca_entry_t *h1, 1290 datadm_hca_find_by_name_t *hf) 1291 { 1292 if (datadm_str_match(h1->he_name, hf->hf_name)) { 1293 hf->hf_hca_entry = h1; 1294 return (1); 1295 } 1296 return (0); 1297 } 1298 1299 datadm_hca_entry_t * 1300 datadm_hca_lookup_by_name(datadm_list_t *hca_list, char *hca_driver_name) 1301 { 1302 datadm_hca_find_by_name_t hf; 1303 1304 hf.hf_name = hca_driver_name; 1305 hf.hf_hca_entry = NULL; 1306 (void) datadm_walk_list(hca_list, 1307 (int (*)(datadm_entry_t *, void *))datadm_hca_entry_find_by_name, 1308 &hf); 1309 return (hf.hf_hca_entry); 1310 } 1311 1312 static boolean_t 1313 datadm_add_plink(char *linkname, datadm_fill_ia_list_t *ia_args) 1314 { 1315 datalink_class_t class; 1316 datalink_id_t linkid; 1317 dladm_ib_attr_t ib_attr; 1318 ibnex_ctl_query_hca_t query_hca; 1319 datadm_hca_entry_t *hca; 1320 struct lifreq req; 1321 datadm_ia_find_t ia_find; 1322 datadm_ia_entry_t *ia_entry; 1323 1324 if ((dladm_name2info(ia_args->ia_dlh, linkname, &linkid, NULL, &class, 1325 NULL) != DLADM_STATUS_OK) || 1326 (class != DATALINK_CLASS_PART) || 1327 (dladm_part_info(ia_args->ia_dlh, linkid, &ib_attr, 1328 DLADM_OPT_ACTIVE) != DLADM_STATUS_OK)) { 1329 return (B_FALSE); 1330 } 1331 1332 (void) strlcpy(req.lifr_name, linkname, sizeof (req.lifr_name)); 1333 /* 1334 * we don't really need to know the ip address. 1335 * we just want to check if the device is plumbed 1336 * or not. 1337 */ 1338 if (ioctl(ia_args->ia_sock_fd_v4, SIOCGLIFADDR, (caddr_t)&req) != 0) { 1339 /* 1340 * we try v6 if the v4 address isn't found. 1341 */ 1342 if (ioctl(ia_args->ia_sock_fd_v6, SIOCGLIFADDR, 1343 (caddr_t)&req) != 0) 1344 return (B_FALSE); 1345 } 1346 1347 bzero(&query_hca, sizeof (query_hca)); 1348 query_hca.hca_guid = ib_attr.dia_hca_guid; 1349 if (ioctl(ia_args->ia_ibnex_fd, IBNEX_CTL_QUERY_HCA, &query_hca) == -1) 1350 return (B_FALSE); 1351 1352 if ((hca = datadm_hca_lookup_by_name(ia_args->ia_hca_list, 1353 query_hca.hca_info.hca_driver_name)) == NULL) 1354 return (B_FALSE); 1355 1356 ia_find.if_ia_name = linkname; 1357 ia_find.if_ia_entry = NULL; 1358 (void) datadm_walk_list(&hca->he_ia_list, 1359 (int (*)(datadm_entry_t *, void *)) 1360 datadm_ia_entry_find, &ia_find); 1361 1362 if (ia_find.if_ia_entry == NULL) { 1363 /* 1364 * we insert an ia entry only if 1365 * it is unique. 1366 */ 1367 ia_entry = datadm_alloc_ia_entry(); 1368 if (ia_entry != NULL) { 1369 (void) strlcpy(ia_entry->iae_name, linkname, 1370 MAXLINKNAMELEN); 1371 datadm_enqueue_entry(&hca->he_ia_list, 1372 (datadm_entry_t *)ia_entry); 1373 } 1374 } 1375 1376 return (B_FALSE); 1377 } 1378 1379 /* 1380 * build ia lists for each hca_list element 1381 */ 1382 static int 1383 datadm_build_ia_lists(datadm_list_t *hca_list) 1384 { 1385 dladm_handle_t dlh; 1386 datadm_fill_ia_list_t ia_args; 1387 int rv = -1; 1388 int fd = -1; 1389 int sv4 = -1; 1390 int sv6 = -1; 1391 1392 if (dladm_open(&dlh) != DLADM_STATUS_OK) 1393 return (-1); 1394 1395 if ((fd = open(IBNEX_DEVCTL_DEV, O_RDONLY)) < 0) 1396 goto out; 1397 1398 if ((sv4 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { 1399 perror("datadm: socket"); 1400 goto out; 1401 } 1402 1403 if ((sv6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) { 1404 perror("datadm: socket"); 1405 goto out; 1406 } 1407 1408 ia_args.ia_hca_list = hca_list; 1409 ia_args.ia_dlh = dlh; 1410 ia_args.ia_ibnex_fd = fd; 1411 ia_args.ia_sock_fd_v4 = sv4; 1412 ia_args.ia_sock_fd_v6 = sv6; 1413 1414 dlpi_walk((boolean_t (*) (const char *, void *))datadm_add_plink, 1415 &ia_args, 0); 1416 rv = 0; 1417 1418 out: 1419 if (sv4 != -1) 1420 (void) close(sv4); 1421 if (sv6 != -1) 1422 (void) close(sv6); 1423 if (fd != -1) 1424 (void) close(fd); 1425 1426 dladm_close(dlh); 1427 return (rv); 1428 } 1429 1430 static int 1431 datadm_generate_conf_entry(FILE *outfile, datadm_ia_entry_t *ia_entry, 1432 datadm_sp_entry_t *sp_entry) 1433 { 1434 int retval; 1435 1436 retval = fprintf(outfile, 1437 "%s %s%d.%d %s %s %s %s%d.%d \"%s\" \"%s%s%s\"\n", 1438 ia_entry->iae_name, 1439 (sp_entry->spe_api_version.dv_name ? 1440 sp_entry->spe_api_version.dv_name : ""), 1441 sp_entry->spe_api_version.dv_major, 1442 sp_entry->spe_api_version.dv_minor, 1443 (sp_entry->spe_threadsafe ? "threadsafe" : "nonthreadsafe"), 1444 (sp_entry->spe_default ? "default" : "nondefault"), 1445 sp_entry->spe_libpath, 1446 (sp_entry->spe_sp_version.dv_name ? 1447 sp_entry->spe_sp_version.dv_name : ""), 1448 sp_entry->spe_sp_version.dv_major, 1449 sp_entry->spe_sp_version.dv_minor, 1450 sp_entry->spe_sp_data, 1451 DATADM_DRV_NAME, "=", sp_entry->spe_devname); 1452 1453 if (retval < 0) { 1454 return (-1); 1455 } 1456 return (0); 1457 } 1458 1459 /* 1460 * generate dat.conf header 1461 */ 1462 static int 1463 datadm_generate_conf_header(FILE *outfile) 1464 { 1465 datadm_entry_t *cep; 1466 datadm_cmnt_entry_t *cmnt; 1467 int retval = 0; 1468 1469 cep = datadm_conf_header.dl_head; 1470 if (cep == NULL) { 1471 /* 1472 * if dat.conf doesn't have a header, we prepend a 1473 * default one. 1474 */ 1475 retval = fprintf(outfile, "%s", datadm_conf_header_default); 1476 goto done; 1477 } 1478 while (cep != NULL) { 1479 cmnt = (datadm_cmnt_entry_t *)cep; 1480 if (cmnt->cmnt_line != NULL) { 1481 int len; 1482 1483 retval = fprintf(outfile, "%s", cmnt->cmnt_line); 1484 if (retval < 0) { 1485 break; 1486 } 1487 1488 /* 1489 * append a newline if the comment line doesn't 1490 * have one. 1491 */ 1492 len = strlen(cmnt->cmnt_line); 1493 if (cmnt->cmnt_line[len - 1] != '\n') { 1494 retval = fprintf(outfile, "\n"); 1495 if (retval < 0) { 1496 break; 1497 } 1498 } 1499 } 1500 cep = cep->de_next; 1501 } 1502 done:; 1503 if (retval < 0) { 1504 return (-1); 1505 } 1506 return (0); 1507 } 1508 1509 /* 1510 * outputs dat.conf to stdout or to basedir/etc/dat/dat.conf 1511 */ 1512 static int 1513 datadm_generate_dat_conf(datadm_list_t *hca_list) 1514 { 1515 FILE *outfile = NULL; 1516 char *dat_conf = datadm_args.da_dat_conf; 1517 datadm_entry_t *hep; 1518 int retval = 0; 1519 1520 if (datadm_args.da_op_type == DATADM_OP_VIEW) { 1521 outfile = stdout; 1522 } else { 1523 outfile = fopen(dat_conf, "w+"); 1524 if (outfile == NULL) { 1525 (void) fprintf(stderr, gettext( 1526 "datadm: cannot open %s: %s\n"), 1527 dat_conf, strerror(errno)); 1528 return (-1); 1529 } 1530 } 1531 if (outfile != stdout) { 1532 /* 1533 * do not generate the header if we are 1534 * printing to the screen 1535 */ 1536 retval = datadm_generate_conf_header(outfile); 1537 if (retval != 0) { 1538 goto done; 1539 } 1540 } 1541 hep = hca_list->dl_head; 1542 while (hep != NULL) { 1543 datadm_entry_t *iep; 1544 1545 iep = ((datadm_hca_entry_t *)hep)->he_ia_list.dl_head; 1546 while (iep != NULL) { 1547 datadm_entry_t *sep; 1548 1549 sep = ((datadm_hca_entry_t *)hep)->he_sp_list.dl_head; 1550 while (sep != NULL) { 1551 if (((datadm_sp_entry_t *)sep)->spe_invalid) { 1552 sep = sep->de_next; 1553 continue; 1554 } 1555 retval = datadm_generate_conf_entry(outfile, 1556 (datadm_ia_entry_t *)iep, 1557 (datadm_sp_entry_t *)sep); 1558 if (retval != 0) { 1559 goto done; 1560 } 1561 sep = sep->de_next; 1562 } 1563 iep = iep->de_next; 1564 } 1565 hep = hep->de_next; 1566 } 1567 retval = fflush(outfile); 1568 done:; 1569 if (outfile != stdout) { 1570 (void) fclose(outfile); 1571 } 1572 if (retval < 0) { 1573 perror("datadm: fprintf"); 1574 } 1575 return (retval); 1576 } 1577 1578 static int 1579 datadm_view(void) 1580 { 1581 int retval = 0; 1582 datadm_list_t hca_list; 1583 1584 bzero(&hca_list, sizeof (hca_list)); 1585 1586 retval = datadm_parse_dat_conf(&hca_list); 1587 if (retval != 0) { 1588 goto cleanup; 1589 } 1590 retval = datadm_generate_dat_conf(&hca_list); 1591 if (retval != 0) { 1592 goto cleanup; 1593 } 1594 1595 cleanup:; 1596 datadm_free_list(&datadm_conf_header, 1597 (void (*)(datadm_entry_t *))datadm_free_cmnt_entry); 1598 datadm_free_list(&hca_list, 1599 (void (*)(datadm_entry_t *))datadm_free_hca_entry); 1600 return (retval); 1601 } 1602 1603 static int 1604 datadm_update(void) 1605 { 1606 int retval = 0; 1607 datadm_list_t hca_list; 1608 1609 bzero(&hca_list, sizeof (hca_list)); 1610 1611 retval = datadm_parse_dat_conf(&hca_list); 1612 if (retval != 0) { 1613 goto cleanup; 1614 } 1615 retval = datadm_build_ia_lists(&hca_list); 1616 if (retval != 0) { 1617 goto cleanup; 1618 } 1619 retval = datadm_generate_dat_conf(&hca_list); 1620 if (retval != 0) { 1621 goto cleanup; 1622 } 1623 1624 cleanup:; 1625 datadm_free_list(&datadm_conf_header, 1626 (void (*)(datadm_entry_t *))datadm_free_cmnt_entry); 1627 datadm_free_list(&hca_list, 1628 (void (*)(datadm_entry_t *))datadm_free_hca_entry); 1629 return (retval); 1630 } 1631 1632 static int 1633 datadm_add(void) 1634 { 1635 int retval = 0; 1636 datadm_list_t hca_list; 1637 1638 bzero(&hca_list, sizeof (hca_list)); 1639 1640 retval = datadm_parse_dat_conf(&hca_list); 1641 if (retval != 0) { 1642 goto cleanup; 1643 } 1644 retval = datadm_parse_sp_conf(&hca_list); 1645 if (retval != 0) { 1646 goto cleanup; 1647 } 1648 retval = datadm_build_ia_lists(&hca_list); 1649 if (retval != 0) { 1650 goto cleanup; 1651 } 1652 retval = datadm_generate_dat_conf(&hca_list); 1653 if (retval != 0) { 1654 goto cleanup; 1655 } 1656 1657 cleanup:; 1658 datadm_free_list(&datadm_conf_header, 1659 (void (*)(datadm_entry_t *))datadm_free_cmnt_entry); 1660 datadm_free_list(&hca_list, 1661 (void (*)(datadm_entry_t *))datadm_free_hca_entry); 1662 return (retval); 1663 } 1664 1665 static int 1666 datadm_remove(void) 1667 { 1668 int retval = 0; 1669 datadm_list_t hca_list; 1670 datadm_list_t hca_list2; 1671 1672 bzero(&hca_list, sizeof (hca_list)); 1673 bzero(&hca_list2, sizeof (hca_list2)); 1674 1675 retval = datadm_parse_dat_conf(&hca_list); 1676 if (retval != 0) { 1677 goto cleanup; 1678 } 1679 retval = datadm_parse_sp_conf(&hca_list2); 1680 if (retval != 0) { 1681 goto cleanup; 1682 } 1683 datadm_invalidate_common_sp_entries(&hca_list, &hca_list2); 1684 1685 retval = datadm_generate_dat_conf(&hca_list); 1686 if (retval != 0) { 1687 goto cleanup; 1688 } 1689 1690 cleanup:; 1691 datadm_free_list(&datadm_conf_header, 1692 (void (*)(datadm_entry_t *))datadm_free_cmnt_entry); 1693 datadm_free_list(&hca_list, 1694 (void (*)(datadm_entry_t *))datadm_free_hca_entry); 1695 datadm_free_list(&hca_list2, 1696 (void (*)(datadm_entry_t *))datadm_free_hca_entry); 1697 return (retval); 1698 } 1699 1700 static int 1701 datadm_locate_dat_conf(char *basedir) 1702 { 1703 char *dat_conf; 1704 1705 if (basedir == NULL) { 1706 datadm_args.da_dat_conf = DATADM_DAT_CONF; 1707 return (0); 1708 } 1709 dat_conf = (char *)malloc(strlen(basedir) + 1710 strlen(DATADM_DAT_CONF) + 1); 1711 if (dat_conf == NULL) { 1712 return (-1); 1713 } 1714 dat_conf[0] = '\0'; 1715 (void) strcat(dat_conf, basedir); 1716 (void) strcat(dat_conf, DATADM_DAT_CONF); 1717 datadm_args.da_dat_conf = dat_conf; 1718 return (0); 1719 } 1720 1721 int 1722 main(int argc, char **argv) 1723 { 1724 extern char *optarg; 1725 extern int optind; 1726 char *basedir = NULL; 1727 int c, retval; 1728 int op_type = -1, errflg = 0; 1729 1730 bzero(&datadm_args, sizeof (datadm_args)); 1731 bzero(&datadm_conf_header, sizeof (datadm_conf_header)); 1732 1733 (void) setlocale(LC_ALL, ""); 1734 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 1735 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 1736 #endif 1737 (void) textdomain(TEXT_DOMAIN); 1738 1739 while ((c = getopt(argc, argv, "vua:r:b:")) != EOF) { 1740 switch (c) { 1741 case 'v': 1742 if (op_type != -1) errflg = 1; 1743 op_type = DATADM_OP_VIEW; 1744 break; 1745 case 'u': 1746 if (op_type != -1) errflg = 1; 1747 op_type = DATADM_OP_UPDATE; 1748 break; 1749 case 'a': 1750 if (op_type != -1) errflg = 1; 1751 op_type = DATADM_OP_ADD; 1752 datadm_args.da_sp_conf = optarg; 1753 break; 1754 case 'r': 1755 if (op_type != -1) errflg = 1; 1756 op_type = DATADM_OP_REMOVE; 1757 datadm_args.da_sp_conf = optarg; 1758 break; 1759 case 'b': 1760 basedir = optarg; 1761 break; 1762 default: 1763 errflg = 1; 1764 break; 1765 } 1766 if (errflg != 0) { 1767 break; 1768 } 1769 } 1770 if (errflg != 0 || op_type == -1 || optind < argc) { 1771 datadm_usage(); 1772 return (1); 1773 } 1774 datadm_args.da_op_type = op_type; 1775 if (datadm_locate_dat_conf(basedir)) { 1776 return (1); 1777 } 1778 1779 retval = (*datadm_ops[op_type])(); 1780 return (retval); 1781 } 1782