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) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 /* 26 * Copyright 2019 OmniOS Community Edition (OmniOSce) Association. 27 */ 28 29 #include <unistd.h> 30 #include <errno.h> 31 #include <ctype.h> 32 #include <fcntl.h> 33 #include <strings.h> 34 #include <dirent.h> 35 #include <stdlib.h> 36 #include <netinet/in.h> 37 #include <arpa/inet.h> 38 #include <sys/param.h> 39 #include <sys/stat.h> 40 #include <sys/dld.h> 41 #include <sys/dld_ioc.h> 42 #include <libdladm_impl.h> 43 #include <libintl.h> 44 #include <libdlpi.h> 45 #include <libdllink.h> 46 47 static char dladm_rootdir[MAXPATHLEN] = "/"; 48 49 typedef struct media_type_desc { 50 uint32_t media_type; 51 #define MAX_MEDIA_TYPE_STRING 32 52 const char media_type_str[MAX_MEDIA_TYPE_STRING]; 53 } media_type_t; 54 55 static media_type_t media_type_table[] = { 56 { DL_ETHER, "Ethernet" }, 57 { DL_WIFI, "WiFi" }, 58 { DL_IB, "Infiniband" }, 59 { DL_IPV4, "IPv4Tunnel" }, 60 { DL_IPV6, "IPv6Tunnel" }, 61 { DL_6TO4, "6to4Tunnel" }, 62 { DL_CSMACD, "CSMA/CD" }, 63 { DL_TPB, "TokenBus" }, 64 { DL_TPR, "TokenRing" }, 65 { DL_METRO, "MetroNet" }, 66 { DL_HDLC, "HDLC" }, 67 { DL_CHAR, "SyncCharacter" }, 68 { DL_CTCA, "CTCA" }, 69 { DL_FDDI, "FDDI" }, 70 { DL_FC, "FiberChannel" }, 71 { DL_ATM, "ATM" }, 72 { DL_IPATM, "ATM(ClassicIP)" }, 73 { DL_X25, "X.25" }, 74 { DL_IPX25, "X.25(ClassicIP)" }, 75 { DL_ISDN, "ISDN" }, 76 { DL_HIPPI, "HIPPI" }, 77 { DL_100VG, "100BaseVGEthernet" }, 78 { DL_100VGTPR, "100BaseVGTokenRing" }, 79 { DL_ETH_CSMA, "IEEE802.3" }, 80 { DL_100BT, "100BaseT" }, 81 { DL_FRAME, "FrameRelay" }, 82 { DL_MPFRAME, "MPFrameRelay" }, 83 { DL_ASYNC, "AsyncCharacter" }, 84 { DL_IPNET, "IPNET" }, 85 { DL_OTHER, "Other" } 86 }; 87 #define MEDIATYPECOUNT (sizeof (media_type_table) / sizeof (media_type_t)) 88 89 typedef struct { 90 uint32_t lp_type; 91 char *lp_name; 92 } link_protect_t; 93 94 static link_protect_t link_protect_types[] = { 95 { MPT_MACNOSPOOF, "mac-nospoof" }, 96 { MPT_RESTRICTED, "restricted" }, 97 { MPT_IPNOSPOOF, "ip-nospoof" }, 98 { MPT_DHCPNOSPOOF, "dhcp-nospoof" } 99 }; 100 #define LPTYPES (sizeof (link_protect_types) / sizeof (link_protect_t)) 101 102 dladm_status_t 103 dladm_open(dladm_handle_t *handle) 104 { 105 int dld_fd; 106 107 if (handle == NULL) 108 return (DLADM_STATUS_BADARG); 109 110 if ((dld_fd = open(DLD_CONTROL_DEV, O_RDWR)) < 0) 111 return (dladm_errno2status(errno)); 112 113 /* 114 * Don't open DLMGMT_DOOR now. dlmgmtd(1M) is not able to 115 * open the door when the dladm handle is opened because the 116 * door hasn't been created yet at that time. Thus, we must 117 * open it on-demand in dladm_door_fd(). Move the open() 118 * to dladm_door_fd() for all cases. 119 */ 120 121 if ((*handle = malloc(sizeof (struct dladm_handle))) == NULL) { 122 (void) close(dld_fd); 123 return (DLADM_STATUS_NOMEM); 124 } 125 126 (*handle)->dld_fd = dld_fd; 127 (*handle)->door_fd = -1; 128 (*handle)->dld_kcp = NULL; 129 130 return (DLADM_STATUS_OK); 131 } 132 133 void 134 dladm_close(dladm_handle_t handle) 135 { 136 if (handle != NULL) { 137 (void) close(handle->dld_fd); 138 if (handle->door_fd != -1) 139 (void) close(handle->door_fd); 140 if (handle->dld_kcp != NULL) 141 (void) kstat_close(handle->dld_kcp); 142 free(handle); 143 } 144 } 145 146 int 147 dladm_dld_fd(dladm_handle_t handle) 148 { 149 return (handle->dld_fd); 150 } 151 152 kstat_ctl_t * 153 dladm_dld_kcp(dladm_handle_t handle) 154 { 155 if (handle->dld_kcp == NULL) 156 handle->dld_kcp = kstat_open(); 157 return (handle->dld_kcp); 158 } 159 160 /* 161 * If DLMGMT_DOOR hasn't been opened in the handle yet, open it. 162 */ 163 dladm_status_t 164 dladm_door_fd(dladm_handle_t handle, int *door_fd) 165 { 166 int fd; 167 168 if (handle->door_fd == -1) { 169 if ((fd = open(DLMGMT_DOOR, O_RDONLY)) < 0) 170 return (dladm_errno2status(errno)); 171 handle->door_fd = fd; 172 } 173 *door_fd = handle->door_fd; 174 175 return (DLADM_STATUS_OK); 176 } 177 178 const char * 179 dladm_status2str(dladm_status_t status, char *buf) 180 { 181 const char *s; 182 183 switch (status) { 184 case DLADM_STATUS_OK: 185 s = "ok"; 186 break; 187 case DLADM_STATUS_BADARG: 188 s = "invalid argument"; 189 break; 190 case DLADM_STATUS_FAILED: 191 s = "operation failed"; 192 break; 193 case DLADM_STATUS_TOOSMALL: 194 s = "buffer size too small"; 195 break; 196 case DLADM_STATUS_NOTSUP: 197 s = "operation not supported"; 198 break; 199 case DLADM_STATUS_NOTFOUND: 200 s = "object not found"; 201 break; 202 case DLADM_STATUS_BADVAL: 203 s = "invalid value"; 204 break; 205 case DLADM_STATUS_NOMEM: 206 s = "insufficient memory"; 207 break; 208 case DLADM_STATUS_EXIST: 209 s = "object already exists"; 210 break; 211 case DLADM_STATUS_LINKINVAL: 212 s = "invalid link"; 213 break; 214 case DLADM_STATUS_PROPRDONLY: 215 s = "read-only property"; 216 break; 217 case DLADM_STATUS_BADVALCNT: 218 s = "invalid number of values"; 219 break; 220 case DLADM_STATUS_DBNOTFOUND: 221 s = "database not found"; 222 break; 223 case DLADM_STATUS_DENIED: 224 s = "permission denied"; 225 break; 226 case DLADM_STATUS_IOERR: 227 s = "I/O error"; 228 break; 229 case DLADM_STATUS_TEMPONLY: 230 s = "change cannot be persistent"; 231 break; 232 case DLADM_STATUS_TIMEDOUT: 233 s = "operation timed out"; 234 break; 235 case DLADM_STATUS_ISCONN: 236 s = "already connected"; 237 break; 238 case DLADM_STATUS_NOTCONN: 239 s = "not connected"; 240 break; 241 case DLADM_STATUS_REPOSITORYINVAL: 242 s = "invalid configuration repository"; 243 break; 244 case DLADM_STATUS_MACADDRINVAL: 245 s = "invalid MAC address"; 246 break; 247 case DLADM_STATUS_KEYINVAL: 248 s = "invalid key"; 249 break; 250 case DLADM_STATUS_INVALIDMACADDRLEN: 251 s = "invalid MAC address length"; 252 break; 253 case DLADM_STATUS_INVALIDMACADDRTYPE: 254 s = "invalid MAC address type"; 255 break; 256 case DLADM_STATUS_LINKBUSY: 257 s = "link busy"; 258 break; 259 case DLADM_STATUS_VIDINVAL: 260 s = "invalid VLAN identifier"; 261 break; 262 case DLADM_STATUS_TRYAGAIN: 263 s = "try again later"; 264 break; 265 case DLADM_STATUS_NONOTIF: 266 s = "link notification is not supported"; 267 break; 268 case DLADM_STATUS_BADTIMEVAL: 269 s = "invalid time range"; 270 break; 271 case DLADM_STATUS_INVALIDMACADDR: 272 s = "invalid MAC address value"; 273 break; 274 case DLADM_STATUS_INVALIDMACADDRNIC: 275 s = "MAC address reserved for use by underlying data-link"; 276 break; 277 case DLADM_STATUS_INVALIDMACADDRINUSE: 278 s = "MAC address is already in use"; 279 break; 280 case DLADM_STATUS_MACFACTORYSLOTINVALID: 281 s = "invalid factory MAC address slot"; 282 break; 283 case DLADM_STATUS_MACFACTORYSLOTUSED: 284 s = "factory MAC address slot already used"; 285 break; 286 case DLADM_STATUS_MACFACTORYSLOTALLUSED: 287 s = "all factory MAC address slots are in use"; 288 break; 289 case DLADM_STATUS_MACFACTORYNOTSUP: 290 s = "factory MAC address slots not supported"; 291 break; 292 case DLADM_STATUS_INVALIDMACPREFIX: 293 s = "Invalid MAC address prefix value"; 294 break; 295 case DLADM_STATUS_INVALIDMACPREFIXLEN: 296 s = "Invalid MAC address prefix length"; 297 break; 298 case DLADM_STATUS_BADCPUID: 299 s = "non-existent processor ID"; 300 break; 301 case DLADM_STATUS_CPUERR: 302 s = "could not determine processor status"; 303 break; 304 case DLADM_STATUS_CPUNOTONLINE: 305 s = "processor not online"; 306 break; 307 case DLADM_STATUS_TOOMANYELEMENTS: 308 s = "too many elements specified"; 309 break; 310 case DLADM_STATUS_BADRANGE: 311 s = "invalid range"; 312 break; 313 case DLADM_STATUS_DB_NOTFOUND: 314 s = "database not found"; 315 break; 316 case DLADM_STATUS_DB_PARSE_ERR: 317 s = "database parse error"; 318 break; 319 case DLADM_STATUS_PROP_PARSE_ERR: 320 s = "property parse error"; 321 break; 322 case DLADM_STATUS_ATTR_PARSE_ERR: 323 s = "attribute parse error"; 324 break; 325 case DLADM_STATUS_FLOW_DB_ERR: 326 s = "flow database error"; 327 break; 328 case DLADM_STATUS_FLOW_DB_OPEN_ERR: 329 s = "flow database open error"; 330 break; 331 case DLADM_STATUS_FLOW_DB_PARSE_ERR: 332 s = "flow database parse error"; 333 break; 334 case DLADM_STATUS_FLOWPROP_DB_PARSE_ERR: 335 s = "flow property database parse error"; 336 break; 337 case DLADM_STATUS_FLOW_ADD_ERR: 338 s = "flow add error"; 339 break; 340 case DLADM_STATUS_FLOW_WALK_ERR: 341 s = "flow walk error"; 342 break; 343 case DLADM_STATUS_FLOW_IDENTICAL: 344 s = "a flow with identical attributes exists"; 345 break; 346 case DLADM_STATUS_FLOW_INCOMPATIBLE: 347 s = "flow(s) with incompatible attributes exists"; 348 break; 349 case DLADM_STATUS_FLOW_EXISTS: 350 s = "link still has flows"; 351 break; 352 case DLADM_STATUS_PERSIST_FLOW_EXISTS: 353 s = "persistent flow with the same name exists"; 354 break; 355 case DLADM_STATUS_INVALID_IP: 356 s = "invalid IP address"; 357 break; 358 case DLADM_STATUS_INVALID_PREFIXLEN: 359 s = "invalid IP prefix length"; 360 break; 361 case DLADM_STATUS_INVALID_PROTOCOL: 362 s = "invalid IP protocol"; 363 break; 364 case DLADM_STATUS_INVALID_PORT: 365 s = "invalid port number"; 366 break; 367 case DLADM_STATUS_INVALID_DSF: 368 s = "invalid dsfield"; 369 break; 370 case DLADM_STATUS_INVALID_DSFMASK: 371 s = "invalid dsfield mask"; 372 break; 373 case DLADM_STATUS_INVALID_MACMARGIN: 374 s = "MTU check failed, use lower MTU or -f option"; 375 break; 376 case DLADM_STATUS_BADPROP: 377 s = "invalid property"; 378 break; 379 case DLADM_STATUS_MINMAXBW: 380 s = "minimum value for maxbw is 1200K"; 381 break; 382 case DLADM_STATUS_NO_HWRINGS: 383 s = "request hw rings failed"; 384 break; 385 case DLADM_STATUS_PERMONLY: 386 s = "change must be persistent"; 387 break; 388 case DLADM_STATUS_OPTMISSING: 389 s = "optional software not installed"; 390 break; 391 case DLADM_STATUS_IPTUNTYPE: 392 s = "invalid IP tunnel type"; 393 break; 394 case DLADM_STATUS_IPTUNTYPEREQD: 395 s = "IP tunnel type required"; 396 break; 397 case DLADM_STATUS_BADIPTUNLADDR: 398 s = "invalid local IP tunnel address"; 399 break; 400 case DLADM_STATUS_BADIPTUNRADDR: 401 s = "invalid remote IP tunnel address"; 402 break; 403 case DLADM_STATUS_ADDRINUSE: 404 s = "address already in use"; 405 break; 406 case DLADM_STATUS_POOLCPU: 407 s = "pool and cpus property are mutually exclusive"; 408 break; 409 case DLADM_STATUS_INVALID_PORT_INSTANCE: 410 s = "invalid IB phys link"; 411 break; 412 case DLADM_STATUS_PORT_IS_DOWN: 413 s = "port is down"; 414 break; 415 case DLADM_STATUS_PARTITION_EXISTS: 416 s = "partition already exists"; 417 break; 418 case DLADM_STATUS_PKEY_NOT_PRESENT: 419 s = "PKEY is not present on the port"; 420 break; 421 case DLADM_STATUS_INVALID_PKEY: 422 s = "invalid PKEY"; 423 break; 424 case DLADM_STATUS_NO_IB_HW_RESOURCE: 425 s = "IB internal resource not available"; 426 break; 427 case DLADM_STATUS_INVALID_PKEY_TBL_SIZE: 428 s = "invalid PKEY table size"; 429 break; 430 case DLADM_STATUS_PORT_NOPROTO: 431 s = "local or remote port requires transport"; 432 break; 433 case DLADM_STATUS_INVALID_MTU: 434 s = "MTU check failed, MTU outside of device's supported range"; 435 break; 436 default: 437 s = "<unknown error>"; 438 break; 439 } 440 (void) snprintf(buf, DLADM_STRSIZE, "%s", dgettext(TEXT_DOMAIN, s)); 441 return (buf); 442 } 443 444 /* 445 * Convert a unix errno to a dladm_status_t. 446 * We only convert errnos that are likely to be encountered. All others 447 * are mapped to DLADM_STATUS_FAILED. 448 */ 449 dladm_status_t 450 dladm_errno2status(int err) 451 { 452 switch (err) { 453 case 0: 454 return (DLADM_STATUS_OK); 455 case EINVAL: 456 return (DLADM_STATUS_BADARG); 457 case EEXIST: 458 return (DLADM_STATUS_EXIST); 459 case ENOENT: 460 return (DLADM_STATUS_NOTFOUND); 461 case ENOSPC: 462 return (DLADM_STATUS_TOOSMALL); 463 case ENOMEM: 464 return (DLADM_STATUS_NOMEM); 465 case ENOTSUP: 466 return (DLADM_STATUS_NOTSUP); 467 case ENETDOWN: 468 return (DLADM_STATUS_NONOTIF); 469 case EACCES: 470 case EPERM: 471 return (DLADM_STATUS_DENIED); 472 case EIO: 473 return (DLADM_STATUS_IOERR); 474 case EBUSY: 475 return (DLADM_STATUS_LINKBUSY); 476 case EAGAIN: 477 return (DLADM_STATUS_TRYAGAIN); 478 case ENOTEMPTY: 479 return (DLADM_STATUS_FLOW_EXISTS); 480 case EOPNOTSUPP: 481 return (DLADM_STATUS_FLOW_INCOMPATIBLE); 482 case EALREADY: 483 return (DLADM_STATUS_FLOW_IDENTICAL); 484 case EADDRINUSE: 485 return (DLADM_STATUS_ADDRINUSE); 486 default: 487 return (DLADM_STATUS_FAILED); 488 } 489 } 490 491 boolean_t 492 dladm_str2interval(char *oarg, uint32_t *interval) 493 { 494 int val; 495 char *endp = NULL; 496 497 errno = 0; 498 val = strtol(oarg, &endp, 10); 499 if (errno != 0 || val <= 0 || *endp != '\0') 500 return (B_FALSE); 501 502 *interval = val; 503 504 return (B_TRUE); 505 } 506 507 dladm_status_t 508 dladm_str2bw(char *oarg, uint64_t *bw) 509 { 510 char *endp = NULL; 511 int64_t n; 512 int mult = 1; 513 514 n = strtoull(oarg, &endp, 10); 515 516 if ((errno != 0) || (strlen(endp) > 1)) 517 return (DLADM_STATUS_BADARG); 518 519 if (n < 0) 520 return (DLADM_STATUS_BADVAL); 521 522 switch (*endp) { 523 case 'k': 524 case 'K': 525 mult = 1000; 526 break; 527 case 'm': 528 case 'M': 529 case '\0': 530 mult = 1000000; 531 break; 532 case 'g': 533 case 'G': 534 mult = 1000000000; 535 break; 536 case '%': 537 /* 538 * percentages not supported for now, 539 * see RFE 6540675 540 */ 541 return (DLADM_STATUS_NOTSUP); 542 default: 543 return (DLADM_STATUS_BADVAL); 544 } 545 546 *bw = n * mult; 547 548 /* check for overflow */ 549 if (*bw / mult != n) 550 return (DLADM_STATUS_BADARG); 551 552 return (DLADM_STATUS_OK); 553 } 554 555 /* 556 * Convert bandwidth in bps to a string in Mbps. For values greater 557 * than 1Mbps or 1000000, print a whole Mbps value. For values that 558 * have fractional Mbps in whole Kbps, print the bandwidth in a manner 559 * similar to a floating point format. 560 * 561 * bps string 562 * 0 0 563 * 100 0 564 * 2000 0.002 565 * 431000 0.431 566 * 1000000 1 567 * 1030000 1.030 568 * 100000000 100 569 */ 570 const char * 571 dladm_bw2str(int64_t bw, char *buf) 572 { 573 int kbps, mbps; 574 575 kbps = (bw%1000000)/1000; 576 mbps = bw/1000000; 577 if (kbps != 0) { 578 if (mbps == 0) 579 (void) snprintf(buf, DLADM_STRSIZE, "0.%03u", kbps); 580 else 581 (void) snprintf(buf, DLADM_STRSIZE, "%5u.%03u", mbps, 582 kbps); 583 } else { 584 (void) snprintf(buf, DLADM_STRSIZE, "%5u", mbps); 585 } 586 587 return (buf); 588 } 589 590 #define LOCK_DB_PERMS S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH 591 592 static int 593 i_dladm_lock_db(const char *lock_file, short type) 594 { 595 int lock_fd; 596 struct flock lock; 597 598 if ((lock_fd = open(lock_file, O_RDWR | O_CREAT | O_TRUNC, 599 LOCK_DB_PERMS)) < 0) 600 return (-1); 601 602 lock.l_type = type; 603 lock.l_whence = SEEK_SET; 604 lock.l_start = 0; 605 lock.l_len = 0; 606 607 if (fcntl(lock_fd, F_SETLKW, &lock) < 0) { 608 int err = errno; 609 610 (void) close(lock_fd); 611 (void) unlink(lock_file); 612 errno = err; 613 return (-1); 614 } 615 return (lock_fd); 616 } 617 618 static void 619 i_dladm_unlock_db(const char *lock_file, int fd) 620 { 621 struct flock lock; 622 623 if (fd < 0) 624 return; 625 626 lock.l_type = F_UNLCK; 627 lock.l_whence = SEEK_SET; 628 lock.l_start = 0; 629 lock.l_len = 0; 630 631 (void) fcntl(fd, F_SETLKW, &lock); 632 (void) close(fd); 633 (void) unlink(lock_file); 634 } 635 636 /* 637 * Given a link class, returns its class string. 638 */ 639 const char * 640 dladm_class2str(datalink_class_t class, char *buf) 641 { 642 const char *s; 643 644 switch (class) { 645 case DATALINK_CLASS_PHYS: 646 s = "phys"; 647 break; 648 case DATALINK_CLASS_VLAN: 649 s = "vlan"; 650 break; 651 case DATALINK_CLASS_AGGR: 652 s = "aggr"; 653 break; 654 case DATALINK_CLASS_VNIC: 655 s = "vnic"; 656 break; 657 case DATALINK_CLASS_ETHERSTUB: 658 s = "etherstub"; 659 break; 660 case DATALINK_CLASS_IPTUN: 661 s = "iptun"; 662 break; 663 case DATALINK_CLASS_SIMNET: 664 s = "simnet"; 665 break; 666 case DATALINK_CLASS_BRIDGE: 667 s = "bridge"; 668 break; 669 case DATALINK_CLASS_PART: 670 s = "part"; 671 break; 672 default: 673 s = "unknown"; 674 break; 675 } 676 677 (void) snprintf(buf, DLADM_STRSIZE, "%s", s); 678 return (buf); 679 } 680 681 /* 682 * Given a physical link media type, returns its media type string. 683 */ 684 const char * 685 dladm_media2str(uint32_t media, char *buf) 686 { 687 const char *s = "--"; 688 media_type_t *mt; 689 int idx; 690 691 for (idx = 0; idx < MEDIATYPECOUNT; idx++) { 692 mt = media_type_table + idx; 693 if (mt->media_type == media) { 694 s = mt->media_type_str; 695 break; 696 } 697 } 698 699 (void) snprintf(buf, DLADM_STRSIZE, "%s", s); 700 return (buf); 701 } 702 703 /* 704 * Given a physical link media type string, returns its media type constant. 705 */ 706 uint32_t 707 dladm_str2media(const char *buf) 708 { 709 media_type_t *mt; 710 int idx; 711 712 for (idx = 0; idx < MEDIATYPECOUNT; idx++) { 713 mt = media_type_table + idx; 714 if (strcasecmp(buf, mt->media_type_str) == 0) 715 return (mt->media_type); 716 } 717 718 return (DL_OTHER); 719 } 720 721 dladm_status_t 722 i_dladm_rw_db(dladm_handle_t handle, const char *db_file, mode_t db_perms, 723 dladm_status_t (*process_db)(dladm_handle_t, void *, FILE *, FILE *), 724 void *arg, boolean_t writeop) 725 { 726 dladm_status_t status = DLADM_STATUS_OK; 727 FILE *fp, *nfp = NULL; 728 char lock[MAXPATHLEN]; 729 char file[MAXPATHLEN]; 730 char newfile[MAXPATHLEN]; 731 char *db_basename; 732 int nfd, lock_fd; 733 734 /* 735 * If we are called from a boot script such as net-physical, 736 * it's quite likely that the root fs is still not writable. 737 * For this case, it's ok for the lock creation to fail since 738 * no one else could be accessing our configuration file. 739 */ 740 db_basename = strrchr(db_file, '/'); 741 if (db_basename == NULL || db_basename[1] == '\0') 742 return (dladm_errno2status(EINVAL)); 743 db_basename++; 744 (void) snprintf(lock, MAXPATHLEN, "/tmp/%s.lock", db_basename); 745 if ((lock_fd = i_dladm_lock_db 746 (lock, (writeop ? F_WRLCK : F_RDLCK))) < 0 && errno != EROFS) 747 return (dladm_errno2status(errno)); 748 749 (void) snprintf(file, MAXPATHLEN, "%s/%s", dladm_rootdir, db_file); 750 if ((fp = fopen(file, (writeop ? "r+" : "r"))) == NULL) { 751 int err = errno; 752 753 i_dladm_unlock_db(lock, lock_fd); 754 if (err == ENOENT) 755 return (DLADM_STATUS_DBNOTFOUND); 756 757 return (dladm_errno2status(err)); 758 } 759 760 if (writeop) { 761 (void) snprintf(newfile, MAXPATHLEN, "%s/%s.new", 762 dladm_rootdir, db_file); 763 if ((nfd = open(newfile, O_WRONLY | O_CREAT | O_TRUNC, 764 db_perms)) < 0) { 765 (void) fclose(fp); 766 i_dladm_unlock_db(lock, lock_fd); 767 return (dladm_errno2status(errno)); 768 } 769 770 if ((nfp = fdopen(nfd, "w")) == NULL) { 771 (void) close(nfd); 772 (void) fclose(fp); 773 (void) unlink(newfile); 774 i_dladm_unlock_db(lock, lock_fd); 775 return (dladm_errno2status(errno)); 776 } 777 } 778 status = (*process_db)(handle, arg, fp, nfp); 779 if (!writeop || status != DLADM_STATUS_OK) 780 goto done; 781 782 /* Set permissions on file to db_perms */ 783 if (fchmod(nfd, db_perms) < 0) { 784 status = dladm_errno2status(errno); 785 goto done; 786 } 787 788 /* 789 * Configuration files need to be owned by the 'dladm' user and 790 * 'netadm' group. 791 */ 792 if (fchown(nfd, UID_DLADM, GID_NETADM) < 0) { 793 status = dladm_errno2status(errno); 794 goto done; 795 } 796 797 if (fflush(nfp) == EOF) { 798 status = dladm_errno2status(errno); 799 goto done; 800 } 801 (void) fclose(fp); 802 (void) fclose(nfp); 803 804 if (rename(newfile, file) < 0) { 805 (void) unlink(newfile); 806 i_dladm_unlock_db(lock, lock_fd); 807 return (dladm_errno2status(errno)); 808 } 809 810 i_dladm_unlock_db(lock, lock_fd); 811 return (DLADM_STATUS_OK); 812 813 done: 814 if (nfp != NULL) { 815 (void) fclose(nfp); 816 if (status != DLADM_STATUS_OK) 817 (void) unlink(newfile); 818 } 819 (void) fclose(fp); 820 i_dladm_unlock_db(lock, lock_fd); 821 return (status); 822 } 823 824 dladm_status_t 825 dladm_set_rootdir(const char *rootdir) 826 { 827 DIR *dp; 828 829 if (rootdir == NULL || *rootdir != '/' || 830 (dp = opendir(rootdir)) == NULL) 831 return (DLADM_STATUS_BADARG); 832 833 (void) strncpy(dladm_rootdir, rootdir, MAXPATHLEN); 834 (void) closedir(dp); 835 return (DLADM_STATUS_OK); 836 } 837 838 boolean_t 839 dladm_valid_linkname(const char *link) 840 { 841 size_t len = strlen(link); 842 const char *cp; 843 int nd = 0; 844 845 if (len >= MAXLINKNAMELEN) 846 return (B_FALSE); 847 848 /* Link name cannot start with a digit */ 849 if (isdigit(link[0])) 850 return (B_FALSE); 851 /* Link name must end with a number without leading zeroes */ 852 cp = link + len - 1; 853 while (isdigit(*cp)) { 854 cp--; 855 nd++; 856 } 857 if (nd == 0 || (nd > 1 && *(cp + 1) == '0')) 858 return (B_FALSE); 859 860 /* 861 * The legal characters in a link name are: 862 * alphanumeric (a-z, A-Z, 0-9), underscore ('_'), and '.'. 863 */ 864 for (cp = link; *cp != '\0'; cp++) { 865 if ((isalnum(*cp) == 0) && (*cp != '_') && (*cp != '.')) 866 return (B_FALSE); 867 } 868 869 return (B_TRUE); 870 } 871 872 /* 873 * Convert priority string to a value. 874 */ 875 dladm_status_t 876 dladm_str2pri(char *token, mac_priority_level_t *pri) 877 { 878 if (strlen(token) == strlen("low") && 879 strncasecmp(token, "low", strlen("low")) == 0) { 880 *pri = MPL_LOW; 881 } else if (strlen(token) == strlen("medium") && 882 strncasecmp(token, "medium", strlen("medium")) == 0) { 883 *pri = MPL_MEDIUM; 884 } else if (strlen(token) == strlen("high") && 885 strncasecmp(token, "high", strlen("high")) == 0) { 886 *pri = MPL_HIGH; 887 } else { 888 return (DLADM_STATUS_BADVAL); 889 } 890 return (DLADM_STATUS_OK); 891 } 892 893 /* 894 * Convert priority value to a string. 895 */ 896 const char * 897 dladm_pri2str(mac_priority_level_t pri, char *buf) 898 { 899 const char *s; 900 901 switch (pri) { 902 case MPL_LOW: 903 s = "low"; 904 break; 905 case MPL_MEDIUM: 906 s = "medium"; 907 break; 908 case MPL_HIGH: 909 s = "high"; 910 break; 911 default: 912 s = "--"; 913 break; 914 } 915 (void) snprintf(buf, DLADM_STRSIZE, "%s", dgettext(TEXT_DOMAIN, s)); 916 return (buf); 917 } 918 919 /* 920 * Convert protect string to a value. 921 */ 922 dladm_status_t 923 dladm_str2protect(char *token, uint32_t *ptype) 924 { 925 link_protect_t *lp; 926 int i; 927 928 for (i = 0; i < LPTYPES; i++) { 929 lp = &link_protect_types[i]; 930 if (strcmp(token, lp->lp_name) == 0) { 931 *ptype = lp->lp_type; 932 return (DLADM_STATUS_OK); 933 } 934 } 935 return (DLADM_STATUS_BADVAL); 936 } 937 938 /* 939 * Convert protect value to a string. 940 */ 941 const char * 942 dladm_protect2str(uint32_t ptype, char *buf) 943 { 944 const char *s = "--"; 945 link_protect_t *lp; 946 int i; 947 948 for (i = 0; i < LPTYPES; i++) { 949 lp = &link_protect_types[i]; 950 if (lp->lp_type == ptype) { 951 s = lp->lp_name; 952 break; 953 } 954 } 955 (void) snprintf(buf, DLADM_STRSIZE, "%s", dgettext(TEXT_DOMAIN, s)); 956 return (buf); 957 } 958 959 /* 960 * Convert an IPv4 address to/from a string. 961 */ 962 const char * 963 dladm_ipv4addr2str(void *addr, char *buf) 964 { 965 if (inet_ntop(AF_INET, addr, buf, INET_ADDRSTRLEN) == NULL) 966 buf[0] = '\0'; 967 968 return (buf); 969 } 970 971 dladm_status_t 972 dladm_str2ipv4addr(char *token, void *addr) 973 { 974 return (inet_pton(AF_INET, token, addr) == 1 ? 975 DLADM_STATUS_OK : DLADM_STATUS_INVALID_IP); 976 } 977 978 const char * 979 dladm_ipv6addr2str(void *addr, char *buf) 980 { 981 if (inet_ntop(AF_INET6, addr, buf, INET6_ADDRSTRLEN) == NULL) 982 buf[0] = '\0'; 983 984 return (buf); 985 } 986 987 dladm_status_t 988 dladm_str2ipv6addr(char *token, void *addr) 989 { 990 return (inet_pton(AF_INET6, token, addr) == 1 ? 991 DLADM_STATUS_OK : DLADM_STATUS_INVALID_IP); 992 } 993 994 /* 995 * Find the set bits in a mask. 996 * This is used for expanding a bitmask into individual sub-masks 997 * which can be used for further processing. 998 */ 999 void 1000 dladm_find_setbits32(uint32_t mask, uint32_t *list, uint32_t *cnt) 1001 { 1002 int i, c = 0; 1003 1004 for (i = 0; i < 32; i++) { 1005 if (((1 << i) & mask) != 0) 1006 list[c++] = 1 << i; 1007 } 1008 *cnt = c; 1009 } 1010 1011 void 1012 dladm_free_args(dladm_arg_list_t *list) 1013 { 1014 if (list != NULL) { 1015 free(list->al_buf); 1016 free(list); 1017 } 1018 } 1019 1020 dladm_status_t 1021 dladm_parse_args(char *str, dladm_arg_list_t **listp, boolean_t novalues) 1022 { 1023 dladm_arg_list_t *list; 1024 dladm_arg_info_t *aip; 1025 char *buf, *curr; 1026 int len, i; 1027 1028 if (str == NULL) 1029 return (DLADM_STATUS_BADVAL); 1030 1031 if (str[0] == '\0') 1032 return (DLADM_STATUS_OK); 1033 1034 list = malloc(sizeof (dladm_arg_list_t)); 1035 if (list == NULL) 1036 return (dladm_errno2status(errno)); 1037 1038 list->al_count = 0; 1039 list->al_buf = buf = strdup(str); 1040 if (buf == NULL) 1041 return (dladm_errno2status(errno)); 1042 1043 curr = buf; 1044 len = strlen(buf); 1045 aip = NULL; 1046 for (i = 0; i < len; i++) { 1047 char c = buf[i]; 1048 boolean_t match = (c == '=' || c == ','); 1049 1050 if (!match && i != len - 1) 1051 continue; 1052 1053 if (match) { 1054 buf[i] = '\0'; 1055 if (*curr == '\0') 1056 goto fail; 1057 } 1058 1059 if (aip != NULL && c != '=') { 1060 if (aip->ai_count > DLADM_MAX_ARG_VALS) 1061 goto fail; 1062 1063 if (novalues) 1064 goto fail; 1065 1066 aip->ai_val[aip->ai_count] = curr; 1067 aip->ai_count++; 1068 } else { 1069 if (list->al_count > DLADM_MAX_ARG_VALS) 1070 goto fail; 1071 1072 aip = &list->al_info[list->al_count]; 1073 aip->ai_name = curr; 1074 aip->ai_count = 0; 1075 list->al_count++; 1076 if (c == ',') 1077 aip = NULL; 1078 } 1079 curr = buf + i + 1; 1080 } 1081 1082 *listp = list; 1083 return (DLADM_STATUS_OK); 1084 1085 fail: 1086 dladm_free_args(list); 1087 return (DLADM_STATUS_FAILED); 1088 } 1089 1090 /* 1091 * mac_propval_range_t functions. Currently implemented for only 1092 * ranges of uint32_t elements, but can be expanded as required. 1093 */ 1094 /* 1095 * Convert an array of strings (which can be ranges or individual 1096 * elements) into a single mac_propval_range_t structure which 1097 * is allocated here but should be freed by the caller. 1098 */ 1099 dladm_status_t 1100 dladm_strs2range(char **prop_val, uint_t val_cnt, mac_propval_type_t type, 1101 mac_propval_range_t **range) 1102 { 1103 int i; 1104 char *endp; 1105 mac_propval_range_t *rangep; 1106 dladm_status_t status = DLADM_STATUS_OK; 1107 1108 switch (type) { 1109 case MAC_PROPVAL_UINT32: { 1110 mac_propval_uint32_range_t *ur; 1111 1112 /* Allocate range structure */ 1113 rangep = malloc(sizeof (mac_propval_range_t) + 1114 (val_cnt-1)*(sizeof (mac_propval_uint32_range_t))); 1115 if (rangep == NULL) 1116 return (DLADM_STATUS_NOMEM); 1117 1118 rangep->mpr_count = 0; 1119 ur = &rangep->mpr_range_uint32[0]; 1120 for (i = 0; i < val_cnt; i++, ur++) { 1121 errno = 0; 1122 if (strchr(prop_val[i], '-') == NULL) { 1123 /* single element */ 1124 ur->mpur_min = ur->mpur_max = 1125 strtol(prop_val[i], &endp, 10); 1126 if ((endp != NULL) && (*endp != '\0')) { 1127 return (DLADM_STATUS_BADRANGE); 1128 } 1129 } else { 1130 /* range of elements */ 1131 ur->mpur_min = strtol(prop_val[i], &endp, 10); 1132 if (*endp++ != '-') 1133 return (DLADM_STATUS_BADRANGE); 1134 ur->mpur_max = strtol(endp, &endp, 10); 1135 if (endp != NULL && *endp != '\0' || 1136 ur->mpur_max < ur->mpur_min) 1137 return (DLADM_STATUS_BADRANGE); 1138 } 1139 rangep->mpr_count++; 1140 } 1141 break; 1142 } 1143 default: 1144 return (DLADM_STATUS_BADVAL); 1145 } 1146 1147 rangep->mpr_type = type; 1148 *range = rangep; 1149 1150 return (status); 1151 } 1152 1153 /* 1154 * Convert a mac_propval_range_t structure into an array of elements. 1155 */ 1156 dladm_status_t 1157 dladm_range2list(mac_propval_range_t *rangep, void *elem, uint_t *nelem) 1158 { 1159 int i, j, k; 1160 dladm_status_t status = DLADM_STATUS_OK; 1161 1162 switch (rangep->mpr_type) { 1163 case MAC_PROPVAL_UINT32: { 1164 mac_propval_uint32_range_t *ur; 1165 uint32_t *elem32 = elem; 1166 1167 k = 0; 1168 ur = &rangep->mpr_range_uint32[0]; 1169 for (i = 0; i < rangep->mpr_count; i++, ur++) { 1170 for (j = 0; j <= ur->mpur_max - ur->mpur_min; j++) { 1171 elem32[k++] = ur->mpur_min + j; 1172 if (k > *nelem) { 1173 status = DLADM_STATUS_TOOMANYELEMENTS; 1174 break; 1175 } 1176 } 1177 } 1178 *nelem = k; 1179 break; 1180 } 1181 default: 1182 status = DLADM_STATUS_BADVAL; 1183 break; 1184 } 1185 return (status); 1186 } 1187 1188 /* 1189 * Convert a mac_propval_range_t structure into an array of strings 1190 * of single elements or ranges. 1191 */ 1192 int 1193 dladm_range2strs(mac_propval_range_t *rangep, char **prop_val) 1194 { 1195 int i; 1196 1197 switch (rangep->mpr_type) { 1198 case MAC_PROPVAL_UINT32: { 1199 mac_propval_uint32_range_t *ur; 1200 1201 /* Write ranges and individual elements */ 1202 ur = &rangep->mpr_range_uint32[0]; 1203 for (i = 0; i < rangep->mpr_count; i++, ur++) { 1204 if (ur->mpur_min == ur->mpur_max) { 1205 /* single element */ 1206 (void) snprintf(prop_val[i], DLADM_PROP_VAL_MAX, 1207 "%u", ur->mpur_min); 1208 } else { 1209 /* range of elements */ 1210 (void) snprintf(prop_val[i], DLADM_PROP_VAL_MAX, 1211 "%u-%u", ur->mpur_min, ur->mpur_max); 1212 } 1213 } 1214 return (0); 1215 } 1216 default: 1217 break; 1218 } 1219 return (EINVAL); 1220 } 1221 1222 static int 1223 uint32cmp(const void *a, const void *b) 1224 { 1225 return (*(uint32_t *)a - *(uint32_t *)b); 1226 } 1227 1228 /* 1229 * Sort and convert an array of elements into a single 1230 * mac_propval_range_t structure which is allocated here but 1231 * should be freed by the caller. 1232 */ 1233 dladm_status_t 1234 dladm_list2range(void *elem, uint_t nelem, mac_propval_type_t type, 1235 mac_propval_range_t **range) 1236 { 1237 int i; 1238 uint_t nr = 0; 1239 mac_propval_range_t *rangep; 1240 dladm_status_t status = DLADM_STATUS_OK; 1241 1242 switch (type) { 1243 case MAC_PROPVAL_UINT32: { 1244 mac_propval_uint32_range_t *ur; 1245 uint32_t *elem32 = elem; 1246 uint32_t *sort32; 1247 1248 /* Allocate range structure */ 1249 rangep = malloc(sizeof (mac_propval_range_t) + 1250 (nelem-1)*(sizeof (mac_propval_uint32_range_t))); 1251 if (rangep == NULL) 1252 return (DLADM_STATUS_NOMEM); 1253 1254 /* Allocate array for sorting */ 1255 sort32 = malloc(nelem * sizeof (uint32_t)); 1256 if (sort32 == NULL) { 1257 free(rangep); 1258 return (DLADM_STATUS_NOMEM); 1259 } 1260 1261 /* Copy and sort list */ 1262 for (i = 0; i < nelem; i++) 1263 sort32[i] = elem32[i]; 1264 if (nelem > 1) 1265 qsort(sort32, nelem, sizeof (uint32_t), uint32cmp); 1266 1267 /* Convert list to ranges */ 1268 ur = &rangep->mpr_range_uint32[0]; 1269 ur->mpur_min = ur->mpur_max = sort32[0]; 1270 for (i = 1; i < nelem; i++) { 1271 if (sort32[i]-sort32[i-1] == 1) { 1272 /* part of current range */ 1273 ur->mpur_max = sort32[i]; 1274 } else { 1275 /* start a new range */ 1276 nr++; ur++; 1277 ur->mpur_min = ur->mpur_max = sort32[i]; 1278 } 1279 } 1280 free(sort32); 1281 break; 1282 } 1283 default: 1284 return (DLADM_STATUS_BADRANGE); 1285 } 1286 1287 rangep->mpr_type = type; 1288 rangep->mpr_count = nr + 1; 1289 *range = rangep; 1290 1291 return (status); 1292 } 1293