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