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) 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /*
26 * This file contains routines that are used to modify/retrieve protocol or
27 * interface property values. It also holds all the supported properties for
28 * both IP interface and protocols in `ipadm_prop_desc_t'. Following protocols
29 * are supported: IP, IPv4, IPv6, TCP, SCTP, UDP and ICMP.
30 *
31 * This file also contains walkers, which walks through the property table and
32 * calls the callback function, of the form `ipadm_prop_wfunc_t' , for every
33 * property in the table.
34 */
35
36 #include <unistd.h>
37 #include <errno.h>
38 #include <ctype.h>
39 #include <fcntl.h>
40 #include <strings.h>
41 #include <stdlib.h>
42 #include <netinet/in.h>
43 #include <arpa/inet.h>
44 #include <sys/sockio.h>
45 #include <assert.h>
46 #include <libdllink.h>
47 #include <zone.h>
48 #include "libipadm_impl.h"
49 #include <inet/tunables.h>
50
51 #define IPADM_NONESTR "none"
52 #define DEF_METRIC_VAL 0 /* default metric value */
53
54 #define A_CNT(arr) (sizeof (arr) / sizeof (arr[0]))
55
56 static ipadm_status_t i_ipadm_validate_if(ipadm_handle_t, const char *,
57 uint_t, uint_t);
58
59 /*
60 * Callback functions to retrieve property values from the kernel. These
61 * functions, when required, translate the values from the kernel to a format
62 * suitable for printing. For example: boolean values will be translated
63 * to on/off. They also retrieve DEFAULT, PERM and POSSIBLE values for
64 * a given property.
65 */
66 static ipadm_pd_getf_t i_ipadm_get_prop, i_ipadm_get_ifprop_flags,
67 i_ipadm_get_mtu, i_ipadm_get_metric,
68 i_ipadm_get_usesrc, i_ipadm_get_forwarding,
69 i_ipadm_get_ecnsack, i_ipadm_get_hostmodel;
70
71 /*
72 * Callback function to set property values. These functions translate the
73 * values to a format suitable for kernel consumption, allocates the necessary
74 * ioctl buffers and then invokes ioctl().
75 */
76 static ipadm_pd_setf_t i_ipadm_set_prop, i_ipadm_set_mtu,
77 i_ipadm_set_ifprop_flags,
78 i_ipadm_set_metric, i_ipadm_set_usesrc,
79 i_ipadm_set_forwarding, i_ipadm_set_eprivport,
80 i_ipadm_set_ecnsack, i_ipadm_set_hostmodel;
81
82 /* array of protocols we support */
83 static int protocols[] = { MOD_PROTO_IP, MOD_PROTO_RAWIP,
84 MOD_PROTO_TCP, MOD_PROTO_UDP,
85 MOD_PROTO_SCTP };
86
87 /*
88 * Supported IP protocol properties.
89 */
90 static ipadm_prop_desc_t ipadm_ip_prop_table[] = {
91 { "arp", IPADMPROP_CLASS_IF, MOD_PROTO_IPV4, 0,
92 i_ipadm_set_ifprop_flags, i_ipadm_get_onoff,
93 i_ipadm_get_ifprop_flags },
94
95 { "forwarding", IPADMPROP_CLASS_MODIF, MOD_PROTO_IPV4, 0,
96 i_ipadm_set_forwarding, i_ipadm_get_onoff,
97 i_ipadm_get_forwarding },
98
99 { "metric", IPADMPROP_CLASS_IF, MOD_PROTO_IPV4, 0,
100 i_ipadm_set_metric, NULL, i_ipadm_get_metric },
101
102 { "mtu", IPADMPROP_CLASS_IF, MOD_PROTO_IPV4, 0,
103 i_ipadm_set_mtu, i_ipadm_get_mtu, i_ipadm_get_mtu },
104
105 { "exchange_routes", IPADMPROP_CLASS_IF, MOD_PROTO_IPV4, 0,
106 i_ipadm_set_ifprop_flags, i_ipadm_get_onoff,
107 i_ipadm_get_ifprop_flags },
108
109 { "usesrc", IPADMPROP_CLASS_IF, MOD_PROTO_IPV4, 0,
110 i_ipadm_set_usesrc, NULL, i_ipadm_get_usesrc },
111
112 { "ttl", IPADMPROP_CLASS_MODULE, MOD_PROTO_IPV4, 0,
113 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
114
115 { "forwarding", IPADMPROP_CLASS_MODIF, MOD_PROTO_IPV6, 0,
116 i_ipadm_set_forwarding, i_ipadm_get_onoff,
117 i_ipadm_get_forwarding },
118
119 { "hoplimit", IPADMPROP_CLASS_MODULE, MOD_PROTO_IPV6, 0,
120 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
121
122 { "metric", IPADMPROP_CLASS_IF, MOD_PROTO_IPV6, 0,
123 i_ipadm_set_metric, NULL, i_ipadm_get_metric },
124
125 { "mtu", IPADMPROP_CLASS_IF, MOD_PROTO_IPV6, 0,
126 i_ipadm_set_mtu, i_ipadm_get_mtu, i_ipadm_get_mtu },
127
128 { "nud", IPADMPROP_CLASS_IF, MOD_PROTO_IPV6, 0,
129 i_ipadm_set_ifprop_flags, i_ipadm_get_onoff,
130 i_ipadm_get_ifprop_flags },
131
132 { "exchange_routes", IPADMPROP_CLASS_IF, MOD_PROTO_IPV6, 0,
133 i_ipadm_set_ifprop_flags, i_ipadm_get_onoff,
134 i_ipadm_get_ifprop_flags },
135
136 { "usesrc", IPADMPROP_CLASS_IF, MOD_PROTO_IPV6, 0,
137 i_ipadm_set_usesrc, NULL, i_ipadm_get_usesrc },
138
139 { "hostmodel", IPADMPROP_CLASS_MODULE, MOD_PROTO_IPV6, 0,
140 i_ipadm_set_hostmodel, i_ipadm_get_hostmodel,
141 i_ipadm_get_hostmodel },
142
143 { "hostmodel", IPADMPROP_CLASS_MODULE, MOD_PROTO_IPV4, 0,
144 i_ipadm_set_hostmodel, i_ipadm_get_hostmodel,
145 i_ipadm_get_hostmodel },
146
147 { NULL, 0, 0, 0, NULL, NULL, NULL }
148 };
149
150 /* possible values for TCP properties `ecn' and `sack' */
151 static const char *ecn_sack_vals[] = {"never", "passive", "active", NULL};
152
153 /* Supported TCP protocol properties */
154 static ipadm_prop_desc_t ipadm_tcp_prop_table[] = {
155 { "ecn", IPADMPROP_CLASS_MODULE, MOD_PROTO_TCP, 0,
156 i_ipadm_set_ecnsack, i_ipadm_get_ecnsack, i_ipadm_get_ecnsack },
157
158 { "extra_priv_ports", IPADMPROP_CLASS_MODULE, MOD_PROTO_TCP,
159 IPADMPROP_MULVAL, i_ipadm_set_eprivport, i_ipadm_get_prop,
160 i_ipadm_get_prop },
161
162 { "largest_anon_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_TCP, 0,
163 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
164
165 { "recv_maxbuf", IPADMPROP_CLASS_MODULE, MOD_PROTO_TCP, 0,
166 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
167
168 { "sack", IPADMPROP_CLASS_MODULE, MOD_PROTO_TCP, 0,
169 i_ipadm_set_ecnsack, i_ipadm_get_ecnsack, i_ipadm_get_ecnsack },
170
171 { "send_maxbuf", IPADMPROP_CLASS_MODULE, MOD_PROTO_TCP, 0,
172 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
173
174 { "smallest_anon_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_TCP, 0,
175 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
176
177 { "smallest_nonpriv_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_TCP, 0,
178 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
179
180 { NULL, 0, 0, 0, NULL, NULL, NULL }
181 };
182
183 /* Supported UDP protocol properties */
184 static ipadm_prop_desc_t ipadm_udp_prop_table[] = {
185 { "extra_priv_ports", IPADMPROP_CLASS_MODULE, MOD_PROTO_UDP,
186 IPADMPROP_MULVAL, i_ipadm_set_eprivport, i_ipadm_get_prop,
187 i_ipadm_get_prop },
188
189 { "largest_anon_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_UDP, 0,
190 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
191
192 { "recv_maxbuf", IPADMPROP_CLASS_MODULE, MOD_PROTO_UDP, 0,
193 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
194
195 { "send_maxbuf", IPADMPROP_CLASS_MODULE, MOD_PROTO_UDP, 0,
196 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
197
198 { "smallest_anon_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_UDP, 0,
199 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
200
201 { "smallest_nonpriv_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_UDP, 0,
202 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
203
204 { NULL, 0, 0, 0, NULL, NULL, NULL }
205 };
206
207 /* Supported SCTP protocol properties */
208 static ipadm_prop_desc_t ipadm_sctp_prop_table[] = {
209 { "extra_priv_ports", IPADMPROP_CLASS_MODULE, MOD_PROTO_SCTP,
210 IPADMPROP_MULVAL, i_ipadm_set_eprivport, i_ipadm_get_prop,
211 i_ipadm_get_prop },
212
213 { "largest_anon_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_SCTP, 0,
214 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
215
216 { "recv_maxbuf", IPADMPROP_CLASS_MODULE, MOD_PROTO_SCTP, 0,
217 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
218
219 { "send_maxbuf", IPADMPROP_CLASS_MODULE, MOD_PROTO_SCTP, 0,
220 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
221
222 { "smallest_anon_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_SCTP, 0,
223 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
224
225 { "smallest_nonpriv_port", IPADMPROP_CLASS_MODULE, MOD_PROTO_SCTP, 0,
226 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
227
228 { NULL, 0, 0, 0, NULL, NULL, NULL }
229 };
230
231 /* Supported ICMP protocol properties */
232 static ipadm_prop_desc_t ipadm_icmp_prop_table[] = {
233 { "recv_maxbuf", IPADMPROP_CLASS_MODULE, MOD_PROTO_RAWIP, 0,
234 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
235
236 { "send_maxbuf", IPADMPROP_CLASS_MODULE, MOD_PROTO_RAWIP, 0,
237 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop },
238
239 { NULL, 0, 0, 0, NULL, NULL, NULL }
240 };
241
242 /*
243 * A dummy private property structure, used while handling private
244 * protocol properties (properties not yet supported by libipadm).
245 */
246 static ipadm_prop_desc_t ipadm_privprop =\
247 { NULL, IPADMPROP_CLASS_MODULE, MOD_PROTO_NONE, 0,
248 i_ipadm_set_prop, i_ipadm_get_prop, i_ipadm_get_prop };
249
250 /*
251 * Returns the property description table, for the given protocol
252 */
253 static ipadm_prop_desc_t *
254 i_ipadm_get_propdesc_table(uint_t proto)
255 {
256 switch (proto) {
257 case MOD_PROTO_IP:
258 case MOD_PROTO_IPV4:
259 case MOD_PROTO_IPV6:
260 return (ipadm_ip_prop_table);
261 case MOD_PROTO_RAWIP:
262 return (ipadm_icmp_prop_table);
263 case MOD_PROTO_TCP:
264 return (ipadm_tcp_prop_table);
265 case MOD_PROTO_UDP:
266 return (ipadm_udp_prop_table);
267 case MOD_PROTO_SCTP:
268 return (ipadm_sctp_prop_table);
269 }
270
271 return (NULL);
272 }
273
274 static ipadm_prop_desc_t *
275 i_ipadm_get_prop_desc(const char *pname, uint_t proto, int *errp)
276 {
277 int err = 0;
278 boolean_t matched_name = B_FALSE;
279 ipadm_prop_desc_t *ipdp = NULL, *ipdtbl;
280
281 if ((ipdtbl = i_ipadm_get_propdesc_table(proto)) == NULL) {
282 err = EINVAL;
283 goto ret;
284 }
285 for (ipdp = ipdtbl; ipdp->ipd_name != NULL; ipdp++) {
286 if (strcmp(pname, ipdp->ipd_name) == 0) {
287 matched_name = B_TRUE;
288 if (ipdp->ipd_proto == proto)
289 break;
290 }
291 }
292 if (ipdp->ipd_name == NULL) {
293 err = ENOENT;
294 /* if we matched name, but failed protocol check */
295 if (matched_name)
296 err = EPROTO;
297 ipdp = NULL;
298 }
299 ret:
300 if (errp != NULL)
301 *errp = err;
302 return (ipdp);
303 }
304
305 char *
306 ipadm_proto2str(uint_t proto)
307 {
308 switch (proto) {
309 case MOD_PROTO_IP:
310 return ("ip");
311 case MOD_PROTO_IPV4:
312 return ("ipv4");
313 case MOD_PROTO_IPV6:
314 return ("ipv6");
315 case MOD_PROTO_RAWIP:
316 return ("icmp");
317 case MOD_PROTO_TCP:
318 return ("tcp");
319 case MOD_PROTO_UDP:
320 return ("udp");
321 case MOD_PROTO_SCTP:
322 return ("sctp");
323 }
324
325 return (NULL);
326 }
327
328 uint_t
329 ipadm_str2proto(const char *protostr)
330 {
331 if (protostr == NULL)
332 return (MOD_PROTO_NONE);
333 if (strcmp(protostr, "tcp") == 0)
334 return (MOD_PROTO_TCP);
335 else if (strcmp(protostr, "udp") == 0)
336 return (MOD_PROTO_UDP);
337 else if (strcmp(protostr, "ip") == 0)
338 return (MOD_PROTO_IP);
339 else if (strcmp(protostr, "ipv4") == 0)
340 return (MOD_PROTO_IPV4);
341 else if (strcmp(protostr, "ipv6") == 0)
342 return (MOD_PROTO_IPV6);
343 else if (strcmp(protostr, "icmp") == 0)
344 return (MOD_PROTO_RAWIP);
345 else if (strcmp(protostr, "sctp") == 0)
346 return (MOD_PROTO_SCTP);
347 else if (strcmp(protostr, "arp") == 0)
348 return (MOD_PROTO_IP);
349
350 return (MOD_PROTO_NONE);
351 }
352
353 /* ARGSUSED */
354 static ipadm_status_t
355 i_ipadm_set_mtu(ipadm_handle_t iph, const void *arg,
356 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
357 {
358 struct lifreq lifr;
359 char *endp;
360 uint_t mtu;
361 int s;
362 const char *ifname = arg;
363 char val[MAXPROPVALLEN];
364
365 /* to reset MTU first retrieve the default MTU and then set it */
366 if (flags & IPADM_OPT_DEFAULT) {
367 ipadm_status_t status;
368 uint_t size = MAXPROPVALLEN;
369
370 status = i_ipadm_get_prop(iph, arg, pdp, val, &size,
371 proto, MOD_PROP_DEFAULT);
372 if (status != IPADM_SUCCESS)
373 return (status);
374 pval = val;
375 }
376
377 errno = 0;
378 mtu = (uint_t)strtol(pval, &endp, 10);
379 if (errno != 0 || *endp != '\0')
380 return (IPADM_INVALID_ARG);
381
382 bzero(&lifr, sizeof (lifr));
383 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
384 lifr.lifr_mtu = mtu;
385
386 s = (proto == MOD_PROTO_IPV6 ? iph->iph_sock6 : iph->iph_sock);
387 if (ioctl(s, SIOCSLIFMTU, (caddr_t)&lifr) < 0)
388 return (ipadm_errno2status(errno));
389
390 return (IPADM_SUCCESS);
391 }
392
393 /* ARGSUSED */
394 static ipadm_status_t
395 i_ipadm_set_metric(ipadm_handle_t iph, const void *arg,
396 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
397 {
398 struct lifreq lifr;
399 char *endp;
400 int metric;
401 const char *ifname = arg;
402 int s;
403
404 /* if we are resetting, set the value to its default value */
405 if (flags & IPADM_OPT_DEFAULT) {
406 metric = DEF_METRIC_VAL;
407 } else {
408 errno = 0;
409 metric = (uint_t)strtol(pval, &endp, 10);
410 if (errno != 0 || *endp != '\0')
411 return (IPADM_INVALID_ARG);
412 }
413
414 bzero(&lifr, sizeof (lifr));
415 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
416 lifr.lifr_metric = metric;
417
418 s = (proto == MOD_PROTO_IPV6 ? iph->iph_sock6 : iph->iph_sock);
419
420 if (ioctl(s, SIOCSLIFMETRIC, (caddr_t)&lifr) < 0)
421 return (ipadm_errno2status(errno));
422
423 return (IPADM_SUCCESS);
424 }
425
426 /* ARGSUSED */
427 static ipadm_status_t
428 i_ipadm_set_usesrc(ipadm_handle_t iph, const void *arg,
429 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
430 {
431 struct lifreq lifr;
432 const char *ifname = arg;
433 int s;
434 uint_t ifindex = 0;
435
436 /* if we are resetting, set the value to its default value */
437 if (flags & IPADM_OPT_DEFAULT)
438 pval = IPADM_NONESTR;
439
440 /*
441 * cannot specify logical interface name. We can also filter out other
442 * bogus interface names here itself through i_ipadm_validate_ifname().
443 */
444 if (strcmp(pval, IPADM_NONESTR) != 0 &&
445 !i_ipadm_validate_ifname(iph, pval))
446 return (IPADM_INVALID_ARG);
447
448 bzero(&lifr, sizeof (lifr));
449 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
450
451 s = (proto == MOD_PROTO_IPV6 ? iph->iph_sock6 : iph->iph_sock);
452
453 if (strcmp(pval, IPADM_NONESTR) != 0) {
454 if ((ifindex = if_nametoindex(pval)) == 0)
455 return (ipadm_errno2status(errno));
456 lifr.lifr_index = ifindex;
457 } else {
458 if (ioctl(s, SIOCGLIFUSESRC, (caddr_t)&lifr) < 0)
459 return (ipadm_errno2status(errno));
460 lifr.lifr_index = 0;
461 }
462 if (ioctl(s, SIOCSLIFUSESRC, (caddr_t)&lifr) < 0)
463 return (ipadm_errno2status(errno));
464
465 return (IPADM_SUCCESS);
466 }
467
468 static struct hostmodel_strval {
469 char *esm_str;
470 ip_hostmodel_t esm_val;
471 } esm_arr[] = {
472 {"weak", IP_WEAK_ES},
473 {"src-priority", IP_SRC_PRI_ES},
474 {"strong", IP_STRONG_ES},
475 {"custom", IP_MAXVAL_ES}
476 };
477
478 static ip_hostmodel_t
479 i_ipadm_hostmodel_str2val(const char *pval)
480 {
481 int i;
482
483 for (i = 0; i < A_CNT(esm_arr); i++) {
484 if (esm_arr[i].esm_str != NULL &&
485 strcmp(pval, esm_arr[i].esm_str) == 0) {
486 return (esm_arr[i].esm_val);
487 }
488 }
489 return (IP_MAXVAL_ES);
490 }
491
492 static char *
493 i_ipadm_hostmodel_val2str(ip_hostmodel_t pval)
494 {
495 int i;
496
497 for (i = 0; i < A_CNT(esm_arr); i++) {
498 if (esm_arr[i].esm_val == pval)
499 return (esm_arr[i].esm_str);
500 }
501 return (NULL);
502 }
503
504 /* ARGSUSED */
505 static ipadm_status_t
506 i_ipadm_set_hostmodel(ipadm_handle_t iph, const void *arg,
507 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
508 {
509 ip_hostmodel_t hostmodel;
510 char val[11]; /* covers uint32_max as a string */
511
512 if ((flags & IPADM_OPT_DEFAULT) == 0) {
513 hostmodel = i_ipadm_hostmodel_str2val(pval);
514 if (hostmodel == IP_MAXVAL_ES)
515 return (IPADM_INVALID_ARG);
516 (void) snprintf(val, sizeof (val), "%d", hostmodel);
517 pval = val;
518 }
519 return (i_ipadm_set_prop(iph, NULL, pdp, pval, proto, flags));
520 }
521
522 /* ARGSUSED */
523 static ipadm_status_t
524 i_ipadm_get_hostmodel(ipadm_handle_t iph, const void *arg,
525 ipadm_prop_desc_t *pdp, char *buf, uint_t *bufsize, uint_t proto,
526 uint_t valtype)
527 {
528 ip_hostmodel_t hostmodel;
529 char *cp;
530 size_t nbytes;
531 ipadm_status_t status;
532
533 switch (valtype) {
534 case MOD_PROP_PERM:
535 nbytes = snprintf(buf, *bufsize, "%d", MOD_PROP_PERM_RW);
536 break;
537 case MOD_PROP_DEFAULT:
538 nbytes = snprintf(buf, *bufsize, "weak");
539 break;
540 case MOD_PROP_ACTIVE:
541 status = i_ipadm_get_prop(iph, arg, pdp, buf, bufsize, proto,
542 valtype);
543 if (status != IPADM_SUCCESS)
544 return (status);
545 bcopy(buf, &hostmodel, sizeof (hostmodel));
546 cp = i_ipadm_hostmodel_val2str(hostmodel);
547 nbytes = snprintf(buf, *bufsize, "%s",
548 (cp != NULL ? cp : "?"));
549 break;
550 case MOD_PROP_POSSIBLE:
551 nbytes = snprintf(buf, *bufsize, "strong,src-priority,weak");
552 break;
553 default:
554 return (IPADM_INVALID_ARG);
555 }
556 if (nbytes >= *bufsize) {
557 /* insufficient buffer space */
558 *bufsize = nbytes + 1;
559 return (IPADM_NO_BUFS);
560 }
561 return (IPADM_SUCCESS);
562 }
563
564 /* ARGSUSED */
565 static ipadm_status_t
566 i_ipadm_set_ifprop_flags(ipadm_handle_t iph, const void *arg,
567 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
568 {
569 ipadm_status_t status = IPADM_SUCCESS;
570 const char *ifname = arg;
571 uint64_t on_flags = 0, off_flags = 0;
572 boolean_t on = B_FALSE;
573 sa_family_t af = (proto == MOD_PROTO_IPV6 ? AF_INET6 : AF_INET);
574
575 /* if we are resetting, set the value to its default value */
576 if (flags & IPADM_OPT_DEFAULT) {
577 if (strcmp(pdp->ipd_name, "exchange_routes") == 0 ||
578 strcmp(pdp->ipd_name, "arp") == 0 ||
579 strcmp(pdp->ipd_name, "nud") == 0) {
580 pval = IPADM_ONSTR;
581 } else if (strcmp(pdp->ipd_name, "forwarding") == 0) {
582 pval = IPADM_OFFSTR;
583 } else {
584 return (IPADM_PROP_UNKNOWN);
585 }
586 }
587
588 if (strcmp(pval, IPADM_ONSTR) == 0)
589 on = B_TRUE;
590 else if (strcmp(pval, IPADM_OFFSTR) == 0)
591 on = B_FALSE;
592 else
593 return (IPADM_INVALID_ARG);
594
595 if (strcmp(pdp->ipd_name, "exchange_routes") == 0) {
596 if (on)
597 off_flags = IFF_NORTEXCH;
598 else
599 on_flags = IFF_NORTEXCH;
600 } else if (strcmp(pdp->ipd_name, "arp") == 0) {
601 if (on)
602 off_flags = IFF_NOARP;
603 else
604 on_flags = IFF_NOARP;
605 } else if (strcmp(pdp->ipd_name, "nud") == 0) {
606 if (on)
607 off_flags = IFF_NONUD;
608 else
609 on_flags = IFF_NONUD;
610 } else if (strcmp(pdp->ipd_name, "forwarding") == 0) {
611 if (on)
612 on_flags = IFF_ROUTER;
613 else
614 off_flags = IFF_ROUTER;
615 }
616
617 if (on_flags || off_flags) {
618 status = i_ipadm_set_flags(iph, ifname, af, on_flags,
619 off_flags);
620 }
621 return (status);
622 }
623
624 /* ARGSUSED */
625 static ipadm_status_t
626 i_ipadm_set_eprivport(ipadm_handle_t iph, const void *arg,
627 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
628 {
629 nvlist_t *portsnvl = NULL;
630 nvpair_t *nvp;
631 ipadm_status_t status = IPADM_SUCCESS;
632 int err;
633 uint_t count = 0;
634
635 if (flags & IPADM_OPT_DEFAULT) {
636 assert(pval == NULL);
637 return (i_ipadm_set_prop(iph, arg, pdp, pval, proto, flags));
638 }
639
640 if ((err = ipadm_str2nvlist(pval, &portsnvl, IPADM_NORVAL)) != 0)
641 return (ipadm_errno2status(err));
642
643 /* count the number of ports */
644 for (nvp = nvlist_next_nvpair(portsnvl, NULL); nvp != NULL;
645 nvp = nvlist_next_nvpair(portsnvl, nvp)) {
646 ++count;
647 }
648
649 if (iph->iph_flags & IPH_INIT) {
650 flags |= IPADM_OPT_APPEND;
651 } else if (count > 1) {
652 /*
653 * We allow only one port to be added, removed or
654 * assigned at a time.
655 *
656 * However on reboot, while initializing protocol
657 * properties, extra_priv_ports might have multiple
658 * values. Only in that case we allow setting multiple
659 * values.
660 */
661 nvlist_free(portsnvl);
662 return (IPADM_INVALID_ARG);
663 }
664
665 for (nvp = nvlist_next_nvpair(portsnvl, NULL); nvp != NULL;
666 nvp = nvlist_next_nvpair(portsnvl, nvp)) {
667 status = i_ipadm_set_prop(iph, arg, pdp, nvpair_name(nvp),
668 proto, flags);
669 if (status != IPADM_SUCCESS)
670 break;
671 }
672 nvlist_free(portsnvl);
673 return (status);
674 }
675
676 /* ARGSUSED */
677 static ipadm_status_t
678 i_ipadm_set_forwarding(ipadm_handle_t iph, const void *arg,
679 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
680 {
681 const char *ifname = arg;
682 ipadm_status_t status;
683
684 /*
685 * if interface name is provided, then set forwarding using the
686 * IFF_ROUTER flag
687 */
688 if (ifname != NULL) {
689 status = i_ipadm_set_ifprop_flags(iph, ifname, pdp, pval,
690 proto, flags);
691 } else {
692 char *val = NULL;
693
694 /*
695 * if the caller is IPH_LEGACY, `pval' already contains
696 * numeric values.
697 */
698 if (!(flags & IPADM_OPT_DEFAULT) &&
699 !(iph->iph_flags & IPH_LEGACY)) {
700
701 if (strcmp(pval, IPADM_ONSTR) == 0)
702 val = "1";
703 else if (strcmp(pval, IPADM_OFFSTR) == 0)
704 val = "0";
705 else
706 return (IPADM_INVALID_ARG);
707 pval = val;
708 }
709
710 status = i_ipadm_set_prop(iph, ifname, pdp, pval, proto, flags);
711 }
712
713 return (status);
714 }
715
716 /* ARGSUSED */
717 static ipadm_status_t
718 i_ipadm_set_ecnsack(ipadm_handle_t iph, const void *arg,
719 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
720 {
721 uint_t i;
722 char val[MAXPROPVALLEN];
723
724 /* if IPH_LEGACY is set, `pval' already contains numeric values */
725 if (!(flags & IPADM_OPT_DEFAULT) && !(iph->iph_flags & IPH_LEGACY)) {
726 for (i = 0; ecn_sack_vals[i] != NULL; i++) {
727 if (strcmp(pval, ecn_sack_vals[i]) == 0)
728 break;
729 }
730 if (ecn_sack_vals[i] == NULL)
731 return (IPADM_INVALID_ARG);
732 (void) snprintf(val, MAXPROPVALLEN, "%d", i);
733 pval = val;
734 }
735
736 return (i_ipadm_set_prop(iph, arg, pdp, pval, proto, flags));
737 }
738
739 /* ARGSUSED */
740 ipadm_status_t
741 i_ipadm_get_ecnsack(ipadm_handle_t iph, const void *arg,
742 ipadm_prop_desc_t *pdp, char *buf, uint_t *bufsize, uint_t proto,
743 uint_t valtype)
744 {
745 ipadm_status_t status = IPADM_SUCCESS;
746 uint_t i, nbytes = 0;
747
748 switch (valtype) {
749 case MOD_PROP_POSSIBLE:
750 for (i = 0; ecn_sack_vals[i] != NULL; i++) {
751 if (i == 0)
752 nbytes += snprintf(buf + nbytes,
753 *bufsize - nbytes, "%s", ecn_sack_vals[i]);
754 else
755 nbytes += snprintf(buf + nbytes,
756 *bufsize - nbytes, ",%s", ecn_sack_vals[i]);
757 if (nbytes >= *bufsize)
758 break;
759 }
760 break;
761 case MOD_PROP_PERM:
762 case MOD_PROP_DEFAULT:
763 case MOD_PROP_ACTIVE:
764 status = i_ipadm_get_prop(iph, arg, pdp, buf, bufsize, proto,
765 valtype);
766
767 /*
768 * If IPH_LEGACY is set, do not convert the value returned
769 * from kernel,
770 */
771 if (iph->iph_flags & IPH_LEGACY)
772 break;
773
774 /*
775 * For current and default value, convert the value returned
776 * from kernel to more discrete representation.
777 */
778 if (status == IPADM_SUCCESS && (valtype == MOD_PROP_ACTIVE ||
779 valtype == MOD_PROP_DEFAULT)) {
780 i = atoi(buf);
781 assert(i < 3);
782 nbytes = snprintf(buf, *bufsize, "%s",
783 ecn_sack_vals[i]);
784 }
785 break;
786 default:
787 return (IPADM_INVALID_ARG);
788 }
789 if (nbytes >= *bufsize) {
790 /* insufficient buffer space */
791 *bufsize = nbytes + 1;
792 return (IPADM_NO_BUFS);
793 }
794
795 return (status);
796 }
797
798 /* ARGSUSED */
799 static ipadm_status_t
800 i_ipadm_get_forwarding(ipadm_handle_t iph, const void *arg,
801 ipadm_prop_desc_t *pdp, char *buf, uint_t *bufsize, uint_t proto,
802 uint_t valtype)
803 {
804 const char *ifname = arg;
805 ipadm_status_t status = IPADM_SUCCESS;
806
807 /*
808 * if interface name is provided, then get forwarding status using
809 * SIOCGLIFFLAGS
810 */
811 if (ifname != NULL) {
812 status = i_ipadm_get_ifprop_flags(iph, ifname, pdp,
813 buf, bufsize, pdp->ipd_proto, valtype);
814 } else {
815 status = i_ipadm_get_prop(iph, ifname, pdp, buf,
816 bufsize, proto, valtype);
817 /*
818 * If IPH_LEGACY is set, do not convert the value returned
819 * from kernel,
820 */
821 if (iph->iph_flags & IPH_LEGACY)
822 goto ret;
823 if (status == IPADM_SUCCESS && (valtype == MOD_PROP_ACTIVE ||
824 valtype == MOD_PROP_DEFAULT)) {
825 uint_t val = atoi(buf);
826
827 (void) snprintf(buf, *bufsize,
828 (val == 1 ? IPADM_ONSTR : IPADM_OFFSTR));
829 }
830 }
831
832 ret:
833 return (status);
834 }
835
836 /* ARGSUSED */
837 static ipadm_status_t
838 i_ipadm_get_mtu(ipadm_handle_t iph, const void *arg,
839 ipadm_prop_desc_t *pdp, char *buf, uint_t *bufsize, uint_t proto,
840 uint_t valtype)
841 {
842 struct lifreq lifr;
843 const char *ifname = arg;
844 size_t nbytes;
845 int s;
846
847 switch (valtype) {
848 case MOD_PROP_PERM:
849 nbytes = snprintf(buf, *bufsize, "%d", MOD_PROP_PERM_RW);
850 break;
851 case MOD_PROP_DEFAULT:
852 case MOD_PROP_POSSIBLE:
853 return (i_ipadm_get_prop(iph, arg, pdp, buf, bufsize,
854 proto, valtype));
855 case MOD_PROP_ACTIVE:
856 bzero(&lifr, sizeof (lifr));
857 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
858 s = (proto == MOD_PROTO_IPV6 ? iph->iph_sock6 : iph->iph_sock);
859
860 if (ioctl(s, SIOCGLIFMTU, (caddr_t)&lifr) < 0)
861 return (ipadm_errno2status(errno));
862 nbytes = snprintf(buf, *bufsize, "%u", lifr.lifr_mtu);
863 break;
864 default:
865 return (IPADM_INVALID_ARG);
866 }
867 if (nbytes >= *bufsize) {
868 /* insufficient buffer space */
869 *bufsize = nbytes + 1;
870 return (IPADM_NO_BUFS);
871 }
872 return (IPADM_SUCCESS);
873 }
874
875 /* ARGSUSED */
876 static ipadm_status_t
877 i_ipadm_get_metric(ipadm_handle_t iph, const void *arg,
878 ipadm_prop_desc_t *pdp, char *buf, uint_t *bufsize, uint_t proto,
879 uint_t valtype)
880 {
881 struct lifreq lifr;
882 const char *ifname = arg;
883 size_t nbytes;
884 int s, val;
885
886 switch (valtype) {
887 case MOD_PROP_PERM:
888 val = MOD_PROP_PERM_RW;
889 break;
890 case MOD_PROP_DEFAULT:
891 val = DEF_METRIC_VAL;
892 break;
893 case MOD_PROP_ACTIVE:
894 bzero(&lifr, sizeof (lifr));
895 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
896
897 s = (proto == MOD_PROTO_IPV6 ? iph->iph_sock6 : iph->iph_sock);
898 if (ioctl(s, SIOCGLIFMETRIC, (caddr_t)&lifr) < 0)
899 return (ipadm_errno2status(errno));
900 val = lifr.lifr_metric;
901 break;
902 default:
903 return (IPADM_INVALID_ARG);
904 }
905 nbytes = snprintf(buf, *bufsize, "%d", val);
906 if (nbytes >= *bufsize) {
907 /* insufficient buffer space */
908 *bufsize = nbytes + 1;
909 return (IPADM_NO_BUFS);
910 }
911
912 return (IPADM_SUCCESS);
913 }
914
915 /* ARGSUSED */
916 static ipadm_status_t
917 i_ipadm_get_usesrc(ipadm_handle_t iph, const void *arg,
918 ipadm_prop_desc_t *ipd, char *buf, uint_t *bufsize, uint_t proto,
919 uint_t valtype)
920 {
921 struct lifreq lifr;
922 const char *ifname = arg;
923 int s;
924 char if_name[IF_NAMESIZE];
925 size_t nbytes;
926
927 switch (valtype) {
928 case MOD_PROP_PERM:
929 nbytes = snprintf(buf, *bufsize, "%d", MOD_PROP_PERM_RW);
930 break;
931 case MOD_PROP_DEFAULT:
932 nbytes = snprintf(buf, *bufsize, "%s", IPADM_NONESTR);
933 break;
934 case MOD_PROP_ACTIVE:
935 bzero(&lifr, sizeof (lifr));
936 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
937
938 s = (proto == MOD_PROTO_IPV6 ? iph->iph_sock6 : iph->iph_sock);
939 if (ioctl(s, SIOCGLIFUSESRC, (caddr_t)&lifr) < 0)
940 return (ipadm_errno2status(errno));
941 if (lifr.lifr_index == 0) {
942 /* no src address was set, so print 'none' */
943 (void) strlcpy(if_name, IPADM_NONESTR,
944 sizeof (if_name));
945 } else if (if_indextoname(lifr.lifr_index, if_name) == NULL) {
946 return (ipadm_errno2status(errno));
947 }
948 nbytes = snprintf(buf, *bufsize, "%s", if_name);
949 break;
950 default:
951 return (IPADM_INVALID_ARG);
952 }
953 if (nbytes >= *bufsize) {
954 /* insufficient buffer space */
955 *bufsize = nbytes + 1;
956 return (IPADM_NO_BUFS);
957 }
958 return (IPADM_SUCCESS);
959 }
960
961 /* ARGSUSED */
962 static ipadm_status_t
963 i_ipadm_get_ifprop_flags(ipadm_handle_t iph, const void *arg,
964 ipadm_prop_desc_t *pdp, char *buf, uint_t *bufsize, uint_t proto,
965 uint_t valtype)
966 {
967 uint64_t intf_flags;
968 char *val;
969 size_t nbytes;
970 const char *ifname = arg;
971 sa_family_t af;
972 ipadm_status_t status = IPADM_SUCCESS;
973
974 switch (valtype) {
975 case MOD_PROP_PERM:
976 nbytes = snprintf(buf, *bufsize, "%d", MOD_PROP_PERM_RW);
977 break;
978 case MOD_PROP_DEFAULT:
979 if (strcmp(pdp->ipd_name, "exchange_routes") == 0 ||
980 strcmp(pdp->ipd_name, "arp") == 0 ||
981 strcmp(pdp->ipd_name, "nud") == 0) {
982 val = IPADM_ONSTR;
983 } else if (strcmp(pdp->ipd_name, "forwarding") == 0) {
984 val = IPADM_OFFSTR;
985 } else {
986 return (IPADM_PROP_UNKNOWN);
987 }
988 nbytes = snprintf(buf, *bufsize, "%s", val);
989 break;
990 case MOD_PROP_ACTIVE:
991 af = (proto == MOD_PROTO_IPV6 ? AF_INET6 : AF_INET);
992 status = i_ipadm_get_flags(iph, ifname, af, &intf_flags);
993 if (status != IPADM_SUCCESS)
994 return (status);
995
996 val = IPADM_OFFSTR;
997 if (strcmp(pdp->ipd_name, "exchange_routes") == 0) {
998 if (!(intf_flags & IFF_NORTEXCH))
999 val = IPADM_ONSTR;
1000 } else if (strcmp(pdp->ipd_name, "forwarding") == 0) {
1001 if (intf_flags & IFF_ROUTER)
1002 val = IPADM_ONSTR;
1003 } else if (strcmp(pdp->ipd_name, "arp") == 0) {
1004 if (!(intf_flags & IFF_NOARP))
1005 val = IPADM_ONSTR;
1006 } else if (strcmp(pdp->ipd_name, "nud") == 0) {
1007 if (!(intf_flags & IFF_NONUD))
1008 val = IPADM_ONSTR;
1009 }
1010 nbytes = snprintf(buf, *bufsize, "%s", val);
1011 break;
1012 default:
1013 return (IPADM_INVALID_ARG);
1014 }
1015 if (nbytes >= *bufsize) {
1016 /* insufficient buffer space */
1017 *bufsize = nbytes + 1;
1018 status = IPADM_NO_BUFS;
1019 }
1020
1021 return (status);
1022 }
1023
1024 static void
1025 i_ipadm_perm2str(char *buf, uint_t *bufsize)
1026 {
1027 uint_t perm = atoi(buf);
1028
1029 (void) snprintf(buf, *bufsize, "%c%c",
1030 ((perm & MOD_PROP_PERM_READ) != 0) ? 'r' : '-',
1031 ((perm & MOD_PROP_PERM_WRITE) != 0) ? 'w' : '-');
1032 }
1033
1034 /* ARGSUSED */
1035 static ipadm_status_t
1036 i_ipadm_get_prop(ipadm_handle_t iph, const void *arg,
1037 ipadm_prop_desc_t *pdp, char *buf, uint_t *bufsize, uint_t proto,
1038 uint_t valtype)
1039 {
1040 ipadm_status_t status = IPADM_SUCCESS;
1041 const char *ifname = arg;
1042 mod_ioc_prop_t *mip;
1043 char *pname = pdp->ipd_name;
1044 uint_t iocsize;
1045
1046 /* allocate sufficient ioctl buffer to retrieve value */
1047 iocsize = sizeof (mod_ioc_prop_t) + *bufsize - 1;
1048 if ((mip = calloc(1, iocsize)) == NULL)
1049 return (IPADM_NO_BUFS);
1050
1051 mip->mpr_version = MOD_PROP_VERSION;
1052 mip->mpr_flags = valtype;
1053 mip->mpr_proto = proto;
1054 if (ifname != NULL) {
1055 (void) strlcpy(mip->mpr_ifname, ifname,
1056 sizeof (mip->mpr_ifname));
1057 }
1058 (void) strlcpy(mip->mpr_name, pname, sizeof (mip->mpr_name));
1059 mip->mpr_valsize = *bufsize;
1060
1061 if (i_ipadm_strioctl(iph->iph_sock, SIOCGETPROP, (char *)mip,
1062 iocsize) < 0) {
1063 if (errno == ENOENT)
1064 status = IPADM_PROP_UNKNOWN;
1065 else
1066 status = ipadm_errno2status(errno);
1067 } else {
1068 bcopy(mip->mpr_val, buf, *bufsize);
1069 }
1070
1071 free(mip);
1072 return (status);
1073 }
1074
1075 /*
1076 * Populates the ipmgmt_prop_arg_t based on the class of property.
1077 *
1078 * For private protocol properties, while persisting information in ipadm
1079 * data store, to ensure there is no collision of namespace between ipadm
1080 * private nvpair names (which also starts with '_', see ipadm_ipmgmt.h)
1081 * and private protocol property names, we will prepend IPADM_PRIV_PROP_PREFIX
1082 * to property names.
1083 */
1084 static void
1085 i_ipadm_populate_proparg(ipmgmt_prop_arg_t *pargp, ipadm_prop_desc_t *pdp,
1086 const char *pval, const void *object)
1087 {
1088 const struct ipadm_addrobj_s *ipaddr;
1089 uint_t class = pdp->ipd_class;
1090 uint_t proto = pdp->ipd_proto;
1091
1092 (void) strlcpy(pargp->ia_pname, pdp->ipd_name,
1093 sizeof (pargp->ia_pname));
1094 if (pval != NULL)
1095 (void) strlcpy(pargp->ia_pval, pval, sizeof (pargp->ia_pval));
1096
1097 switch (class) {
1098 case IPADMPROP_CLASS_MODULE:
1099 /* if it's a private property then add the prefix. */
1100 if (pdp->ipd_name[0] == '_') {
1101 (void) snprintf(pargp->ia_pname,
1102 sizeof (pargp->ia_pname), "_%s", pdp->ipd_name);
1103 }
1104 (void) strlcpy(pargp->ia_module, object,
1105 sizeof (pargp->ia_module));
1106 break;
1107 case IPADMPROP_CLASS_MODIF:
1108 /* check if object is protostr or an ifname */
1109 if (ipadm_str2proto(object) != MOD_PROTO_NONE) {
1110 (void) strlcpy(pargp->ia_module, object,
1111 sizeof (pargp->ia_module));
1112 break;
1113 }
1114 /* it's an interface property, fall through */
1115 /* FALLTHRU */
1116 case IPADMPROP_CLASS_IF:
1117 (void) strlcpy(pargp->ia_ifname, object,
1118 sizeof (pargp->ia_ifname));
1119 (void) strlcpy(pargp->ia_module, ipadm_proto2str(proto),
1120 sizeof (pargp->ia_module));
1121 break;
1122 case IPADMPROP_CLASS_ADDR:
1123 ipaddr = object;
1124 (void) strlcpy(pargp->ia_ifname, ipaddr->ipadm_ifname,
1125 sizeof (pargp->ia_ifname));
1126 (void) strlcpy(pargp->ia_aobjname, ipaddr->ipadm_aobjname,
1127 sizeof (pargp->ia_aobjname));
1128 break;
1129 }
1130 }
1131
1132 /*
1133 * Common function to retrieve property value for a given interface `ifname' or
1134 * for a given protocol `proto'. The property name is in `pname'.
1135 *
1136 * `valtype' determines the type of value that will be retrieved.
1137 * IPADM_OPT_ACTIVE - current value of the property (active config)
1138 * IPADM_OPT_PERSIST - value of the property from persistent store
1139 * IPADM_OPT_DEFAULT - default hard coded value (boot-time value)
1140 * IPADM_OPT_PERM - read/write permissions for the value
1141 * IPADM_OPT_POSSIBLE - range of values
1142 */
1143 static ipadm_status_t
1144 i_ipadm_getprop_common(ipadm_handle_t iph, const char *ifname,
1145 const char *pname, char *buf, uint_t *bufsize, uint_t proto,
1146 uint_t valtype)
1147 {
1148 ipadm_status_t status = IPADM_SUCCESS;
1149 ipadm_prop_desc_t *pdp;
1150 char priv_propname[MAXPROPNAMELEN];
1151 boolean_t is_if = (ifname != NULL);
1152 int err = 0;
1153
1154 pdp = i_ipadm_get_prop_desc(pname, proto, &err);
1155 if (err == EPROTO)
1156 return (IPADM_BAD_PROTOCOL);
1157 /* there are no private interface properties */
1158 if (is_if && err == ENOENT)
1159 return (IPADM_PROP_UNKNOWN);
1160
1161 if (pdp != NULL) {
1162 /*
1163 * check whether the property can be
1164 * applied on an interface
1165 */
1166 if (is_if && !(pdp->ipd_class & IPADMPROP_CLASS_IF))
1167 return (IPADM_INVALID_ARG);
1168 /*
1169 * check whether the property can be
1170 * applied on a module
1171 */
1172 if (!is_if && !(pdp->ipd_class & IPADMPROP_CLASS_MODULE))
1173 return (IPADM_INVALID_ARG);
1174
1175 } else {
1176 /* private protocol properties, pass it to kernel directly */
1177 pdp = &ipadm_privprop;
1178 (void) strlcpy(priv_propname, pname, sizeof (priv_propname));
1179 pdp->ipd_name = priv_propname;
1180 }
1181
1182 switch (valtype) {
1183 case IPADM_OPT_PERM:
1184 status = pdp->ipd_get(iph, ifname, pdp, buf, bufsize, proto,
1185 MOD_PROP_PERM);
1186 if (status == IPADM_SUCCESS)
1187 i_ipadm_perm2str(buf, bufsize);
1188 break;
1189 case IPADM_OPT_ACTIVE:
1190 status = pdp->ipd_get(iph, ifname, pdp, buf, bufsize, proto,
1191 MOD_PROP_ACTIVE);
1192 break;
1193 case IPADM_OPT_DEFAULT:
1194 status = pdp->ipd_get(iph, ifname, pdp, buf, bufsize, proto,
1195 MOD_PROP_DEFAULT);
1196 break;
1197 case IPADM_OPT_POSSIBLE:
1198 if (pdp->ipd_get_range != NULL) {
1199 status = pdp->ipd_get_range(iph, ifname, pdp, buf,
1200 bufsize, proto, MOD_PROP_POSSIBLE);
1201 break;
1202 }
1203 buf[0] = '\0';
1204 break;
1205 case IPADM_OPT_PERSIST:
1206 /* retrieve from database */
1207 if (is_if)
1208 status = i_ipadm_get_persist_propval(iph, pdp, buf,
1209 bufsize, ifname);
1210 else
1211 status = i_ipadm_get_persist_propval(iph, pdp, buf,
1212 bufsize, ipadm_proto2str(proto));
1213 break;
1214 default:
1215 status = IPADM_INVALID_ARG;
1216 break;
1217 }
1218 return (status);
1219 }
1220
1221 /*
1222 * Get protocol property of the specified protocol.
1223 */
1224 ipadm_status_t
1225 ipadm_get_prop(ipadm_handle_t iph, const char *pname, char *buf,
1226 uint_t *bufsize, uint_t proto, uint_t valtype)
1227 {
1228 /*
1229 * validate the arguments of the function.
1230 */
1231 if (iph == NULL || pname == NULL || buf == NULL ||
1232 bufsize == NULL || *bufsize == 0) {
1233 return (IPADM_INVALID_ARG);
1234 }
1235 /*
1236 * Do we support this proto, if not return error.
1237 */
1238 if (ipadm_proto2str(proto) == NULL)
1239 return (IPADM_NOTSUP);
1240
1241 return (i_ipadm_getprop_common(iph, NULL, pname, buf, bufsize,
1242 proto, valtype));
1243 }
1244
1245 /*
1246 * Get interface property of the specified interface.
1247 */
1248 ipadm_status_t
1249 ipadm_get_ifprop(ipadm_handle_t iph, const char *ifname, const char *pname,
1250 char *buf, uint_t *bufsize, uint_t proto, uint_t valtype)
1251 {
1252 /* validate the arguments of the function. */
1253 if (iph == NULL || pname == NULL || buf == NULL ||
1254 bufsize == NULL || *bufsize == 0) {
1255 return (IPADM_INVALID_ARG);
1256 }
1257
1258 /* Do we support this proto, if not return error. */
1259 if (ipadm_proto2str(proto) == NULL)
1260 return (IPADM_NOTSUP);
1261
1262 /*
1263 * check if interface name is provided for interface property and
1264 * is valid.
1265 */
1266 if (!i_ipadm_validate_ifname(iph, ifname))
1267 return (IPADM_INVALID_ARG);
1268
1269 return (i_ipadm_getprop_common(iph, ifname, pname, buf, bufsize,
1270 proto, valtype));
1271 }
1272
1273 /*
1274 * Allocates sufficient ioctl buffers and copies property name and the
1275 * value, among other things. If the flag IPADM_OPT_DEFAULT is set, then
1276 * `pval' will be NULL and it instructs the kernel to reset the current
1277 * value to property's default value.
1278 */
1279 static ipadm_status_t
1280 i_ipadm_set_prop(ipadm_handle_t iph, const void *arg,
1281 ipadm_prop_desc_t *pdp, const void *pval, uint_t proto, uint_t flags)
1282 {
1283 ipadm_status_t status = IPADM_SUCCESS;
1284 const char *ifname = arg;
1285 mod_ioc_prop_t *mip;
1286 char *pname = pdp->ipd_name;
1287 uint_t valsize, iocsize;
1288 uint_t iocflags = 0;
1289
1290 if (flags & IPADM_OPT_DEFAULT) {
1291 iocflags |= MOD_PROP_DEFAULT;
1292 } else if (flags & IPADM_OPT_ACTIVE) {
1293 iocflags |= MOD_PROP_ACTIVE;
1294 if (flags & IPADM_OPT_APPEND)
1295 iocflags |= MOD_PROP_APPEND;
1296 else if (flags & IPADM_OPT_REMOVE)
1297 iocflags |= MOD_PROP_REMOVE;
1298 }
1299
1300 if (pval != NULL) {
1301 valsize = strlen(pval);
1302 iocsize = sizeof (mod_ioc_prop_t) + valsize - 1;
1303 } else {
1304 valsize = 0;
1305 iocsize = sizeof (mod_ioc_prop_t);
1306 }
1307
1308 if ((mip = calloc(1, iocsize)) == NULL)
1309 return (IPADM_NO_BUFS);
1310
1311 mip->mpr_version = MOD_PROP_VERSION;
1312 mip->mpr_flags = iocflags;
1313 mip->mpr_proto = proto;
1314 if (ifname != NULL) {
1315 (void) strlcpy(mip->mpr_ifname, ifname,
1316 sizeof (mip->mpr_ifname));
1317 }
1318
1319 (void) strlcpy(mip->mpr_name, pname, sizeof (mip->mpr_name));
1320 mip->mpr_valsize = valsize;
1321 if (pval != NULL)
1322 bcopy(pval, mip->mpr_val, valsize);
1323
1324 if (i_ipadm_strioctl(iph->iph_sock, SIOCSETPROP, (char *)mip,
1325 iocsize) < 0) {
1326 if (errno == ENOENT)
1327 status = IPADM_PROP_UNKNOWN;
1328 else
1329 status = ipadm_errno2status(errno);
1330 }
1331 free(mip);
1332 return (status);
1333 }
1334
1335 /*
1336 * Common function for modifying both protocol/interface property.
1337 *
1338 * If:
1339 * IPADM_OPT_PERSIST is set then the value is persisted.
1340 * IPADM_OPT_DEFAULT is set then the default value for the property will
1341 * be applied.
1342 */
1343 static ipadm_status_t
1344 i_ipadm_setprop_common(ipadm_handle_t iph, const char *ifname,
1345 const char *pname, const char *buf, uint_t proto, uint_t pflags)
1346 {
1347 ipadm_status_t status = IPADM_SUCCESS;
1348 boolean_t persist = (pflags & IPADM_OPT_PERSIST);
1349 boolean_t reset = (pflags & IPADM_OPT_DEFAULT);
1350 ipadm_prop_desc_t *pdp;
1351 boolean_t is_if = (ifname != NULL);
1352 char priv_propname[MAXPROPNAMELEN];
1353 int err = 0;
1354
1355 /* Check that property value is within the allowed size */
1356 if (!reset && strnlen(buf, MAXPROPVALLEN) >= MAXPROPVALLEN)
1357 return (IPADM_INVALID_ARG);
1358
1359 pdp = i_ipadm_get_prop_desc(pname, proto, &err);
1360 if (err == EPROTO)
1361 return (IPADM_BAD_PROTOCOL);
1362 /* there are no private interface properties */
1363 if (is_if && err == ENOENT)
1364 return (IPADM_PROP_UNKNOWN);
1365
1366 if (pdp != NULL) {
1367 /* do some sanity checks */
1368 if (is_if) {
1369 if (!(pdp->ipd_class & IPADMPROP_CLASS_IF))
1370 return (IPADM_INVALID_ARG);
1371 } else {
1372 if (!(pdp->ipd_class & IPADMPROP_CLASS_MODULE))
1373 return (IPADM_INVALID_ARG);
1374 }
1375 /*
1376 * if the property is not multi-valued and IPADM_OPT_APPEND or
1377 * IPADM_OPT_REMOVE is specified, return IPADM_INVALID_ARG.
1378 */
1379 if (!(pdp->ipd_flags & IPADMPROP_MULVAL) && (pflags &
1380 (IPADM_OPT_APPEND|IPADM_OPT_REMOVE))) {
1381 return (IPADM_INVALID_ARG);
1382 }
1383 } else {
1384 /* private protocol property, pass it to kernel directly */
1385 pdp = &ipadm_privprop;
1386 (void) strlcpy(priv_propname, pname, sizeof (priv_propname));
1387 pdp->ipd_name = priv_propname;
1388 }
1389
1390 status = pdp->ipd_set(iph, ifname, pdp, buf, proto, pflags);
1391 if (status != IPADM_SUCCESS)
1392 return (status);
1393
1394 if (persist) {
1395 if (is_if)
1396 status = i_ipadm_persist_propval(iph, pdp, buf, ifname,
1397 pflags);
1398 else
1399 status = i_ipadm_persist_propval(iph, pdp, buf,
1400 ipadm_proto2str(proto), pflags);
1401 }
1402 return (status);
1403 }
1404
1405 /*
1406 * Sets the property value of the specified interface
1407 */
1408 ipadm_status_t
1409 ipadm_set_ifprop(ipadm_handle_t iph, const char *ifname, const char *pname,
1410 const char *buf, uint_t proto, uint_t pflags)
1411 {
1412 boolean_t reset = (pflags & IPADM_OPT_DEFAULT);
1413 ipadm_status_t status;
1414
1415 /* check for solaris.network.interface.config authorization */
1416 if (!ipadm_check_auth())
1417 return (IPADM_EAUTH);
1418 /*
1419 * validate the arguments of the function.
1420 */
1421 if (iph == NULL || pname == NULL || (!reset && buf == NULL) ||
1422 pflags == 0 || pflags == IPADM_OPT_PERSIST ||
1423 (pflags & ~(IPADM_COMMON_OPT_MASK|IPADM_OPT_DEFAULT))) {
1424 return (IPADM_INVALID_ARG);
1425 }
1426
1427 /*
1428 * Do we support this protocol, if not return error.
1429 */
1430 if (ipadm_proto2str(proto) == NULL)
1431 return (IPADM_NOTSUP);
1432
1433 /*
1434 * Validate the interface and check if a persistent
1435 * operation is performed on a temporary object.
1436 */
1437 status = i_ipadm_validate_if(iph, ifname, proto, pflags);
1438 if (status != IPADM_SUCCESS)
1439 return (status);
1440
1441 return (i_ipadm_setprop_common(iph, ifname, pname, buf, proto,
1442 pflags));
1443 }
1444
1445 /*
1446 * Sets the property value of the specified protocol.
1447 */
1448 ipadm_status_t
1449 ipadm_set_prop(ipadm_handle_t iph, const char *pname, const char *buf,
1450 uint_t proto, uint_t pflags)
1451 {
1452 boolean_t reset = (pflags & IPADM_OPT_DEFAULT);
1453
1454 /* check for solaris.network.interface.config authorization */
1455 if (!ipadm_check_auth())
1456 return (IPADM_EAUTH);
1457 /*
1458 * validate the arguments of the function.
1459 */
1460 if (iph == NULL || pname == NULL ||(!reset && buf == NULL) ||
1461 pflags == 0 || pflags == IPADM_OPT_PERSIST ||
1462 (pflags & ~(IPADM_COMMON_OPT_MASK|IPADM_OPT_DEFAULT|
1463 IPADM_OPT_APPEND|IPADM_OPT_REMOVE))) {
1464 return (IPADM_INVALID_ARG);
1465 }
1466
1467 /*
1468 * Do we support this proto, if not return error.
1469 */
1470 if (ipadm_proto2str(proto) == NULL)
1471 return (IPADM_NOTSUP);
1472
1473 return (i_ipadm_setprop_common(iph, NULL, pname, buf, proto,
1474 pflags));
1475 }
1476
1477 /* helper function for ipadm_walk_proptbl */
1478 static void
1479 i_ipadm_walk_proptbl(ipadm_prop_desc_t *pdtbl, uint_t proto, uint_t class,
1480 ipadm_prop_wfunc_t *func, void *arg)
1481 {
1482 ipadm_prop_desc_t *pdp;
1483
1484 for (pdp = pdtbl; pdp->ipd_name != NULL; pdp++) {
1485 if (!(pdp->ipd_class & class))
1486 continue;
1487
1488 if (proto != MOD_PROTO_NONE && !(pdp->ipd_proto & proto))
1489 continue;
1490
1491 /*
1492 * we found a class specific match, call the
1493 * user callback function.
1494 */
1495 if (func(arg, pdp->ipd_name, pdp->ipd_proto) == B_FALSE)
1496 break;
1497 }
1498 }
1499
1500 /*
1501 * Walks through all the properties, for a given protocol and property class
1502 * (protocol or interface).
1503 *
1504 * Further if proto == MOD_PROTO_NONE, then it walks through all the supported
1505 * protocol property tables.
1506 */
1507 ipadm_status_t
1508 ipadm_walk_proptbl(uint_t proto, uint_t class, ipadm_prop_wfunc_t *func,
1509 void *arg)
1510 {
1511 ipadm_prop_desc_t *pdtbl;
1512 ipadm_status_t status = IPADM_SUCCESS;
1513 int i;
1514 int count = A_CNT(protocols);
1515
1516 if (func == NULL)
1517 return (IPADM_INVALID_ARG);
1518
1519 switch (class) {
1520 case IPADMPROP_CLASS_ADDR:
1521 pdtbl = ipadm_addrprop_table;
1522 break;
1523 case IPADMPROP_CLASS_IF:
1524 case IPADMPROP_CLASS_MODULE:
1525 pdtbl = i_ipadm_get_propdesc_table(proto);
1526 if (pdtbl == NULL && proto != MOD_PROTO_NONE)
1527 return (IPADM_INVALID_ARG);
1528 break;
1529 default:
1530 return (IPADM_INVALID_ARG);
1531 }
1532
1533 if (pdtbl != NULL) {
1534 /*
1535 * proto will be MOD_PROTO_NONE in the case of
1536 * IPADMPROP_CLASS_ADDR.
1537 */
1538 i_ipadm_walk_proptbl(pdtbl, proto, class, func, arg);
1539 } else {
1540 /* Walk thru all the protocol tables, we support */
1541 for (i = 0; i < count; i++) {
1542 pdtbl = i_ipadm_get_propdesc_table(protocols[i]);
1543 i_ipadm_walk_proptbl(pdtbl, protocols[i], class, func,
1544 arg);
1545 }
1546 }
1547 return (status);
1548 }
1549
1550 /*
1551 * Given a property name, walks through all the instances of a property name.
1552 * Some properties have two instances one for v4 interfaces and another for v6
1553 * interfaces. For example: MTU. MTU can have different values for v4 and v6.
1554 * Therefore there are two properties for 'MTU'.
1555 *
1556 * This function invokes `func' for every instance of property `pname'
1557 */
1558 ipadm_status_t
1559 ipadm_walk_prop(const char *pname, uint_t proto, uint_t class,
1560 ipadm_prop_wfunc_t *func, void *arg)
1561 {
1562 ipadm_prop_desc_t *pdtbl, *pdp;
1563 ipadm_status_t status = IPADM_SUCCESS;
1564 boolean_t matched = B_FALSE;
1565
1566 if (pname == NULL || func == NULL)
1567 return (IPADM_INVALID_ARG);
1568
1569 switch (class) {
1570 case IPADMPROP_CLASS_ADDR:
1571 pdtbl = ipadm_addrprop_table;
1572 break;
1573 case IPADMPROP_CLASS_IF:
1574 case IPADMPROP_CLASS_MODULE:
1575 pdtbl = i_ipadm_get_propdesc_table(proto);
1576 break;
1577 default:
1578 return (IPADM_INVALID_ARG);
1579 }
1580
1581 if (pdtbl == NULL)
1582 return (IPADM_INVALID_ARG);
1583
1584 for (pdp = pdtbl; pdp->ipd_name != NULL; pdp++) {
1585 if (strcmp(pname, pdp->ipd_name) != 0)
1586 continue;
1587 if (!(pdp->ipd_proto & proto))
1588 continue;
1589 matched = B_TRUE;
1590 /* we found a match, call the callback function */
1591 if (func(arg, pdp->ipd_name, pdp->ipd_proto) == B_FALSE)
1592 break;
1593 }
1594 if (!matched)
1595 status = IPADM_PROP_UNKNOWN;
1596 return (status);
1597 }
1598
1599 /* ARGSUSED */
1600 ipadm_status_t
1601 i_ipadm_get_onoff(ipadm_handle_t iph, const void *arg, ipadm_prop_desc_t *dp,
1602 char *buf, uint_t *bufsize, uint_t proto, uint_t valtype)
1603 {
1604 (void) snprintf(buf, *bufsize, "%s,%s", IPADM_ONSTR, IPADM_OFFSTR);
1605 return (IPADM_SUCCESS);
1606 }
1607
1608 /*
1609 * Makes a door call to ipmgmtd to retrieve the persisted property value
1610 */
1611 ipadm_status_t
1612 i_ipadm_get_persist_propval(ipadm_handle_t iph, ipadm_prop_desc_t *pdp,
1613 char *gbuf, uint_t *gbufsize, const void *object)
1614 {
1615 ipmgmt_prop_arg_t parg;
1616 ipmgmt_getprop_rval_t rval, *rvalp;
1617 size_t nbytes;
1618 int err = 0;
1619
1620 bzero(&parg, sizeof (parg));
1621 parg.ia_cmd = IPMGMT_CMD_GETPROP;
1622 i_ipadm_populate_proparg(&parg, pdp, NULL, object);
1623
1624 rvalp = &rval;
1625 err = ipadm_door_call(iph, &parg, sizeof (parg), (void **)&rvalp,
1626 sizeof (rval), B_FALSE);
1627 if (err == 0) {
1628 /* assert that rvalp was not reallocated */
1629 assert(rvalp == &rval);
1630
1631 /* `ir_pval' contains the property value */
1632 nbytes = snprintf(gbuf, *gbufsize, "%s", rvalp->ir_pval);
1633 if (nbytes >= *gbufsize) {
1634 /* insufficient buffer space */
1635 *gbufsize = nbytes + 1;
1636 err = ENOBUFS;
1637 }
1638 }
1639 return (ipadm_errno2status(err));
1640 }
1641
1642 /*
1643 * Persists the property value for a given property in the data store
1644 */
1645 ipadm_status_t
1646 i_ipadm_persist_propval(ipadm_handle_t iph, ipadm_prop_desc_t *pdp,
1647 const char *pval, const void *object, uint_t flags)
1648 {
1649 ipmgmt_prop_arg_t parg;
1650 int err = 0;
1651
1652 bzero(&parg, sizeof (parg));
1653 i_ipadm_populate_proparg(&parg, pdp, pval, object);
1654 /*
1655 * Check if value to be persisted need to be appended or removed. This
1656 * is required for multi-valued property.
1657 */
1658 if (flags & IPADM_OPT_APPEND)
1659 parg.ia_flags |= IPMGMT_APPEND;
1660 if (flags & IPADM_OPT_REMOVE)
1661 parg.ia_flags |= IPMGMT_REMOVE;
1662
1663 if (flags & (IPADM_OPT_DEFAULT|IPADM_OPT_REMOVE))
1664 parg.ia_cmd = IPMGMT_CMD_RESETPROP;
1665 else
1666 parg.ia_cmd = IPMGMT_CMD_SETPROP;
1667
1668 err = ipadm_door_call(iph, &parg, sizeof (parg), NULL, 0, B_FALSE);
1669
1670 /*
1671 * its fine if there were no entry in the DB to delete. The user
1672 * might be changing property value, which was not changed
1673 * persistently.
1674 */
1675 if (err == ENOENT)
1676 err = 0;
1677 return (ipadm_errno2status(err));
1678 }
1679
1680 /*
1681 * This is called from ipadm_set_ifprop() to validate the set operation.
1682 * It does the following steps:
1683 * 1. Validates the interface name.
1684 * 2. Fails if it is an IPMP meta-interface or an underlying interface.
1685 * 3. In case of a persistent operation, verifies that the
1686 * interface is persistent.
1687 */
1688 static ipadm_status_t
1689 i_ipadm_validate_if(ipadm_handle_t iph, const char *ifname,
1690 uint_t proto, uint_t flags)
1691 {
1692 sa_family_t af, other_af;
1693 ipadm_status_t status;
1694 boolean_t p_exists;
1695 boolean_t af_exists, other_af_exists, a_exists;
1696
1697 /* Check if the interface name is valid. */
1698 if (!i_ipadm_validate_ifname(iph, ifname))
1699 return (IPADM_INVALID_ARG);
1700
1701 af = (proto == MOD_PROTO_IPV6 ? AF_INET6 : AF_INET);
1702 /*
1703 * Setting properties on an IPMP meta-interface or underlying
1704 * interface is not supported.
1705 */
1706 if (i_ipadm_is_ipmp(iph, ifname) || i_ipadm_is_under_ipmp(iph, ifname))
1707 return (IPADM_NOTSUP);
1708
1709 /* Check if interface exists in the persistent configuration. */
1710 status = i_ipadm_if_pexists(iph, ifname, af, &p_exists);
1711 if (status != IPADM_SUCCESS)
1712 return (status);
1713
1714 /* Check if interface exists in the active configuration. */
1715 af_exists = ipadm_if_enabled(iph, ifname, af);
1716 other_af = (af == AF_INET ? AF_INET6 : AF_INET);
1717 other_af_exists = ipadm_if_enabled(iph, ifname, other_af);
1718 a_exists = (af_exists || other_af_exists);
1719 if (!a_exists && p_exists)
1720 return (IPADM_OP_DISABLE_OBJ);
1721 if (!af_exists)
1722 return (IPADM_ENXIO);
1723
1724 /*
1725 * If a persistent operation is requested, check if the underlying
1726 * IP interface is persistent.
1727 */
1728 if ((flags & IPADM_OPT_PERSIST) && !p_exists)
1729 return (IPADM_TEMPORARY_OBJ);
1730 return (IPADM_SUCCESS);
1731 }
1732
1733 /*
1734 * Private protocol properties namespace scheme:
1735 *
1736 * PSARC 2010/080 identified the private protocol property names to be the
1737 * leading protocol names. For e.g. tcp_strong_iss, ip_strict_src_multihoming,
1738 * et al,. However to be consistent with private data-link property names,
1739 * which starts with '_', private protocol property names will start with '_'.
1740 * For e.g. _strong_iss, _strict_src_multihoming, et al,.
1741 */
1742
1743 /* maps new private protocol property name to the old private property name */
1744 typedef struct ipadm_oname2nname_map {
1745 char *iom_oname;
1746 char *iom_nname;
1747 uint_t iom_proto;
1748 } ipadm_oname2nname_map_t;
1749
1750 /*
1751 * IP is a special case. It isn't straight forward to derive the legacy name
1752 * from the new name and vice versa. No set standard was followed in naming
1753 * the properties and hence we need a table to capture the mapping.
1754 */
1755 static ipadm_oname2nname_map_t name_map[] = {
1756 { "arp_probe_delay", "_arp_probe_delay",
1757 MOD_PROTO_IP },
1758 { "arp_fastprobe_delay", "_arp_fastprobe_delay",
1759 MOD_PROTO_IP },
1760 { "arp_probe_interval", "_arp_probe_interval",
1761 MOD_PROTO_IP },
1762 { "arp_fastprobe_interval", "_arp_fastprobe_interval",
1763 MOD_PROTO_IP },
1764 { "arp_probe_count", "_arp_probe_count",
1765 MOD_PROTO_IP },
1766 { "arp_fastprobe_count", "_arp_fastprobe_count",
1767 MOD_PROTO_IP },
1768 { "arp_defend_interval", "_arp_defend_interval",
1769 MOD_PROTO_IP },
1770 { "arp_defend_rate", "_arp_defend_rate",
1771 MOD_PROTO_IP },
1772 { "arp_defend_period", "_arp_defend_period",
1773 MOD_PROTO_IP },
1774 { "ndp_defend_interval", "_ndp_defend_interval",
1775 MOD_PROTO_IP },
1776 { "ndp_defend_rate", "_ndp_defend_rate",
1777 MOD_PROTO_IP },
1778 { "ndp_defend_period", "_ndp_defend_period",
1779 MOD_PROTO_IP },
1780 { "igmp_max_version", "_igmp_max_version",
1781 MOD_PROTO_IP },
1782 { "mld_max_version", "_mld_max_version",
1783 MOD_PROTO_IP },
1784 { "ipsec_override_persocket_policy", "_ipsec_override_persocket_policy",
1785 MOD_PROTO_IP },
1786 { "ipsec_policy_log_interval", "_ipsec_policy_log_interval",
1787 MOD_PROTO_IP },
1788 { "icmp_accept_clear_messages", "_icmp_accept_clear_messages",
1789 MOD_PROTO_IP },
1790 { "igmp_accept_clear_messages", "_igmp_accept_clear_messages",
1791 MOD_PROTO_IP },
1792 { "pim_accept_clear_messages", "_pim_accept_clear_messages",
1793 MOD_PROTO_IP },
1794 { "ip_respond_to_echo_multicast", "_respond_to_echo_multicast",
1795 MOD_PROTO_IPV4 },
1796 { "ip_send_redirects", "_send_redirects",
1797 MOD_PROTO_IPV4 },
1798 { "ip_forward_src_routed", "_forward_src_routed",
1799 MOD_PROTO_IPV4 },
1800 { "ip_icmp_return_data_bytes", "_icmp_return_data_bytes",
1801 MOD_PROTO_IPV4 },
1802 { "ip_ignore_redirect", "_ignore_redirect",
1803 MOD_PROTO_IPV4 },
1804 { "ip_strict_dst_multihoming", "_strict_dst_multihoming",
1805 MOD_PROTO_IPV4 },
1806 { "ip_reasm_timeout", "_reasm_timeout",
1807 MOD_PROTO_IPV4 },
1808 { "ip_strict_src_multihoming", "_strict_src_multihoming",
1809 MOD_PROTO_IPV4 },
1810 { "ipv4_dad_announce_interval", "_dad_announce_interval",
1811 MOD_PROTO_IPV4 },
1812 { "ipv4_icmp_return_pmtu", "_icmp_return_pmtu",
1813 MOD_PROTO_IPV4 },
1814 { "ipv6_dad_announce_interval", "_dad_announce_interval",
1815 MOD_PROTO_IPV6 },
1816 { "ipv6_icmp_return_pmtu", "_icmp_return_pmtu",
1817 MOD_PROTO_IPV6 },
1818 { NULL, NULL, MOD_PROTO_NONE }
1819 };
1820
1821 /*
1822 * Following API returns a new property name in `nname' for the given legacy
1823 * property name in `oname'.
1824 */
1825 int
1826 ipadm_legacy2new_propname(const char *oname, char *nname, uint_t nnamelen,
1827 uint_t *proto)
1828 {
1829 const char *str;
1830 ipadm_oname2nname_map_t *ionmp;
1831
1832 /* if it's a public property, there is nothing to return */
1833 if (i_ipadm_get_prop_desc(oname, *proto, NULL) != NULL)
1834 return (-1);
1835
1836 /*
1837 * we didn't find the `oname' in the table, check if the property
1838 * name begins with a leading protocol.
1839 */
1840 str = oname;
1841 switch (*proto) {
1842 case MOD_PROTO_TCP:
1843 if (strstr(oname, "tcp_") == oname)
1844 str += strlen("tcp");
1845 break;
1846 case MOD_PROTO_SCTP:
1847 if (strstr(oname, "sctp_") == oname)
1848 str += strlen("sctp");
1849 break;
1850 case MOD_PROTO_UDP:
1851 if (strstr(oname, "udp_") == oname)
1852 str += strlen("udp");
1853 break;
1854 case MOD_PROTO_RAWIP:
1855 if (strstr(oname, "icmp_") == oname)
1856 str += strlen("icmp");
1857 break;
1858 case MOD_PROTO_IP:
1859 case MOD_PROTO_IPV4:
1860 case MOD_PROTO_IPV6:
1861 if (strstr(oname, "ip6_") == oname) {
1862 *proto = MOD_PROTO_IPV6;
1863 str += strlen("ip6");
1864 } else {
1865 for (ionmp = name_map; ionmp->iom_oname != NULL;
1866 ionmp++) {
1867 if (strcmp(oname, ionmp->iom_oname) == 0) {
1868 str = ionmp->iom_nname;
1869 *proto = ionmp->iom_proto;
1870 break;
1871 }
1872 }
1873 if (ionmp->iom_oname != NULL)
1874 break;
1875
1876 if (strstr(oname, "ip_") == oname) {
1877 *proto = MOD_PROTO_IP;
1878 str += strlen("ip");
1879 }
1880 }
1881 break;
1882 default:
1883 return (-1);
1884 }
1885 (void) snprintf(nname, nnamelen, "%s", str);
1886 return (0);
1887 }
1888
1889 /*
1890 * Following API is required for ndd.c alone. To maintain backward
1891 * compatibility with ndd output, we need to print the legacy name
1892 * for the new name.
1893 */
1894 int
1895 ipadm_new2legacy_propname(const char *oname, char *nname,
1896 uint_t nnamelen, uint_t proto)
1897 {
1898 char *prefix;
1899 ipadm_oname2nname_map_t *ionmp;
1900
1901 /* if it's a public property, there is nothing to prepend */
1902 if (i_ipadm_get_prop_desc(oname, proto, NULL) != NULL)
1903 return (-1);
1904
1905 switch (proto) {
1906 case MOD_PROTO_TCP:
1907 prefix = "tcp";
1908 break;
1909 case MOD_PROTO_SCTP:
1910 prefix = "sctp";
1911 break;
1912 case MOD_PROTO_UDP:
1913 prefix = "udp";
1914 break;
1915 case MOD_PROTO_RAWIP:
1916 prefix = "icmp";
1917 break;
1918 case MOD_PROTO_IP:
1919 case MOD_PROTO_IPV4:
1920 case MOD_PROTO_IPV6:
1921 /* handle special case for IP */
1922 for (ionmp = name_map; ionmp->iom_oname != NULL; ionmp++) {
1923 if (strcmp(oname, ionmp->iom_nname) == 0 &&
1924 ionmp->iom_proto == proto) {
1925 (void) strlcpy(nname, ionmp->iom_oname,
1926 nnamelen);
1927 return (0);
1928 }
1929 }
1930 if (proto == MOD_PROTO_IPV6)
1931 prefix = "ip6";
1932 else
1933 prefix = "ip";
1934 break;
1935 default:
1936 return (-1);
1937 }
1938 (void) snprintf(nname, nnamelen, "%s%s", prefix, oname);
1939 return (0);
1940 }