/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * Copyright (c) 2015, Joyent, Inc. * Copyright 2020 Peter Tribble. * Copyright 2022 OmniOS Community Edition (OmniOSce) Association. * Copyright 2023 Oxide Computer Company */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static char dladm_rootdir[MAXPATHLEN] = "/"; typedef struct media_type_desc { uint32_t media_type; #define MAX_MEDIA_TYPE_STRING 32 const char media_type_str[MAX_MEDIA_TYPE_STRING]; } media_type_t; static media_type_t media_type_table[] = { { DL_ETHER, "Ethernet" }, { DL_WIFI, "WiFi" }, { DL_IB, "Infiniband" }, { DL_IPV4, "IPv4Tunnel" }, { DL_IPV6, "IPv6Tunnel" }, { DL_6TO4, "6to4Tunnel" }, { DL_CSMACD, "CSMA/CD" }, { DL_TPB, "TokenBus" }, { DL_TPR, "TokenRing" }, { DL_METRO, "MetroNet" }, { DL_HDLC, "HDLC" }, { DL_CHAR, "SyncCharacter" }, { DL_CTCA, "CTCA" }, { DL_FDDI, "FDDI" }, { DL_FC, "FiberChannel" }, { DL_ATM, "ATM" }, { DL_IPATM, "ATM(ClassicIP)" }, { DL_X25, "X.25" }, { DL_IPX25, "X.25(ClassicIP)" }, { DL_ISDN, "ISDN" }, { DL_HIPPI, "HIPPI" }, { DL_100VG, "100BaseVGEthernet" }, { DL_100VGTPR, "100BaseVGTokenRing" }, { DL_ETH_CSMA, "IEEE802.3" }, { DL_100BT, "100BaseT" }, { DL_FRAME, "FrameRelay" }, { DL_MPFRAME, "MPFrameRelay" }, { DL_ASYNC, "AsyncCharacter" }, { DL_IPNET, "IPNET" }, { DL_OTHER, "Other" } }; #define MEDIATYPECOUNT (sizeof (media_type_table) / sizeof (media_type_t)) typedef struct { uint32_t lp_type; char *lp_name; } link_protect_t; static link_protect_t link_protect_types[] = { { MPT_MACNOSPOOF, "mac-nospoof" }, { MPT_RESTRICTED, "restricted" }, { MPT_IPNOSPOOF, "ip-nospoof" }, { MPT_DHCPNOSPOOF, "dhcp-nospoof" } }; #define LPTYPES (sizeof (link_protect_types) / sizeof (link_protect_t)) dladm_status_t dladm_open(dladm_handle_t *handle) { int dld_fd; if (handle == NULL) return (DLADM_STATUS_BADARG); if ((dld_fd = open(DLD_CONTROL_DEV, O_RDWR)) < 0) return (dladm_errno2status(errno)); /* * Don't open DLMGMT_DOOR now. dlmgmtd(8) is not able to * open the door when the dladm handle is opened because the * door hasn't been created yet at that time. Thus, we must * open it on-demand in dladm_door_fd(). Move the open() * to dladm_door_fd() for all cases. */ if ((*handle = malloc(sizeof (struct dladm_handle))) == NULL) { (void) close(dld_fd); return (DLADM_STATUS_NOMEM); } (*handle)->dld_fd = dld_fd; (*handle)->door_fd = -1; (*handle)->dld_kcp = NULL; return (DLADM_STATUS_OK); } void dladm_close(dladm_handle_t handle) { if (handle != NULL) { (void) close(handle->dld_fd); if (handle->door_fd != -1) (void) close(handle->door_fd); if (handle->dld_kcp != NULL) (void) kstat_close(handle->dld_kcp); free(handle); } } int dladm_dld_fd(dladm_handle_t handle) { return (handle->dld_fd); } kstat_ctl_t * dladm_dld_kcp(dladm_handle_t handle) { if (handle->dld_kcp == NULL) handle->dld_kcp = kstat_open(); return (handle->dld_kcp); } /* * If DLMGMT_DOOR hasn't been opened in the handle yet, open it. */ dladm_status_t dladm_door_fd(dladm_handle_t handle, int *door_fd) { int fd; if (handle->door_fd == -1) { if ((fd = open(DLMGMT_DOOR, O_RDONLY)) < 0) return (dladm_errno2status(errno)); handle->door_fd = fd; } *door_fd = handle->door_fd; return (DLADM_STATUS_OK); } const char * dladm_status2str(dladm_status_t status, char *buf) { const char *s; switch (status) { case DLADM_STATUS_OK: s = "ok"; break; case DLADM_STATUS_BADARG: s = "invalid argument"; break; case DLADM_STATUS_FAILED: s = "operation failed"; break; case DLADM_STATUS_TOOSMALL: s = "buffer size too small"; break; case DLADM_STATUS_NOTSUP: s = "operation not supported"; break; case DLADM_STATUS_NOTFOUND: s = "object not found"; break; case DLADM_STATUS_BADVAL: s = "invalid value"; break; case DLADM_STATUS_NOMEM: s = "insufficient memory"; break; case DLADM_STATUS_EXIST: s = "object already exists"; break; case DLADM_STATUS_LINKINVAL: s = "invalid link"; break; case DLADM_STATUS_PROPRDONLY: s = "read-only property"; break; case DLADM_STATUS_BADVALCNT: s = "invalid number of values"; break; case DLADM_STATUS_DBNOTFOUND: s = "database not found"; break; case DLADM_STATUS_DENIED: s = "permission denied"; break; case DLADM_STATUS_IOERR: s = "I/O error"; break; case DLADM_STATUS_TEMPONLY: s = "change cannot be persistent"; break; case DLADM_STATUS_TIMEDOUT: s = "operation timed out"; break; case DLADM_STATUS_ISCONN: s = "already connected"; break; case DLADM_STATUS_NOTCONN: s = "not connected"; break; case DLADM_STATUS_REPOSITORYINVAL: s = "invalid configuration repository"; break; case DLADM_STATUS_MACADDRINVAL: s = "invalid MAC address"; break; case DLADM_STATUS_KEYINVAL: s = "invalid key"; break; case DLADM_STATUS_INVALIDMACADDRLEN: s = "invalid MAC address length"; break; case DLADM_STATUS_INVALIDMACADDRTYPE: s = "invalid MAC address type"; break; case DLADM_STATUS_LINKBUSY: s = "link busy"; break; case DLADM_STATUS_VIDINVAL: s = "invalid VLAN identifier"; break; case DLADM_STATUS_TRYAGAIN: s = "try again later"; break; case DLADM_STATUS_NONOTIF: s = "link notification is not supported"; break; case DLADM_STATUS_BADTIMEVAL: s = "invalid time range"; break; case DLADM_STATUS_INVALIDMACADDR: s = "invalid MAC address value"; break; case DLADM_STATUS_INVALIDMACADDRNIC: s = "MAC address reserved for use by underlying data-link"; break; case DLADM_STATUS_INVALIDMACADDRINUSE: s = "MAC address is already in use"; break; case DLADM_STATUS_MACFACTORYSLOTINVALID: s = "invalid factory MAC address slot"; break; case DLADM_STATUS_MACFACTORYSLOTUSED: s = "factory MAC address slot already used"; break; case DLADM_STATUS_MACFACTORYSLOTALLUSED: s = "all factory MAC address slots are in use"; break; case DLADM_STATUS_MACFACTORYNOTSUP: s = "factory MAC address slots not supported"; break; case DLADM_STATUS_INVALIDMACPREFIX: s = "Invalid MAC address prefix value"; break; case DLADM_STATUS_INVALIDMACPREFIXLEN: s = "Invalid MAC address prefix length"; break; case DLADM_STATUS_BADCPUID: s = "non-existent processor ID"; break; case DLADM_STATUS_CPUERR: s = "could not determine processor status"; break; case DLADM_STATUS_CPUNOTONLINE: s = "processor not online"; break; case DLADM_STATUS_TOOMANYELEMENTS: s = "too many elements specified"; break; case DLADM_STATUS_BADRANGE: s = "invalid range"; break; case DLADM_STATUS_DB_NOTFOUND: s = "database not found"; break; case DLADM_STATUS_DB_PARSE_ERR: s = "database parse error"; break; case DLADM_STATUS_PROP_PARSE_ERR: s = "property parse error"; break; case DLADM_STATUS_ATTR_PARSE_ERR: s = "attribute parse error"; break; case DLADM_STATUS_FLOW_DB_ERR: s = "flow database error"; break; case DLADM_STATUS_FLOW_DB_OPEN_ERR: s = "flow database open error"; break; case DLADM_STATUS_FLOW_DB_PARSE_ERR: s = "flow database parse error"; break; case DLADM_STATUS_FLOWPROP_DB_PARSE_ERR: s = "flow property database parse error"; break; case DLADM_STATUS_FLOW_ADD_ERR: s = "flow add error"; break; case DLADM_STATUS_FLOW_WALK_ERR: s = "flow walk error"; break; case DLADM_STATUS_FLOW_IDENTICAL: s = "a flow with identical attributes exists"; break; case DLADM_STATUS_FLOW_INCOMPATIBLE: s = "flow(s) with incompatible attributes exists"; break; case DLADM_STATUS_FLOW_EXISTS: s = "link still has flows"; break; case DLADM_STATUS_PERSIST_FLOW_EXISTS: s = "persistent flow with the same name exists"; break; case DLADM_STATUS_INVALID_IP: s = "invalid IP address"; break; case DLADM_STATUS_INVALID_PREFIXLEN: s = "invalid IP prefix length"; break; case DLADM_STATUS_INVALID_PROTOCOL: s = "invalid IP protocol"; break; case DLADM_STATUS_INVALID_PORT: s = "invalid port number"; break; case DLADM_STATUS_INVALID_DSF: s = "invalid dsfield"; break; case DLADM_STATUS_INVALID_DSFMASK: s = "invalid dsfield mask"; break; case DLADM_STATUS_INVALID_MACMARGIN: s = "MTU check failed, use lower MTU or -f option"; break; case DLADM_STATUS_BADPROP: s = "invalid property"; break; case DLADM_STATUS_MINMAXBW: s = "minimum value for maxbw is 1200K"; break; case DLADM_STATUS_NO_HWRINGS: s = "request hw rings failed"; break; case DLADM_STATUS_PERMONLY: s = "change must be persistent"; break; case DLADM_STATUS_OPTMISSING: s = "optional software not installed"; break; case DLADM_STATUS_IPTUNTYPE: s = "invalid IP tunnel type"; break; case DLADM_STATUS_IPTUNTYPEREQD: s = "IP tunnel type required"; break; case DLADM_STATUS_BADIPTUNLADDR: s = "invalid local IP tunnel address"; break; case DLADM_STATUS_BADIPTUNRADDR: s = "invalid remote IP tunnel address"; break; case DLADM_STATUS_ADDRINUSE: s = "address already in use"; break; case DLADM_STATUS_POOLCPU: s = "pool and cpus property are mutually exclusive"; break; case DLADM_STATUS_INVALID_PORT_INSTANCE: s = "invalid IB phys link"; break; case DLADM_STATUS_PORT_IS_DOWN: s = "port is down"; break; case DLADM_STATUS_PARTITION_EXISTS: s = "partition already exists"; break; case DLADM_STATUS_PKEY_NOT_PRESENT: s = "PKEY is not present on the port"; break; case DLADM_STATUS_INVALID_PKEY: s = "invalid PKEY"; break; case DLADM_STATUS_NO_IB_HW_RESOURCE: s = "IB internal resource not available"; break; case DLADM_STATUS_INVALID_PKEY_TBL_SIZE: s = "invalid PKEY table size"; break; case DLADM_STATUS_PORT_NOPROTO: s = "local or remote port requires transport"; break; case DLADM_STATUS_INVALID_MTU: s = "MTU check failed, MTU outside of device's supported range"; break; case DLADM_STATUS_PERSIST_ON_TEMP: s = "can't create persistent object on top of temporary object"; break; case DLADM_STATUS_BAD_ENCAP: s = "invalid encapsulation protocol"; break; case DLADM_STATUS_ADDRNOTAVAIL: s = "can't assign requested address"; break; default: s = ""; break; } (void) snprintf(buf, DLADM_STRSIZE, "%s", dgettext(TEXT_DOMAIN, s)); return (buf); } /* * Convert a unix errno to a dladm_status_t. * We only convert errnos that are likely to be encountered. All others * are mapped to DLADM_STATUS_FAILED. */ dladm_status_t dladm_errno2status(int err) { switch (err) { case 0: return (DLADM_STATUS_OK); case EINVAL: return (DLADM_STATUS_BADARG); case EEXIST: return (DLADM_STATUS_EXIST); case ENOENT: return (DLADM_STATUS_NOTFOUND); case ENOSPC: return (DLADM_STATUS_TOOSMALL); case ENOMEM: return (DLADM_STATUS_NOMEM); case ENOTSUP: return (DLADM_STATUS_NOTSUP); case ENETDOWN: return (DLADM_STATUS_NONOTIF); case EACCES: case EPERM: return (DLADM_STATUS_DENIED); case EIO: return (DLADM_STATUS_IOERR); case EBUSY: return (DLADM_STATUS_LINKBUSY); case EAGAIN: return (DLADM_STATUS_TRYAGAIN); case ENOTEMPTY: return (DLADM_STATUS_FLOW_EXISTS); case EOPNOTSUPP: return (DLADM_STATUS_FLOW_INCOMPATIBLE); case EALREADY: return (DLADM_STATUS_FLOW_IDENTICAL); case EADDRINUSE: return (DLADM_STATUS_ADDRINUSE); case EADDRNOTAVAIL: return (DLADM_STATUS_ADDRNOTAVAIL); default: return (DLADM_STATUS_FAILED); } } boolean_t dladm_str2interval(char *oarg, uint32_t *interval) { int val; char *endp = NULL; errno = 0; val = strtol(oarg, &endp, 10); if (errno != 0 || val <= 0 || *endp != '\0') return (B_FALSE); *interval = val; return (B_TRUE); } dladm_status_t dladm_str2bw(char *oarg, uint64_t *bw) { char *endp = NULL; uint64_t n; int64_t sn; int mult = 1; errno = 0; sn = strtoull(oarg, &endp, 10); if ((errno != 0) || (strlen(endp) > 1)) return (DLADM_STATUS_BADARG); if (sn < 0) return (DLADM_STATUS_BADVAL); n = sn; switch (*endp) { case 'k': case 'K': mult = 1000; break; case 'm': case 'M': case '\0': mult = 1000000; break; case 'g': case 'G': mult = 1000000000; break; case '%': /* * percentages not supported for now, * see RFE 6540675 */ return (DLADM_STATUS_NOTSUP); default: return (DLADM_STATUS_BADVAL); } *bw = n * mult; /* check for overflow */ if (*bw / mult != n) return (DLADM_STATUS_BADARG); return (DLADM_STATUS_OK); } /* * Convert bandwidth in bps to a string in Mbps. For values greater * than 1Mbps or 1000000, print a whole Mbps value. For values that * have fractional Mbps in whole Kbps, print the bandwidth in a manner * similar to a floating point format. * * bps string * 0 0 * 100 0 * 2000 0.002 * 431000 0.431 * 1000000 1 * 1030000 1.030 * 100000000 100 */ const char * dladm_bw2str(int64_t bw, char *buf) { int kbps, mbps; kbps = (bw%1000000)/1000; mbps = bw/1000000; if (kbps != 0) { (void) snprintf(buf, DLADM_STRSIZE, "%5u.%03u", mbps, kbps); } else { (void) snprintf(buf, DLADM_STRSIZE, "%5u", mbps); } return (buf); } #define LOCK_DB_PERMS S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH static int i_dladm_lock_db(const char *lock_file, short type) { int lock_fd; struct flock lock; if ((lock_fd = open(lock_file, O_RDWR | O_CREAT | O_TRUNC, LOCK_DB_PERMS)) < 0) return (-1); lock.l_type = type; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; if (fcntl(lock_fd, F_SETLKW, &lock) < 0) { int err = errno; (void) close(lock_fd); (void) unlink(lock_file); errno = err; return (-1); } return (lock_fd); } static void i_dladm_unlock_db(const char *lock_file, int fd) { struct flock lock; if (fd < 0) return; lock.l_type = F_UNLCK; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; (void) fcntl(fd, F_SETLKW, &lock); (void) close(fd); (void) unlink(lock_file); } /* * Given a link class, returns its class string. */ const char * dladm_class2str(datalink_class_t class, char *buf) { const char *s; switch (class) { case DATALINK_CLASS_PHYS: s = "phys"; break; case DATALINK_CLASS_VLAN: s = "vlan"; break; case DATALINK_CLASS_AGGR: s = "aggr"; break; case DATALINK_CLASS_VNIC: s = "vnic"; break; case DATALINK_CLASS_ETHERSTUB: s = "etherstub"; break; case DATALINK_CLASS_IPTUN: s = "iptun"; break; case DATALINK_CLASS_SIMNET: s = "simnet"; break; case DATALINK_CLASS_BRIDGE: s = "bridge"; break; case DATALINK_CLASS_PART: s = "part"; break; case DATALINK_CLASS_OVERLAY: s = "overlay"; break; case DATALINK_CLASS_MISC: s = "misc"; break; default: s = "unknown"; break; } (void) snprintf(buf, DLADM_STRSIZE, "%s", s); return (buf); } /* * Given a physical link media type, returns its media type string. */ const char * dladm_media2str(uint32_t media, char *buf) { const char *s = "--"; media_type_t *mt; uint_t idx; for (idx = 0; idx < MEDIATYPECOUNT; idx++) { mt = media_type_table + idx; if (mt->media_type == media) { s = mt->media_type_str; break; } } (void) snprintf(buf, DLADM_STRSIZE, "%s", s); return (buf); } /* * Given a physical link media type string, returns its media type constant. */ uint32_t dladm_str2media(const char *buf) { media_type_t *mt; uint_t idx; for (idx = 0; idx < MEDIATYPECOUNT; idx++) { mt = media_type_table + idx; if (strcasecmp(buf, mt->media_type_str) == 0) return (mt->media_type); } return (DL_OTHER); } dladm_status_t i_dladm_rw_db(dladm_handle_t handle, const char *db_file, mode_t db_perms, dladm_status_t (*process_db)(dladm_handle_t, void *, FILE *, FILE *), void *arg, boolean_t writeop) { dladm_status_t status = DLADM_STATUS_OK; FILE *fp, *nfp = NULL; char lock[MAXPATHLEN]; char file[MAXPATHLEN]; char newfile[MAXPATHLEN]; char *db_basename; int nfd, lock_fd; /* * If we are called from a boot script such as net-physical, * it's quite likely that the root fs is still not writable. * For this case, it's ok for the lock creation to fail since * no one else could be accessing our configuration file. */ db_basename = strrchr(db_file, '/'); if (db_basename == NULL || db_basename[1] == '\0') return (dladm_errno2status(EINVAL)); db_basename++; (void) snprintf(lock, MAXPATHLEN, "/tmp/%s.lock", db_basename); if ((lock_fd = i_dladm_lock_db (lock, (writeop ? F_WRLCK : F_RDLCK))) < 0 && errno != EROFS) return (dladm_errno2status(errno)); (void) snprintf(file, MAXPATHLEN, "%s/%s", dladm_rootdir, db_file); if ((fp = fopen(file, (writeop ? "r+" : "r"))) == NULL) { int err = errno; i_dladm_unlock_db(lock, lock_fd); if (err == ENOENT) return (DLADM_STATUS_DBNOTFOUND); return (dladm_errno2status(err)); } if (writeop) { (void) snprintf(newfile, MAXPATHLEN, "%s/%s.new", dladm_rootdir, db_file); if ((nfd = open(newfile, O_WRONLY | O_CREAT | O_TRUNC, db_perms)) < 0) { (void) fclose(fp); i_dladm_unlock_db(lock, lock_fd); return (dladm_errno2status(errno)); } if ((nfp = fdopen(nfd, "w")) == NULL) { (void) close(nfd); (void) fclose(fp); (void) unlink(newfile); i_dladm_unlock_db(lock, lock_fd); return (dladm_errno2status(errno)); } } status = (*process_db)(handle, arg, fp, nfp); if (!writeop || status != DLADM_STATUS_OK) goto done; /* Set permissions on file to db_perms */ if (fchmod(nfd, db_perms) < 0) { status = dladm_errno2status(errno); goto done; } /* * Configuration files need to be owned by the 'dladm' user and * 'netadm' group. */ if (fchown(nfd, UID_DLADM, GID_NETADM) < 0) { status = dladm_errno2status(errno); goto done; } if (fflush(nfp) == EOF) { status = dladm_errno2status(errno); goto done; } (void) fclose(fp); (void) fclose(nfp); if (rename(newfile, file) < 0) { (void) unlink(newfile); i_dladm_unlock_db(lock, lock_fd); return (dladm_errno2status(errno)); } i_dladm_unlock_db(lock, lock_fd); return (DLADM_STATUS_OK); done: if (nfp != NULL) { (void) fclose(nfp); if (status != DLADM_STATUS_OK) (void) unlink(newfile); } (void) fclose(fp); i_dladm_unlock_db(lock, lock_fd); return (status); } dladm_status_t dladm_set_rootdir(const char *rootdir) { DIR *dp; if (rootdir == NULL || *rootdir != '/' || (dp = opendir(rootdir)) == NULL) return (DLADM_STATUS_BADARG); (void) strncpy(dladm_rootdir, rootdir, MAXPATHLEN); (void) closedir(dp); return (DLADM_STATUS_OK); } boolean_t dladm_valid_linkname(const char *link) { size_t len = strlen(link); const char *cp; int nd = 0; if (len >= MAXLINKNAMELEN) return (B_FALSE); /* Link name cannot start with a digit */ if (isdigit(link[0])) return (B_FALSE); /* Link name must end with a number without leading zeroes */ cp = link + len - 1; while (isdigit(*cp)) { cp--; nd++; } if (nd == 0 || (nd > 1 && *(cp + 1) == '0')) return (B_FALSE); /* * The legal characters in a link name are: * alphanumeric (a-z, A-Z, 0-9), underscore ('_'), and '.'. */ for (cp = link; *cp != '\0'; cp++) { if ((isalnum(*cp) == 0) && (*cp != '_') && (*cp != '.')) return (B_FALSE); } return (B_TRUE); } /* * Convert priority string to a value. */ dladm_status_t dladm_str2pri(char *token, mac_priority_level_t *pri) { if (strlen(token) == strlen("low") && strncasecmp(token, "low", strlen("low")) == 0) { *pri = MPL_LOW; } else if (strlen(token) == strlen("medium") && strncasecmp(token, "medium", strlen("medium")) == 0) { *pri = MPL_MEDIUM; } else if (strlen(token) == strlen("high") && strncasecmp(token, "high", strlen("high")) == 0) { *pri = MPL_HIGH; } else { return (DLADM_STATUS_BADVAL); } return (DLADM_STATUS_OK); } /* * Convert priority value to a string. */ const char * dladm_pri2str(mac_priority_level_t pri, char *buf) { const char *s; switch (pri) { case MPL_LOW: s = "low"; break; case MPL_MEDIUM: s = "medium"; break; case MPL_HIGH: s = "high"; break; default: s = "--"; break; } (void) snprintf(buf, DLADM_STRSIZE, "%s", dgettext(TEXT_DOMAIN, s)); return (buf); } /* * Convert protect string to a value. */ dladm_status_t dladm_str2protect(char *token, uint32_t *ptype) { link_protect_t *lp; uint_t i; for (i = 0; i < LPTYPES; i++) { lp = &link_protect_types[i]; if (strcmp(token, lp->lp_name) == 0) { *ptype = lp->lp_type; return (DLADM_STATUS_OK); } } return (DLADM_STATUS_BADVAL); } /* * Convert protect value to a string. */ const char * dladm_protect2str(uint32_t ptype, char *buf) { const char *s = "--"; link_protect_t *lp; uint_t i; for (i = 0; i < LPTYPES; i++) { lp = &link_protect_types[i]; if (lp->lp_type == ptype) { s = lp->lp_name; break; } } (void) snprintf(buf, DLADM_STRSIZE, "%s", dgettext(TEXT_DOMAIN, s)); return (buf); } /* * Convert an IPv4 address to/from a string. */ const char * dladm_ipv4addr2str(void *addr, char *buf) { if (inet_ntop(AF_INET, addr, buf, INET_ADDRSTRLEN) == NULL) buf[0] = '\0'; return (buf); } dladm_status_t dladm_str2ipv4addr(char *token, void *addr) { return (inet_pton(AF_INET, token, addr) == 1 ? DLADM_STATUS_OK : DLADM_STATUS_INVALID_IP); } const char * dladm_ipv6addr2str(void *addr, char *buf) { if (inet_ntop(AF_INET6, addr, buf, INET6_ADDRSTRLEN) == NULL) buf[0] = '\0'; return (buf); } dladm_status_t dladm_str2ipv6addr(char *token, void *addr) { return (inet_pton(AF_INET6, token, addr) == 1 ? DLADM_STATUS_OK : DLADM_STATUS_INVALID_IP); } /* * Find the set bits in a mask. * This is used for expanding a bitmask into individual sub-masks * which can be used for further processing. */ void dladm_find_setbits32(uint32_t mask, uint32_t *list, uint32_t *cnt) { int i, c = 0; for (i = 0; i < 32; i++) { if (((1 << i) & mask) != 0) list[c++] = 1 << i; } *cnt = c; } void dladm_free_args(dladm_arg_list_t *list) { if (list != NULL) { free(list->al_buf); free(list); } } dladm_status_t dladm_parse_args(char *str, dladm_arg_list_t **listp, boolean_t novalues) { dladm_arg_list_t *list; dladm_arg_info_t *aip; char *buf, *curr; int len, i; if (str == NULL) return (DLADM_STATUS_BADVAL); if (str[0] == '\0') return (DLADM_STATUS_OK); list = malloc(sizeof (dladm_arg_list_t)); if (list == NULL) return (dladm_errno2status(errno)); list->al_count = 0; list->al_buf = buf = strdup(str); if (buf == NULL) return (dladm_errno2status(errno)); curr = buf; len = strlen(buf); aip = NULL; for (i = 0; i < len; i++) { char c = buf[i]; boolean_t match = (c == '=' || c == ','); if (!match && i != len - 1) continue; if (match) { buf[i] = '\0'; if (*curr == '\0') goto fail; } if (aip != NULL && c != '=') { if (aip->ai_count > DLADM_MAX_ARG_VALS) goto fail; if (novalues) goto fail; aip->ai_val[aip->ai_count] = curr; aip->ai_count++; } else { if (list->al_count > DLADM_MAX_ARG_VALS) goto fail; aip = &list->al_info[list->al_count]; aip->ai_name = curr; aip->ai_count = 0; list->al_count++; if (c == ',') aip = NULL; } curr = buf + i + 1; } *listp = list; return (DLADM_STATUS_OK); fail: dladm_free_args(list); return (DLADM_STATUS_FAILED); } /* * mac_propval_range_t functions. Currently implemented for only * ranges of uint32_t elements, but can be expanded as required. */ /* * Convert an array of strings (which can be ranges or individual * elements) into a single mac_propval_range_t structure which * is allocated here but should be freed by the caller. */ dladm_status_t dladm_strs2range(char **prop_val, uint_t val_cnt, mac_propval_type_t type, mac_propval_range_t **range) { uint_t i; char *endp; mac_propval_range_t *rangep; dladm_status_t status = DLADM_STATUS_OK; switch (type) { case MAC_PROPVAL_UINT32: { mac_propval_uint32_range_t *ur; /* Allocate range structure */ rangep = malloc(sizeof (mac_propval_range_t) + (val_cnt-1)*(sizeof (mac_propval_uint32_range_t))); if (rangep == NULL) return (DLADM_STATUS_NOMEM); rangep->mpr_count = 0; ur = &rangep->mpr_range_uint32[0]; for (i = 0; i < val_cnt; i++, ur++) { errno = 0; if (strchr(prop_val[i], '-') == NULL) { /* single element */ ur->mpur_min = ur->mpur_max = strtol(prop_val[i], &endp, 10); if ((endp != NULL) && (*endp != '\0')) { return (DLADM_STATUS_BADRANGE); } } else { /* range of elements */ ur->mpur_min = strtol(prop_val[i], &endp, 10); if (*endp++ != '-') return (DLADM_STATUS_BADRANGE); ur->mpur_max = strtol(endp, &endp, 10); if ((endp != NULL && *endp != '\0') || ur->mpur_max < ur->mpur_min) return (DLADM_STATUS_BADRANGE); } rangep->mpr_count++; } break; } default: return (DLADM_STATUS_BADVAL); } rangep->mpr_type = type; *range = rangep; return (status); } /* * Convert a mac_propval_range_t structure into an array of elements. */ dladm_status_t dladm_range2list(const mac_propval_range_t *rangep, void *elem, uint_t *nelem) { uint_t i, j, k; dladm_status_t status = DLADM_STATUS_OK; switch (rangep->mpr_type) { case MAC_PROPVAL_UINT32: { const mac_propval_uint32_range_t *ur; uint32_t *elem32 = elem; k = 0; ur = &rangep->mpr_range_uint32[0]; for (i = 0; i < rangep->mpr_count; i++, ur++) { for (j = 0; j <= ur->mpur_max - ur->mpur_min; j++) { elem32[k++] = ur->mpur_min + j; if (k > *nelem) { status = DLADM_STATUS_TOOMANYELEMENTS; break; } } } *nelem = k; break; } default: status = DLADM_STATUS_BADVAL; break; } return (status); } /* * Convert a mac_propval_range_t structure into an array of strings * of single elements or ranges. */ int dladm_range2strs(const mac_propval_range_t *rangep, char **prop_val) { uint_t i; switch (rangep->mpr_type) { case MAC_PROPVAL_UINT32: { const mac_propval_uint32_range_t *ur; /* Write ranges and individual elements */ ur = &rangep->mpr_range_uint32[0]; for (i = 0; i < rangep->mpr_count; i++, ur++) { if (ur->mpur_min == ur->mpur_max) { /* single element */ (void) snprintf(prop_val[i], DLADM_PROP_VAL_MAX, "%u", ur->mpur_min); } else { /* range of elements */ (void) snprintf(prop_val[i], DLADM_PROP_VAL_MAX, "%u-%u", ur->mpur_min, ur->mpur_max); } } return (0); } case MAC_PROPVAL_STR: { const mac_propval_str_range_t *str; size_t coff, len; coff = 0; str = &rangep->u.mpr_str; for (i = 0; i < rangep->mpr_count; i++) { len = strlen(&str->mpur_data[coff]); (void) strlcpy(prop_val[i], &str->mpur_data[coff], DLADM_PROP_VAL_MAX); coff += len + 1; } return (0); } default: break; } return (EINVAL); } static int uint32cmp(const void *a, const void *b) { return (*(uint32_t *)a - *(uint32_t *)b); } /* * Sort and convert an array of elements into a single * mac_propval_range_t structure which is allocated here but * should be freed by the caller. */ dladm_status_t dladm_list2range(void *elem, uint_t nelem, mac_propval_type_t type, mac_propval_range_t **range) { uint_t i; uint_t nr = 0; mac_propval_range_t *rangep; dladm_status_t status = DLADM_STATUS_OK; switch (type) { case MAC_PROPVAL_UINT32: { mac_propval_uint32_range_t *ur; uint32_t *elem32 = elem; uint32_t *sort32; /* Allocate range structure */ rangep = malloc(sizeof (mac_propval_range_t) + (nelem-1)*(sizeof (mac_propval_uint32_range_t))); if (rangep == NULL) return (DLADM_STATUS_NOMEM); /* Allocate array for sorting */ sort32 = malloc(nelem * sizeof (uint32_t)); if (sort32 == NULL) { free(rangep); return (DLADM_STATUS_NOMEM); } /* Copy and sort list */ for (i = 0; i < nelem; i++) sort32[i] = elem32[i]; if (nelem > 1) qsort(sort32, nelem, sizeof (uint32_t), uint32cmp); /* Convert list to ranges */ ur = &rangep->mpr_range_uint32[0]; ur->mpur_min = ur->mpur_max = sort32[0]; for (i = 1; i < nelem; i++) { if (sort32[i]-sort32[i-1] == 1) { /* part of current range */ ur->mpur_max = sort32[i]; } else { /* start a new range */ nr++; ur++; ur->mpur_min = ur->mpur_max = sort32[i]; } } free(sort32); break; } default: return (DLADM_STATUS_BADRANGE); } rangep->mpr_type = type; rangep->mpr_count = nr + 1; *range = rangep; return (status); } void dladm_errlist_init(dladm_errlist_t *erl) { bzero(erl, sizeof (dladm_errlist_t)); } void dladm_errlist_reset(dladm_errlist_t *erl) { uint_t i; for (i = 0; i < erl->el_count; i++) free(erl->el_errs[i]); free(erl->el_errs); dladm_errlist_init(erl); } uint_t dladm_errlist_count(dladm_errlist_t *erl) { return (erl->el_count); } dladm_status_t dladm_errlist_append(dladm_errlist_t *erl, const char *fmt, ...) { int ret; va_list ap; char *m = NULL; if (erl->el_count == erl->el_alloc) { int alloc; void *addr; if (erl->el_alloc == 0) { assert(erl->el_errs == NULL); alloc = 32; } else { alloc = erl->el_alloc + 32; } addr = realloc(erl->el_errs, sizeof (char *) * alloc); if (addr == NULL) return (DLADM_STATUS_NOMEM); erl->el_errs = addr; erl->el_alloc = alloc; } va_start(ap, fmt); ret = vasprintf(&m, fmt, ap); va_end(ap); if (ret == -1) return (dladm_errno2status(errno)); erl->el_errs[erl->el_count] = m; erl->el_count++; return (DLADM_STATUS_OK); }