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