xref: /titanic_44/usr/src/lib/libdladm/common/libdlbridge.c (revision 56b2bdd1f04d465cfe4a95b88ae5cba5884154e4)
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 <stdio.h>
26 #include <sys/types.h>
27 #include <string.h>
28 #include <fcntl.h>
29 #include <unistd.h>
30 #include <stropts.h>
31 #include <ctype.h>
32 #include <errno.h>
33 #include <stdlib.h>
34 #include <door.h>
35 #include <sys/mman.h>
36 #include <libscf.h>
37 #include <libscf_priv.h>
38 #include <libdllink.h>
39 #include <libdlbridge.h>
40 #include <libdladm_impl.h>
41 #include <stp_in.h>
42 #include <net/bridge.h>
43 #include <net/trill.h>
44 #include <sys/socket.h>
45 #include <sys/dld_ioc.h>
46 
47 /*
48  * Bridge Administration Library.
49  *
50  * This library is used by administration tools such as dladm(1M) to configure
51  * bridges, and by the bridge daemon to retrieve configuration information.
52  */
53 
54 #define	BRIDGE_SVC_NAME	"network/bridge"
55 #define	TRILL_SVC_NAME	"network/routing/trill"
56 
57 #define	DEFAULT_TIMEOUT	60000000
58 #define	INIT_WAIT_USECS	50000
59 #define	MAXPORTS	256
60 
61 typedef struct scf_state {
62 	scf_handle_t *ss_handle;
63 	scf_instance_t *ss_inst;
64 	scf_service_t *ss_svc;
65 	scf_snapshot_t *ss_snap;
66 	scf_propertygroup_t *ss_pg;
67 	scf_property_t *ss_prop;
68 } scf_state_t;
69 
70 static void
71 shut_down_scf(scf_state_t *sstate)
72 {
73 	scf_instance_destroy(sstate->ss_inst);
74 	(void) scf_handle_unbind(sstate->ss_handle);
75 	scf_handle_destroy(sstate->ss_handle);
76 }
77 
78 static char *
79 alloc_fmri(const char *service, const char *instance_name)
80 {
81 	ssize_t max_fmri;
82 	char *fmri;
83 
84 	/* If the limit is unknown, then use an arbitrary value */
85 	if ((max_fmri = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH)) == -1)
86 		max_fmri = 1024;
87 	if ((fmri = malloc(max_fmri)) != NULL) {
88 		(void) snprintf(fmri, max_fmri, "svc:/%s:%s", service,
89 		    instance_name);
90 	}
91 	return (fmri);
92 }
93 
94 /*
95  * Start up SCF and bind the requested instance alone.
96  */
97 static int
98 bind_instance(const char *service, const char *instance_name,
99     scf_state_t *sstate)
100 {
101 	char *fmri = NULL;
102 
103 	(void) memset(sstate, 0, sizeof (*sstate));
104 
105 	if ((sstate->ss_handle = scf_handle_create(SCF_VERSION)) == NULL)
106 		return (-1);
107 
108 	if (scf_handle_bind(sstate->ss_handle) != 0)
109 		goto failure;
110 	sstate->ss_inst = scf_instance_create(sstate->ss_handle);
111 	if (sstate->ss_inst == NULL)
112 		goto failure;
113 
114 	fmri = alloc_fmri(service, instance_name);
115 
116 	if (scf_handle_decode_fmri(sstate->ss_handle, fmri, NULL, NULL,
117 	    sstate->ss_inst, NULL, NULL,
118 	    SCF_DECODE_FMRI_REQUIRE_INSTANCE) != 0)
119 		goto failure;
120 	free(fmri);
121 	return (0);
122 
123 failure:
124 	free(fmri);
125 	shut_down_scf(sstate);
126 	return (-1);
127 }
128 
129 /*
130  * Start up SCF and an exact FMRI.  This is used for creating new instances and
131  * enable/disable actions.
132  */
133 static dladm_status_t
134 exact_instance(const char *fmri, scf_state_t *sstate)
135 {
136 	dladm_status_t status;
137 
138 	(void) memset(sstate, 0, sizeof (*sstate));
139 
140 	if ((sstate->ss_handle = scf_handle_create(SCF_VERSION)) == NULL)
141 		return (DLADM_STATUS_NOMEM);
142 
143 	status = DLADM_STATUS_FAILED;
144 	if (scf_handle_bind(sstate->ss_handle) != 0)
145 		goto failure;
146 	sstate->ss_svc = scf_service_create(sstate->ss_handle);
147 	if (sstate->ss_svc == NULL)
148 		goto failure;
149 	if (scf_handle_decode_fmri(sstate->ss_handle, fmri, NULL,
150 	    sstate->ss_svc, NULL, NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0) {
151 		if (scf_error() == SCF_ERROR_NOT_FOUND)
152 			status = DLADM_STATUS_OPTMISSING;
153 		goto failure;
154 	}
155 	sstate->ss_inst = scf_instance_create(sstate->ss_handle);
156 	if (sstate->ss_inst == NULL)
157 		goto failure;
158 	return (DLADM_STATUS_OK);
159 
160 failure:
161 	shut_down_scf(sstate);
162 	return (status);
163 }
164 
165 static void
166 drop_composed(scf_state_t *sstate)
167 {
168 	scf_property_destroy(sstate->ss_prop);
169 	scf_pg_destroy(sstate->ss_pg);
170 	scf_snapshot_destroy(sstate->ss_snap);
171 }
172 
173 /*
174  * This function sets up a composed view of the configuration information for
175  * the specified instance.  When this is done, the get_property() function
176  * should be able to return individual parameters.
177  */
178 static int
179 get_composed_properties(const char *lpg, boolean_t snap, scf_state_t *sstate)
180 {
181 	sstate->ss_snap = NULL;
182 	sstate->ss_pg = NULL;
183 	sstate->ss_prop = NULL;
184 
185 	if (snap) {
186 		sstate->ss_snap = scf_snapshot_create(sstate->ss_handle);
187 		if (sstate->ss_snap == NULL)
188 			goto failure;
189 		if (scf_instance_get_snapshot(sstate->ss_inst, "running",
190 		    sstate->ss_snap) != 0)
191 			goto failure;
192 	}
193 	if ((sstate->ss_pg = scf_pg_create(sstate->ss_handle)) == NULL)
194 		goto failure;
195 	if (scf_instance_get_pg_composed(sstate->ss_inst, sstate->ss_snap, lpg,
196 	    sstate->ss_pg) != 0)
197 		goto failure;
198 	if ((sstate->ss_prop = scf_property_create(sstate->ss_handle)) ==
199 	    NULL)
200 		goto failure;
201 	return (0);
202 
203 failure:
204 	drop_composed(sstate);
205 	return (-1);
206 }
207 
208 static int
209 get_count(const char *lprop, scf_state_t *sstate, uint64_t *answer)
210 {
211 	scf_value_t *val;
212 	int retv;
213 
214 	if (scf_pg_get_property(sstate->ss_pg, lprop, sstate->ss_prop) != 0)
215 		return (-1);
216 	if ((val = scf_value_create(sstate->ss_handle)) == NULL)
217 		return (-1);
218 
219 	if (scf_property_get_value(sstate->ss_prop, val) == 0 &&
220 	    scf_value_get_count(val, answer) == 0)
221 		retv = 0;
222 	else
223 		retv = -1;
224 	scf_value_destroy(val);
225 	return (retv);
226 }
227 
228 static int
229 get_boolean(const char *lprop, scf_state_t *sstate, boolean_t *answer)
230 {
231 	scf_value_t *val;
232 	int retv;
233 	uint8_t bval;
234 
235 	if (scf_pg_get_property(sstate->ss_pg, lprop, sstate->ss_prop) != 0)
236 		return (-1);
237 	if ((val = scf_value_create(sstate->ss_handle)) == NULL)
238 		return (-1);
239 
240 	if (scf_property_get_value(sstate->ss_prop, val) == 0 &&
241 	    scf_value_get_boolean(val, &bval) == 0) {
242 		retv = 0;
243 		*answer = bval != 0;
244 	} else {
245 		retv = -1;
246 	}
247 	scf_value_destroy(val);
248 	return (retv);
249 }
250 
251 static dladm_status_t
252 bridge_door_call(const char *instname, bridge_door_type_t dtype,
253     datalink_id_t linkid, void **bufp, size_t inlen, size_t *buflenp,
254     boolean_t is_list)
255 {
256 	char doorname[MAXPATHLEN];
257 	int did, retv, etmp;
258 	bridge_door_cmd_t *bdc;
259 	door_arg_t arg;
260 
261 	(void) snprintf(doorname, sizeof (doorname), "%s/%s", DOOR_DIRNAME,
262 	    instname);
263 
264 	/* Knock on the door */
265 	did = open(doorname, O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
266 	if (did == -1)
267 		return (dladm_errno2status(errno));
268 
269 	if ((bdc = malloc(sizeof (*bdc) + inlen)) == NULL) {
270 		(void) close(did);
271 		return (DLADM_STATUS_NOMEM);
272 	}
273 	bdc->bdc_type = dtype;
274 	bdc->bdc_linkid = linkid;
275 	if (inlen != 0)
276 		(void) memcpy(bdc + 1, *bufp, inlen);
277 
278 	(void) memset(&arg, 0, sizeof (arg));
279 	arg.data_ptr = (char *)bdc;
280 	arg.data_size = sizeof (*bdc) + inlen;
281 	arg.rbuf = *bufp;
282 	arg.rsize = *buflenp;
283 
284 	/* The door_call function doesn't restart, so take care of that */
285 	do {
286 		errno = 0;
287 		if ((retv = door_call(did, &arg)) == 0)
288 			break;
289 	} while (errno == EINTR);
290 
291 	/* If we get an unexpected response, then return an error */
292 	if (retv == 0) {
293 		/* The daemon returns a single int for errors */
294 		/* LINTED: pointer alignment */
295 		if (arg.data_size == sizeof (int) && *(int *)arg.rbuf != 0) {
296 			retv = -1;
297 			/* LINTED: pointer alignment */
298 			errno = *(int *)arg.rbuf;
299 		}
300 		/* Terminated daemon returns with zero data */
301 		if (arg.data_size == 0) {
302 			retv = -1;
303 			errno = EBADF;
304 		}
305 	}
306 
307 	if (retv == 0) {
308 		if (arg.rbuf != *bufp) {
309 			if (is_list) {
310 				void *newp;
311 
312 				newp = realloc(*bufp, arg.data_size);
313 				if (newp == NULL) {
314 					retv = -1;
315 				} else {
316 					*bufp = newp;
317 					(void) memcpy(*bufp, arg.rbuf,
318 					    arg.data_size);
319 				}
320 			}
321 			(void) munmap(arg.rbuf, arg.rsize);
322 		}
323 		if (is_list) {
324 			*buflenp = arg.data_size;
325 		} else if (arg.data_size != *buflenp || arg.rbuf != *bufp) {
326 			errno = EINVAL;
327 			retv = -1;
328 		}
329 	}
330 
331 	etmp = errno;
332 	(void) close(did);
333 
334 	/* Revoked door is the same as no door at all */
335 	if (etmp == EBADF)
336 		etmp = ENOENT;
337 
338 	return (retv == 0 ? DLADM_STATUS_OK : dladm_errno2status(etmp));
339 }
340 
341 /*
342  * Wrapper function for making per-port calls.
343  */
344 static dladm_status_t
345 port_door_call(dladm_handle_t handle, datalink_id_t linkid,
346     bridge_door_type_t dtype, void *buf, size_t inlen, size_t buflen)
347 {
348 	char bridge[MAXLINKNAMELEN];
349 	dladm_status_t status;
350 
351 	status = dladm_bridge_getlink(handle, linkid, bridge, sizeof (bridge));
352 	if (status != DLADM_STATUS_OK)
353 		return (status);
354 	return (bridge_door_call(bridge, dtype, linkid, &buf, inlen, &buflen,
355 	    B_FALSE));
356 }
357 
358 static dladm_status_t
359 bridge_refresh(const char *bridge)
360 {
361 	dladm_status_t status;
362 	int twoints[2];
363 	void *bdptr;
364 	size_t buflen;
365 	char *fmri;
366 	int refresh_count;
367 
368 	buflen = sizeof (twoints);
369 	bdptr = twoints;
370 	status = bridge_door_call(bridge, bdcBridgeGetRefreshCount,
371 	    DATALINK_INVALID_LINKID, &bdptr, 0, &buflen, B_FALSE);
372 	if (status == DLADM_STATUS_NOTFOUND)
373 		return (DLADM_STATUS_OK);
374 	if (status != DLADM_STATUS_OK)
375 		return (status);
376 	refresh_count = twoints[0];
377 	if ((fmri = alloc_fmri(BRIDGE_SVC_NAME, bridge)) == NULL)
378 		return (DLADM_STATUS_NOMEM);
379 	status = smf_refresh_instance(fmri) == 0 ?
380 	    DLADM_STATUS_OK : DLADM_STATUS_FAILED;
381 	free(fmri);
382 	if (status == DLADM_STATUS_OK) {
383 		int i = 0;
384 
385 		/*
386 		 * SMF doesn't give any synchronous behavior or dependency
387 		 * ordering for refresh operations, so we have to invent our
388 		 * own mechanism here.  Get the refresh counter from the
389 		 * daemon, and wait for it to change.  It's not pretty, but
390 		 * it's sufficient.
391 		 */
392 		while (++i <= 10) {
393 			buflen = sizeof (twoints);
394 			bdptr = twoints;
395 			status = bridge_door_call(bridge,
396 			    bdcBridgeGetRefreshCount, DATALINK_INVALID_LINKID,
397 			    &bdptr, 0, &buflen, B_FALSE);
398 			if (status != DLADM_STATUS_OK)
399 				break;
400 			if (twoints[0] != refresh_count)
401 				break;
402 			(void) usleep(100000);
403 		}
404 		fmri = alloc_fmri(TRILL_SVC_NAME, bridge);
405 		if (fmri == NULL)
406 			return (DLADM_STATUS_NOMEM);
407 		status = smf_refresh_instance(fmri) == 0 ||
408 		    scf_error() == SCF_ERROR_NOT_FOUND ?
409 		    DLADM_STATUS_OK : DLADM_STATUS_FAILED;
410 		free(fmri);
411 	}
412 	return (status);
413 }
414 
415 /*
416  * Look up bridge property values from SCF and return them.
417  */
418 dladm_status_t
419 dladm_bridge_get_properties(const char *instance_name, UID_STP_CFG_T *cfg,
420     dladm_bridge_prot_t *brprotp)
421 {
422 	scf_state_t sstate;
423 	uint64_t value;
424 	boolean_t trill_enabled;
425 
426 	cfg->field_mask = 0;
427 	cfg->bridge_priority = DEF_BR_PRIO;
428 	cfg->max_age = DEF_BR_MAXAGE;
429 	cfg->hello_time = DEF_BR_HELLOT;
430 	cfg->forward_delay = DEF_BR_FWDELAY;
431 	cfg->force_version = DEF_FORCE_VERS;
432 
433 	(void) strlcpy(cfg->vlan_name, instance_name, sizeof (cfg->vlan_name));
434 
435 	*brprotp = DLADM_BRIDGE_PROT_STP;
436 
437 	/* It's ok for this to be missing; it's installed separately */
438 	if (bind_instance(TRILL_SVC_NAME, instance_name, &sstate) == 0) {
439 		trill_enabled = B_FALSE;
440 		if (get_composed_properties(SCF_PG_GENERAL, B_FALSE, &sstate) ==
441 		    0) {
442 			(void) get_boolean(SCF_PROPERTY_ENABLED, &sstate,
443 			    &trill_enabled);
444 			if (trill_enabled)
445 				*brprotp = DLADM_BRIDGE_PROT_TRILL;
446 			drop_composed(&sstate);
447 		}
448 		if (get_composed_properties(SCF_PG_GENERAL_OVR, B_FALSE,
449 		    &sstate) == 0) {
450 			(void) get_boolean(SCF_PROPERTY_ENABLED, &sstate,
451 			    &trill_enabled);
452 			if (trill_enabled)
453 				*brprotp = DLADM_BRIDGE_PROT_TRILL;
454 			drop_composed(&sstate);
455 		}
456 		shut_down_scf(&sstate);
457 	}
458 
459 	cfg->stp_enabled = (*brprotp == DLADM_BRIDGE_PROT_STP) ?
460 	    STP_ENABLED : STP_DISABLED;
461 	cfg->field_mask |= BR_CFG_STATE;
462 
463 	if (bind_instance(BRIDGE_SVC_NAME, instance_name, &sstate) != 0)
464 		return (DLADM_STATUS_REPOSITORYINVAL);
465 
466 	if (get_composed_properties("config", B_TRUE, &sstate) != 0) {
467 		shut_down_scf(&sstate);
468 		return (DLADM_STATUS_REPOSITORYINVAL);
469 	}
470 
471 	if (get_count("priority", &sstate, &value) == 0) {
472 		cfg->bridge_priority = value;
473 		cfg->field_mask |= BR_CFG_PRIO;
474 	}
475 	if (get_count("max-age", &sstate, &value) == 0) {
476 		cfg->max_age = value / IEEE_TIMER_SCALE;
477 		cfg->field_mask |= BR_CFG_AGE;
478 	}
479 	if (get_count("hello-time", &sstate, &value) == 0) {
480 		cfg->hello_time = value / IEEE_TIMER_SCALE;
481 		cfg->field_mask |= BR_CFG_HELLO;
482 	}
483 	if (get_count("forward-delay", &sstate, &value) == 0) {
484 		cfg->forward_delay = value / IEEE_TIMER_SCALE;
485 		cfg->field_mask |= BR_CFG_DELAY;
486 	}
487 	if (get_count("force-protocol", &sstate, &value) == 0) {
488 		cfg->force_version = value;
489 		cfg->field_mask |= BR_CFG_FORCE_VER;
490 	}
491 
492 	drop_composed(&sstate);
493 	shut_down_scf(&sstate);
494 	return (DLADM_STATUS_OK);
495 }
496 
497 /*
498  * Retrieve special non-settable and undocumented parameters.
499  */
500 dladm_status_t
501 dladm_bridge_get_privprop(const char *instance_name, boolean_t *debugp,
502     uint32_t *tablemaxp)
503 {
504 	scf_state_t sstate;
505 	uint64_t value;
506 
507 	*debugp = B_FALSE;
508 	*tablemaxp = 10000;
509 
510 	if (bind_instance(BRIDGE_SVC_NAME, instance_name, &sstate) != 0)
511 		return (DLADM_STATUS_REPOSITORYINVAL);
512 
513 	if (get_composed_properties("config", B_TRUE, &sstate) != 0) {
514 		shut_down_scf(&sstate);
515 		return (DLADM_STATUS_REPOSITORYINVAL);
516 	}
517 
518 	(void) get_boolean("debug", &sstate, debugp);
519 	if (get_count("table-maximum", &sstate, &value) == 0)
520 		*tablemaxp = (uint32_t)value;
521 
522 	drop_composed(&sstate);
523 	shut_down_scf(&sstate);
524 	return (DLADM_STATUS_OK);
525 }
526 
527 static boolean_t
528 set_count_property(scf_handle_t *handle, scf_transaction_t *tran,
529     const char *propname, uint64_t propval)
530 {
531 	scf_transaction_entry_t *entry;
532 	scf_value_t *value = NULL;
533 
534 	if ((entry = scf_entry_create(handle)) == NULL)
535 		return (B_FALSE);
536 
537 	if ((value = scf_value_create(handle)) == NULL)
538 		goto out;
539 	if (scf_transaction_property_new(tran, entry, propname,
540 	    SCF_TYPE_COUNT) != 0 &&
541 	    scf_transaction_property_change(tran, entry, propname,
542 	    SCF_TYPE_COUNT) != 0)
543 		goto out;
544 	scf_value_set_count(value, propval);
545 	if (scf_entry_add_value(entry, value) == 0)
546 		return (B_TRUE);
547 
548 out:
549 	if (value != NULL)
550 		scf_value_destroy(value);
551 
552 	scf_entry_destroy_children(entry);
553 	scf_entry_destroy(entry);
554 
555 	return (B_FALSE);
556 }
557 
558 static boolean_t
559 set_string_property(scf_handle_t *handle, scf_transaction_t *tran,
560     const char *propname, const char *propval)
561 {
562 	scf_transaction_entry_t *entry;
563 	scf_value_t *value = NULL;
564 
565 	if ((entry = scf_entry_create(handle)) == NULL)
566 		return (B_FALSE);
567 
568 	if ((value = scf_value_create(handle)) == NULL)
569 		goto out;
570 	if (scf_transaction_property_new(tran, entry, propname,
571 	    SCF_TYPE_ASTRING) != 0 &&
572 	    scf_transaction_property_change(tran, entry, propname,
573 	    SCF_TYPE_ASTRING) != 0)
574 		goto out;
575 	if (scf_value_set_astring(value, propval) != 0)
576 		goto out;
577 	if (scf_entry_add_value(entry, value) == 0)
578 		return (B_TRUE);
579 
580 out:
581 	if (value != NULL)
582 		scf_value_destroy(value);
583 
584 	scf_entry_destroy_children(entry);
585 	scf_entry_destroy(entry);
586 
587 	return (B_FALSE);
588 }
589 
590 static boolean_t
591 set_fmri_property(scf_handle_t *handle, scf_transaction_t *tran,
592     const char *propname, const char *propval)
593 {
594 	scf_transaction_entry_t *entry;
595 	scf_value_t *value = NULL;
596 
597 	if ((entry = scf_entry_create(handle)) == NULL)
598 		return (B_FALSE);
599 
600 	if ((value = scf_value_create(handle)) == NULL)
601 		goto out;
602 	if (scf_transaction_property_new(tran, entry, propname,
603 	    SCF_TYPE_FMRI) != 0 &&
604 	    scf_transaction_property_change(tran, entry, propname,
605 	    SCF_TYPE_FMRI) != 0)
606 		goto out;
607 	if (scf_value_set_from_string(value, SCF_TYPE_FMRI, propval) != 0)
608 		goto out;
609 	if (scf_entry_add_value(entry, value) == 0)
610 		return (B_TRUE);
611 
612 out:
613 	if (value != NULL)
614 		scf_value_destroy(value);
615 
616 	scf_entry_destroy_children(entry);
617 	scf_entry_destroy(entry);
618 
619 	return (B_FALSE);
620 }
621 
622 static dladm_status_t
623 dladm_bridge_persist_conf(dladm_handle_t handle, const char *link,
624     datalink_id_t linkid)
625 {
626 	dladm_conf_t conf;
627 	dladm_status_t status;
628 
629 	status = dladm_create_conf(handle, link, linkid, DATALINK_CLASS_BRIDGE,
630 	    DL_ETHER, &conf);
631 	if (status == DLADM_STATUS_OK) {
632 		/*
633 		 * Create the datalink entry for the bridge.  Note that all of
634 		 * the real configuration information is in SMF.
635 		 */
636 		status = dladm_write_conf(handle, conf);
637 		dladm_destroy_conf(handle, conf);
638 	}
639 	return (status);
640 }
641 
642 /* Convert bridge protection option string to dladm_bridge_prot_t */
643 dladm_status_t
644 dladm_bridge_str2prot(const char *str, dladm_bridge_prot_t *brprotp)
645 {
646 	if (strcmp(str, "stp") == 0)
647 		*brprotp = DLADM_BRIDGE_PROT_STP;
648 	else if (strcmp(str, "trill") == 0)
649 		*brprotp = DLADM_BRIDGE_PROT_TRILL;
650 	else
651 		return (DLADM_STATUS_BADARG);
652 	return (DLADM_STATUS_OK);
653 }
654 
655 /* Convert bridge protection option from dladm_bridge_prot_t to string */
656 const char *
657 dladm_bridge_prot2str(dladm_bridge_prot_t brprot)
658 {
659 	switch (brprot) {
660 	case DLADM_BRIDGE_PROT_STP:
661 		return ("stp");
662 	case DLADM_BRIDGE_PROT_TRILL:
663 		return ("trill");
664 	default:
665 		return ("unknown");
666 	}
667 }
668 
669 static dladm_status_t
670 enable_instance(const char *service_name, const char *instance)
671 {
672 	dladm_status_t status;
673 	char *fmri = alloc_fmri(service_name, instance);
674 
675 	if (fmri == NULL)
676 		return (DLADM_STATUS_NOMEM);
677 	status = smf_enable_instance(fmri, 0) == 0 ?
678 	    DLADM_STATUS_OK : DLADM_STATUS_FAILED;
679 	free(fmri);
680 	return (status);
681 }
682 
683 /*
684  * Shut down a possibly-running service instance.  If this is a permanent
685  * change, then delete it from the system.
686  */
687 static dladm_status_t
688 shut_down_instance(const char *service_name, const char *instance,
689     uint32_t flags)
690 {
691 	dladm_status_t status;
692 	char *fmri = alloc_fmri(service_name, instance);
693 	char *state;
694 	scf_state_t sstate;
695 
696 	if (fmri == NULL)
697 		return (DLADM_STATUS_NOMEM);
698 
699 	if (smf_disable_instance(fmri,
700 	    flags & DLADM_OPT_PERSIST ? 0 : SMF_TEMPORARY) == 0) {
701 		useconds_t usecs, umax;
702 
703 		/* If we can disable, then wait for it to happen. */
704 		umax = DEFAULT_TIMEOUT;
705 		for (usecs = INIT_WAIT_USECS; umax != 0; umax -= usecs) {
706 			state = smf_get_state(fmri);
707 			if (state != NULL &&
708 			    strcmp(state, SCF_STATE_STRING_DISABLED) == 0)
709 				break;
710 			free(state);
711 			usecs *= 2;
712 			if (usecs > umax)
713 				usecs = umax;
714 			(void) usleep(usecs);
715 		}
716 		if (umax == 0) {
717 			state = smf_get_state(fmri);
718 			if (state != NULL &&
719 			    strcmp(state, SCF_STATE_STRING_DISABLED) == 0)
720 				umax = 1;
721 		}
722 		free(state);
723 		status = umax != 0 ? DLADM_STATUS_OK : DLADM_STATUS_FAILED;
724 	} else if (scf_error() == SCF_ERROR_NOT_FOUND) {
725 		free(fmri);
726 		return (DLADM_STATUS_OK);
727 	} else {
728 		status = DLADM_STATUS_FAILED;
729 	}
730 
731 	free(fmri);
732 	if (status == DLADM_STATUS_OK && (flags & DLADM_OPT_PERSIST) &&
733 	    bind_instance(service_name, instance, &sstate) == 0) {
734 		(void) scf_instance_delete(sstate.ss_inst);
735 		shut_down_scf(&sstate);
736 	}
737 
738 	return (status);
739 }
740 
741 static dladm_status_t
742 disable_trill(const char *instance, uint32_t flags)
743 {
744 	return (shut_down_instance(TRILL_SVC_NAME, instance, flags));
745 }
746 
747 /*
748  * To enable TRILL, we must create a new instance of the TRILL service, then
749  * add proper dependencies to it, and finally mark it as enabled.  The
750  * dependencies will keep it from going on-line until the bridge is running.
751  */
752 static dladm_status_t
753 enable_trill(const char *instance)
754 {
755 	dladm_status_t status = DLADM_STATUS_FAILED;
756 	char *fmri = NULL;
757 	scf_state_t sstate;
758 	scf_transaction_t *tran = NULL;
759 	boolean_t new_instance = B_FALSE;
760 	boolean_t new_pg = B_FALSE;
761 	int rv;
762 
763 	/*
764 	 * This check is here in case the user has installed and then removed
765 	 * the package.  SMF should remove the manifest, but currently does
766 	 * not.
767 	 */
768 	if (access("/usr/sbin/trilld", F_OK) != 0)
769 		return (DLADM_STATUS_OPTMISSING);
770 
771 	if ((status = exact_instance(TRILL_SVC_NAME, &sstate)) !=
772 	    DLADM_STATUS_OK)
773 		goto out;
774 
775 	status = DLADM_STATUS_FAILED;
776 	if (scf_service_get_instance(sstate.ss_svc, instance, sstate.ss_inst) !=
777 	    0) {
778 		if (scf_service_add_instance(sstate.ss_svc, instance,
779 		    sstate.ss_inst) != 0)
780 			goto out;
781 		new_instance = B_TRUE;
782 	}
783 
784 	if ((tran = scf_transaction_create(sstate.ss_handle)) == NULL)
785 		goto out;
786 
787 	if ((sstate.ss_pg = scf_pg_create(sstate.ss_handle)) == NULL)
788 		goto out;
789 
790 	if (scf_instance_get_pg(sstate.ss_inst, "bridging",
791 	    sstate.ss_pg) == 0) {
792 		status = DLADM_STATUS_OK;
793 		goto out;
794 	}
795 
796 	if ((fmri = alloc_fmri(BRIDGE_SVC_NAME, instance)) == NULL)
797 		goto out;
798 
799 	if (scf_instance_add_pg(sstate.ss_inst, "bridging",
800 	    SCF_GROUP_DEPENDENCY, 0, sstate.ss_pg) != 0)
801 		goto out;
802 
803 	new_pg = B_TRUE;
804 	do {
805 		if (scf_transaction_start(tran, sstate.ss_pg) != 0)
806 			goto out;
807 
808 		if (!set_string_property(sstate.ss_handle, tran,
809 		    SCF_PROPERTY_GROUPING, SCF_DEP_REQUIRE_ALL))
810 			goto out;
811 		if (!set_string_property(sstate.ss_handle, tran,
812 		    SCF_PROPERTY_RESTART_ON, SCF_DEP_RESET_ON_RESTART))
813 			goto out;
814 		if (!set_string_property(sstate.ss_handle, tran,
815 		    SCF_PROPERTY_TYPE, "service"))
816 			goto out;
817 		if (!set_fmri_property(sstate.ss_handle, tran,
818 		    SCF_PROPERTY_ENTITIES, fmri))
819 			goto out;
820 
821 		rv = scf_transaction_commit(tran);
822 		scf_transaction_reset(tran);
823 		if (rv == 0 && scf_pg_update(sstate.ss_pg) == -1)
824 			goto out;
825 	} while (rv == 0);
826 	if (rv != 1)
827 		goto out;
828 
829 	status = DLADM_STATUS_OK;
830 
831 out:
832 	free(fmri);
833 	if (tran != NULL) {
834 		scf_transaction_destroy_children(tran);
835 		scf_transaction_destroy(tran);
836 	}
837 
838 	if (status != DLADM_STATUS_OK && new_pg)
839 		(void) scf_pg_delete(sstate.ss_pg);
840 
841 	drop_composed(&sstate);
842 
843 	/*
844 	 * If we created an instance and then failed, then remove the instance
845 	 * from the system.
846 	 */
847 	if (status != DLADM_STATUS_OK && new_instance)
848 		(void) scf_instance_delete(sstate.ss_inst);
849 
850 	shut_down_scf(&sstate);
851 
852 	if (status == DLADM_STATUS_OK)
853 		status = enable_instance(TRILL_SVC_NAME, instance);
854 
855 	return (status);
856 }
857 
858 /*
859  * Create a new bridge or modify an existing one.  Update the SMF configuration
860  * and add links.
861  *
862  * Input timer values are in IEEE scaled (* 256) format.
863  */
864 dladm_status_t
865 dladm_bridge_configure(dladm_handle_t handle, const char *name,
866     const UID_STP_CFG_T *cfg, dladm_bridge_prot_t brprot, uint32_t flags)
867 {
868 	dladm_status_t status;
869 	scf_state_t sstate;
870 	scf_transaction_t *tran = NULL;
871 	boolean_t new_instance = B_FALSE;
872 	boolean_t new_pg = B_FALSE;
873 	datalink_id_t linkid = DATALINK_INVALID_LINKID;
874 	char linkname[MAXLINKNAMELEN];
875 	int rv;
876 
877 	if (!dladm_valid_bridgename(name))
878 		return (DLADM_STATUS_FAILED);
879 
880 	if (flags & DLADM_OPT_CREATE) {
881 		/*
882 		 * This check is here in case the user has installed and then
883 		 * removed the package.  SMF should remove the manifest, but
884 		 * currently does not.
885 		 */
886 		if (access("/usr/lib/bridged", F_OK) != 0)
887 			return (DLADM_STATUS_OPTMISSING);
888 
889 		(void) snprintf(linkname, sizeof (linkname), "%s0", name);
890 		status = dladm_create_datalink_id(handle, linkname,
891 		    DATALINK_CLASS_BRIDGE, DL_ETHER,
892 		    flags & (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST), &linkid);
893 		if (status != DLADM_STATUS_OK)
894 			return (status);
895 
896 		if ((flags & DLADM_OPT_PERSIST) &&
897 		    (status = dladm_bridge_persist_conf(handle, linkname,
898 		    linkid) != DLADM_STATUS_OK))
899 			goto dladm_fail;
900 	}
901 
902 	if (brprot == DLADM_BRIDGE_PROT_TRILL)
903 		status = enable_trill(name);
904 	else
905 		status = disable_trill(name, flags);
906 	if (status != DLADM_STATUS_OK)
907 		goto dladm_fail;
908 
909 	if ((status = exact_instance(BRIDGE_SVC_NAME, &sstate)) !=
910 	    DLADM_STATUS_OK)
911 		goto out;
912 
913 	/* set up for a series of scf calls */
914 	status = DLADM_STATUS_FAILED;
915 
916 	if (scf_service_get_instance(sstate.ss_svc, name, sstate.ss_inst) ==
917 	    0) {
918 		if (flags & DLADM_OPT_CREATE) {
919 			status = DLADM_STATUS_EXIST;
920 			goto out;
921 		}
922 	} else {
923 		if (!(flags & DLADM_OPT_CREATE)) {
924 			status = DLADM_STATUS_NOTFOUND;
925 			goto out;
926 		}
927 		if (scf_service_add_instance(sstate.ss_svc, name,
928 		    sstate.ss_inst) != 0)
929 			goto out;
930 		new_instance = B_TRUE;
931 	}
932 
933 	if ((tran = scf_transaction_create(sstate.ss_handle)) == NULL)
934 		goto out;
935 
936 	if (cfg->field_mask & BR_CFG_ALL) {
937 		if ((sstate.ss_pg = scf_pg_create(sstate.ss_handle)) == NULL)
938 			goto out;
939 		if (scf_instance_add_pg(sstate.ss_inst, "config",
940 		    SCF_GROUP_APPLICATION, 0, sstate.ss_pg) == 0) {
941 			new_pg = B_TRUE;
942 		} else if (scf_instance_get_pg(sstate.ss_inst, "config",
943 		    sstate.ss_pg) != 0) {
944 			goto out;
945 		}
946 		do {
947 			if (scf_transaction_start(tran, sstate.ss_pg) != 0)
948 				goto out;
949 
950 			if ((cfg->field_mask & BR_CFG_PRIO) &&
951 			    !set_count_property(sstate.ss_handle, tran,
952 			    "priority", cfg->bridge_priority))
953 				goto out;
954 			if ((cfg->field_mask & BR_CFG_AGE) &&
955 			    !set_count_property(sstate.ss_handle, tran,
956 			    "max-age", cfg->max_age * IEEE_TIMER_SCALE))
957 				goto out;
958 			if ((cfg->field_mask & BR_CFG_HELLO) &&
959 			    !set_count_property(sstate.ss_handle, tran,
960 			    "hello-time", cfg->hello_time * IEEE_TIMER_SCALE))
961 				goto out;
962 			if ((cfg->field_mask & BR_CFG_DELAY) &&
963 			    !set_count_property(sstate.ss_handle, tran,
964 			    "forward-delay",
965 			    cfg->forward_delay * IEEE_TIMER_SCALE))
966 				goto out;
967 			if ((cfg->field_mask & BR_CFG_FORCE_VER) &&
968 			    !set_count_property(sstate.ss_handle, tran,
969 			    "force-protocol", cfg->force_version))
970 				goto out;
971 
972 			rv = scf_transaction_commit(tran);
973 			scf_transaction_reset(tran);
974 			if (rv == 0 && scf_pg_update(sstate.ss_pg) == -1)
975 				goto out;
976 		} while (rv == 0);
977 		if (rv != 1)
978 			goto out;
979 	}
980 
981 	/*
982 	 * If we're modifying an existing and running bridge, then tell the
983 	 * daemon to update the requested values.
984 	 */
985 	if ((flags & DLADM_OPT_ACTIVE) && !(flags & DLADM_OPT_CREATE))
986 		status = bridge_refresh(name);
987 	else
988 		status = DLADM_STATUS_OK;
989 
990 out:
991 	if (tran != NULL) {
992 		scf_transaction_destroy_children(tran);
993 		scf_transaction_destroy(tran);
994 	}
995 
996 	if (status != DLADM_STATUS_OK && new_pg)
997 		(void) scf_pg_delete(sstate.ss_pg);
998 
999 	drop_composed(&sstate);
1000 
1001 	/*
1002 	 * If we created an instance and then failed, then remove the instance
1003 	 * from the system.
1004 	 */
1005 	if (status != DLADM_STATUS_OK && new_instance)
1006 		(void) scf_instance_delete(sstate.ss_inst);
1007 
1008 	shut_down_scf(&sstate);
1009 
1010 	/*
1011 	 * Remove the bridge linkid if we've allocated one in this function but
1012 	 * we've failed to set up the SMF properties.
1013 	 */
1014 dladm_fail:
1015 	if (status != DLADM_STATUS_OK && linkid != DATALINK_INVALID_LINKID) {
1016 		(void) dladm_remove_conf(handle, linkid);
1017 		(void) dladm_destroy_datalink_id(handle, linkid, flags);
1018 	}
1019 
1020 	return (status);
1021 }
1022 
1023 /*
1024  * Enable a newly-created bridge in SMF by creating "general/enabled" and
1025  * deleting any "general_ovr/enabled" (used for temporary services).
1026  */
1027 dladm_status_t
1028 dladm_bridge_enable(const char *name)
1029 {
1030 	return (enable_instance(BRIDGE_SVC_NAME, name));
1031 }
1032 
1033 /*
1034  * Set a link as a member of a bridge, or remove bridge membership.  If the
1035  * DLADM_OPT_CREATE flag is set, then we assume that the daemon isn't running.
1036  * In all other cases, we must tell the daemon to add or delete the link in
1037  * order to stay in sync.
1038  */
1039 dladm_status_t
1040 dladm_bridge_setlink(dladm_handle_t handle, datalink_id_t linkid,
1041     const char *bridge)
1042 {
1043 	dladm_status_t status;
1044 	dladm_conf_t conf;
1045 	char oldbridge[MAXLINKNAMELEN];
1046 	boolean_t has_oldbridge;
1047 	boolean_t changed = B_FALSE;
1048 
1049 	if (*bridge != '\0' && !dladm_valid_bridgename(bridge))
1050 		return (DLADM_STATUS_FAILED);
1051 
1052 	status = dladm_open_conf(handle, linkid, &conf);
1053 	if (status != DLADM_STATUS_OK)
1054 		return (status);
1055 
1056 	has_oldbridge = B_FALSE;
1057 	status = dladm_get_conf_field(handle, conf, FBRIDGE, oldbridge,
1058 	    sizeof (oldbridge));
1059 	if (status == DLADM_STATUS_OK) {
1060 		/*
1061 		 * Don't allow a link to be reassigned directly from one bridge
1062 		 * to another.  It must be removed first.
1063 		 */
1064 		if (*oldbridge != '\0' && *bridge != '\0') {
1065 			status = DLADM_STATUS_EXIST;
1066 			goto out;
1067 		}
1068 		has_oldbridge = B_TRUE;
1069 	} else if (status != DLADM_STATUS_NOTFOUND) {
1070 		goto out;
1071 	}
1072 
1073 	if (*bridge != '\0') {
1074 		status = dladm_set_conf_field(handle, conf, FBRIDGE,
1075 		    DLADM_TYPE_STR, bridge);
1076 		changed = B_TRUE;
1077 	} else if (has_oldbridge) {
1078 		status = dladm_unset_conf_field(handle, conf, FBRIDGE);
1079 		changed = B_TRUE;
1080 	} else {
1081 		status = DLADM_STATUS_OK;
1082 		goto out;
1083 	}
1084 	if (status == DLADM_STATUS_OK)
1085 		status = dladm_write_conf(handle, conf);
1086 
1087 out:
1088 	dladm_destroy_conf(handle, conf);
1089 	if (changed && status == DLADM_STATUS_OK) {
1090 		if (bridge[0] == '\0')
1091 			bridge = oldbridge;
1092 		status = bridge_refresh(bridge);
1093 	}
1094 	return (status);
1095 }
1096 
1097 /*
1098  * Get the name of the bridge of which the given linkid is a member.
1099  */
1100 dladm_status_t
1101 dladm_bridge_getlink(dladm_handle_t handle, datalink_id_t linkid, char *bridge,
1102     size_t bridgelen)
1103 {
1104 	dladm_status_t status;
1105 	dladm_conf_t conf;
1106 
1107 	if ((status = dladm_getsnap_conf(handle, linkid, &conf)) !=
1108 	    DLADM_STATUS_OK)
1109 		return (status);
1110 
1111 	*bridge = '\0';
1112 	status = dladm_get_conf_field(handle, conf, FBRIDGE, bridge, bridgelen);
1113 	if (status == DLADM_STATUS_OK && *bridge == '\0')
1114 		status = DLADM_STATUS_NOTFOUND;
1115 
1116 	dladm_destroy_conf(handle, conf);
1117 	return (status);
1118 }
1119 
1120 dladm_status_t
1121 dladm_bridge_refresh(dladm_handle_t handle, datalink_id_t linkid)
1122 {
1123 	char bridge[MAXLINKNAMELEN];
1124 	dladm_status_t status;
1125 
1126 	status = dladm_bridge_getlink(handle, linkid, bridge, sizeof (bridge));
1127 	if (status == DLADM_STATUS_NOTFOUND)
1128 		return (DLADM_STATUS_OK);
1129 	if (status == DLADM_STATUS_OK)
1130 		status = bridge_refresh(bridge);
1131 	return (status);
1132 }
1133 
1134 typedef struct bridge_held_arg_s {
1135 	const char	*bha_bridge;
1136 	boolean_t	bha_isheld;
1137 } bridge_held_arg_t;
1138 
1139 static int
1140 i_dladm_bridge_is_held(dladm_handle_t handle, datalink_id_t linkid, void *arg)
1141 {
1142 	dladm_status_t status = DLADM_STATUS_FAILED;
1143 	dladm_conf_t conf;
1144 	char bridge[MAXLINKNAMELEN];
1145 	bridge_held_arg_t *bha = arg;
1146 
1147 	if ((status = dladm_getsnap_conf(handle, linkid, &conf)) !=
1148 	    DLADM_STATUS_OK)
1149 		return (DLADM_WALK_CONTINUE);
1150 	status = dladm_get_conf_field(handle, conf, FBRIDGE, bridge,
1151 	    sizeof (bridge));
1152 	if (status == DLADM_STATUS_OK && strcmp(bha->bha_bridge, bridge) == 0) {
1153 		bha->bha_isheld = B_TRUE;
1154 		dladm_destroy_conf(handle, conf);
1155 		return (DLADM_WALK_TERMINATE);
1156 	} else {
1157 		dladm_destroy_conf(handle, conf);
1158 		return (DLADM_WALK_CONTINUE);
1159 	}
1160 }
1161 
1162 /*
1163  * Delete a previously created bridge.
1164  */
1165 dladm_status_t
1166 dladm_bridge_delete(dladm_handle_t handle, const char *bridge, uint32_t flags)
1167 {
1168 	datalink_id_t linkid;
1169 	datalink_class_t class;
1170 	dladm_status_t status;
1171 	char linkname[MAXLINKNAMELEN];
1172 
1173 	if (!dladm_valid_bridgename(bridge))
1174 		return (DLADM_STATUS_LINKINVAL);
1175 
1176 	/* Get the datalink ID for this bridge */
1177 	(void) snprintf(linkname, sizeof (linkname), "%s0", bridge);
1178 	if (dladm_name2info(handle, linkname, &linkid, NULL, NULL, NULL) !=
1179 	    DLADM_STATUS_OK)
1180 		linkid = DATALINK_INVALID_LINKID;
1181 	else if (dladm_datalink_id2info(handle, linkid, NULL, &class, NULL,
1182 	    NULL, 0) != DLADM_STATUS_OK)
1183 		linkid = DATALINK_INVALID_LINKID;
1184 	else if (class != DATALINK_CLASS_BRIDGE)
1185 		return (DLADM_STATUS_BADARG);
1186 
1187 	if ((flags & DLADM_OPT_ACTIVE) && linkid == DATALINK_INVALID_LINKID)
1188 		return (DLADM_STATUS_BADARG);
1189 
1190 	if (flags & DLADM_OPT_PERSIST) {
1191 		bridge_held_arg_t arg;
1192 
1193 		arg.bha_bridge = bridge;
1194 		arg.bha_isheld = B_FALSE;
1195 
1196 		/*
1197 		 * See whether there are any persistent links using this
1198 		 * bridge.  If so, we fail the operation.
1199 		 */
1200 		(void) dladm_walk_datalink_id(i_dladm_bridge_is_held, handle,
1201 		    &arg, DATALINK_CLASS_PHYS | DATALINK_CLASS_AGGR |
1202 		    DATALINK_CLASS_ETHERSTUB | DATALINK_CLASS_SIMNET,
1203 		    DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST);
1204 		if (arg.bha_isheld)
1205 			return (DLADM_STATUS_LINKBUSY);
1206 	}
1207 
1208 	if ((status = disable_trill(bridge, flags)) != DLADM_STATUS_OK)
1209 		goto out;
1210 
1211 	/* Disable or remove the SMF instance */
1212 	status = shut_down_instance(BRIDGE_SVC_NAME, bridge, flags);
1213 	if (status != DLADM_STATUS_OK)
1214 		goto out;
1215 
1216 	if (flags & DLADM_OPT_ACTIVE) {
1217 		/*
1218 		 * Delete ACTIVE linkprop now that daemon is gone.
1219 		 */
1220 		(void) dladm_set_linkprop(handle, linkid, NULL, NULL, 0,
1221 		    DLADM_OPT_ACTIVE);
1222 		(void) dladm_destroy_datalink_id(handle, linkid,
1223 		    DLADM_OPT_ACTIVE);
1224 	}
1225 
1226 	if (flags & DLADM_OPT_PERSIST) {
1227 		(void) dladm_remove_conf(handle, linkid);
1228 		(void) dladm_destroy_datalink_id(handle, linkid,
1229 		    DLADM_OPT_PERSIST);
1230 	}
1231 
1232 out:
1233 
1234 	return (status);
1235 }
1236 
1237 /* Check if given name is valid for bridges */
1238 boolean_t
1239 dladm_valid_bridgename(const char *bridge)
1240 {
1241 	size_t		len = strnlen(bridge, MAXLINKNAMELEN);
1242 	const char	*cp;
1243 
1244 	if (len == MAXLINKNAMELEN)
1245 		return (B_FALSE);
1246 
1247 	/*
1248 	 * The bridge name cannot start or end with a digit.
1249 	 */
1250 	if (isdigit(bridge[0]) || isdigit(bridge[len - 1]))
1251 		return (B_FALSE);
1252 
1253 	/*
1254 	 * The legal characters within a bridge name are:
1255 	 * alphanumeric (a-z,  A-Z,  0-9), and the underscore ('_').
1256 	 */
1257 	for (cp = bridge; *cp != '\0'; cp++) {
1258 		if (!isalnum(*cp) && *cp != '_')
1259 			return (B_FALSE);
1260 	}
1261 
1262 	return (B_TRUE);
1263 }
1264 
1265 /*
1266  * Convert a bridge-related observability node name back into the name of the
1267  * bridge.  Returns B_FALSE without making changes if the input name is not in
1268  * a legal format.
1269  */
1270 boolean_t
1271 dladm_observe_to_bridge(char *link)
1272 {
1273 	int llen;
1274 
1275 	llen = strnlen(link, MAXLINKNAMELEN);
1276 	if (llen < 2 || link[llen - 1] != '0' || isdigit(link[llen - 2]))
1277 		return (B_FALSE);
1278 	link[llen - 1] = '\0';
1279 	return (B_TRUE);
1280 }
1281 
1282 /*
1283  * Get bridge property values from the running daemon and return them in a
1284  * common structure.
1285  */
1286 dladm_status_t
1287 dladm_bridge_run_properties(const char *instname, UID_STP_CFG_T *smcfg,
1288     dladm_bridge_prot_t *brprotp)
1289 {
1290 	dladm_status_t status;
1291 	bridge_door_cfg_t bdcf;
1292 	bridge_door_cfg_t *bdcfp = &bdcf;
1293 	size_t buflen = sizeof (bdcf);
1294 
1295 	status = bridge_door_call(instname, bdcBridgeGetConfig,
1296 	    DATALINK_INVALID_LINKID, (void **)&bdcfp, 0, &buflen, B_FALSE);
1297 	if (status == DLADM_STATUS_OK) {
1298 		*smcfg = bdcfp->bdcf_cfg;
1299 		*brprotp = bdcfp->bdcf_prot;
1300 	} else {
1301 		smcfg->field_mask = 0;
1302 		*brprotp = DLADM_BRIDGE_PROT_STP;
1303 	}
1304 	return (status);
1305 }
1306 
1307 /*
1308  * Get bridge state from the running daemon and return in structure borrowed
1309  * from librstp.
1310  */
1311 dladm_status_t
1312 dladm_bridge_state(const char *instname, UID_STP_STATE_T *statep)
1313 {
1314 	size_t buflen = sizeof (*statep);
1315 
1316 	return (bridge_door_call(instname, bdcBridgeGetState,
1317 	    DATALINK_INVALID_LINKID, (void **)&statep, 0, &buflen, B_FALSE));
1318 }
1319 
1320 /* Returns list of ports (datalink_id_t values) assigned to a bridge instance */
1321 datalink_id_t *
1322 dladm_bridge_get_portlist(const char *instname, uint_t *nports)
1323 {
1324 	size_t buflen = sizeof (int) + MAXPORTS * sizeof (datalink_id_t);
1325 	int *rbuf;
1326 
1327 	if ((rbuf = malloc(buflen)) == NULL)
1328 		return (NULL);
1329 	if (bridge_door_call(instname, bdcBridgeGetPorts,
1330 	    DATALINK_INVALID_LINKID, (void **)&rbuf, 0, &buflen, B_TRUE) !=
1331 	    DLADM_STATUS_OK) {
1332 		free(rbuf);
1333 		return (NULL);
1334 	} else {
1335 		/*
1336 		 * Returns an array of datalink_id_t values for all the ports
1337 		 * part of the bridge instance. First entry in the array is the
1338 		 * number of ports.
1339 		 */
1340 		*nports = *rbuf;
1341 		return ((datalink_id_t *)(rbuf + 1));
1342 	}
1343 }
1344 
1345 void
1346 dladm_bridge_free_portlist(datalink_id_t *dlp)
1347 {
1348 	free((int *)dlp - 1);
1349 }
1350 
1351 /* Retrieve Bridge port configuration values */
1352 dladm_status_t
1353 dladm_bridge_get_port_cfg(dladm_handle_t handle, datalink_id_t linkid,
1354     int field, int *valuep)
1355 {
1356 	UID_STP_PORT_CFG_T portcfg;
1357 	dladm_status_t status;
1358 
1359 	status = port_door_call(handle, linkid, bdcPortGetConfig, &portcfg,
1360 	    0, sizeof (portcfg));
1361 	if (status != DLADM_STATUS_OK)
1362 		return (status);
1363 
1364 	switch (field) {
1365 	case PT_CFG_COST:
1366 		*valuep = portcfg.admin_port_path_cost;
1367 		break;
1368 	case PT_CFG_PRIO:
1369 		*valuep = portcfg.port_priority;
1370 		break;
1371 	case PT_CFG_P2P:
1372 		*valuep = portcfg.admin_point2point;
1373 		break;
1374 	case PT_CFG_EDGE:
1375 		*valuep = portcfg.admin_edge;
1376 		break;
1377 	case PT_CFG_NON_STP:
1378 		*valuep = !portcfg.admin_non_stp;
1379 		break;
1380 	case PT_CFG_MCHECK:
1381 		*valuep = (portcfg.field_mask & PT_CFG_MCHECK) ? 1 : 0;
1382 		break;
1383 	}
1384 	return (status);
1385 }
1386 
1387 /* Retreive Bridge port status (disabled, bad SDU etc.) */
1388 dladm_status_t
1389 dladm_bridge_link_state(dladm_handle_t handle, datalink_id_t linkid,
1390     UID_STP_PORT_STATE_T *spsp)
1391 {
1392 	return (port_door_call(handle, linkid, bdcPortGetState, spsp, 0,
1393 	    sizeof (*spsp)));
1394 }
1395 
1396 /* Retrieve Bridge forwarding status of the given link */
1397 dladm_status_t
1398 dladm_bridge_get_forwarding(dladm_handle_t handle, datalink_id_t linkid,
1399     uint_t *valuep)
1400 {
1401 	int twoints[2];
1402 	dladm_status_t status;
1403 
1404 	status = port_door_call(handle, linkid, bdcPortGetForwarding, twoints,
1405 	    0, sizeof (twoints));
1406 	if (status == DLADM_STATUS_OK)
1407 		*valuep = twoints[0];
1408 	return (status);
1409 }
1410 
1411 /* Retrieve Bridge forwarding table entries */
1412 bridge_listfwd_t *
1413 dladm_bridge_get_fwdtable(dladm_handle_t handle, const char *bridge,
1414     uint_t *nfwd)
1415 {
1416 	bridge_listfwd_t *blf = NULL, *newblf, blfread;
1417 	uint_t nblf = 0, maxblf = 0;
1418 	static uint8_t zero_addr[ETHERADDRL];
1419 	int rc;
1420 
1421 	(void) memset(&blfread, 0, sizeof (blfread));
1422 	(void) snprintf(blfread.blf_name, sizeof (blfread.blf_name),
1423 	    "%s0", bridge);
1424 	for (;;) {
1425 		if (nblf >= maxblf) {
1426 			maxblf = maxblf == 0 ? 64 : (maxblf << 1);
1427 			newblf = realloc(blf, maxblf * sizeof (*blf));
1428 			if (newblf == NULL) {
1429 				free(blf);
1430 				blf = NULL;
1431 				break;
1432 			}
1433 			blf = newblf;
1434 		}
1435 		rc = ioctl(dladm_dld_fd(handle), BRIDGE_IOC_LISTFWD, &blfread);
1436 		if (rc != 0) {
1437 			free(blf);
1438 			blf = NULL;
1439 			break;
1440 		}
1441 		if (memcmp(blfread.blf_dest, zero_addr, ETHERADDRL) == 0)
1442 			break;
1443 		blf[nblf++] = blfread;
1444 	}
1445 	if (blf != NULL)
1446 		*nfwd = nblf;
1447 	return (blf);
1448 }
1449 
1450 void
1451 dladm_bridge_free_fwdtable(bridge_listfwd_t *blf)
1452 {
1453 	free(blf);
1454 }
1455 
1456 /* Retrieve list of TRILL nicknames from the TRILL module */
1457 trill_listnick_t *
1458 dladm_bridge_get_trillnick(const char *bridge, uint_t *nnick)
1459 {
1460 	int fd;
1461 	char brcopy[MAXLINKNAMELEN];
1462 	trill_listnick_t *tln = NULL, *newtln, tlnread;
1463 	uint_t ntln = 0, maxtln = 0;
1464 
1465 	if ((fd = socket(PF_TRILL, SOCK_DGRAM, 0)) == -1)
1466 		return (NULL);
1467 	(void) strlcpy(brcopy, bridge, sizeof (brcopy));
1468 	if (ioctl(fd, TRILL_GETBRIDGE, &brcopy) < 0) {
1469 		(void) close(fd);
1470 		return (NULL);
1471 	}
1472 	(void) memset(&tlnread, 0, sizeof (tlnread));
1473 	for (;;) {
1474 		if (ntln >= maxtln) {
1475 			maxtln = maxtln == 0 ? 64 : (maxtln << 1);
1476 			newtln = realloc(tln, maxtln * sizeof (*tln));
1477 			if (newtln == NULL) {
1478 				free(tln);
1479 				tln = NULL;
1480 				break;
1481 			}
1482 			tln = newtln;
1483 		}
1484 		if (ioctl(fd, TRILL_LISTNICK, &tlnread) == -1) {
1485 			free(tln);
1486 			tln = NULL;
1487 			break;
1488 		}
1489 		if (tlnread.tln_nick == 0)
1490 			break;
1491 		tln[ntln++] = tlnread;
1492 	}
1493 	(void) close(fd);
1494 	if (tln != NULL)
1495 		*nnick = ntln;
1496 	return (tln);
1497 }
1498 
1499 void
1500 dladm_bridge_free_trillnick(trill_listnick_t *tln)
1501 {
1502 	free(tln);
1503 }
1504 
1505 /* Retrieve any stored TRILL nickname from TRILL SMF service */
1506 uint16_t
1507 dladm_bridge_get_nick(const char *bridge)
1508 {
1509 	scf_state_t sstate;
1510 	uint64_t value;
1511 	uint16_t nickname = RBRIDGE_NICKNAME_NONE;
1512 
1513 	if (bind_instance(TRILL_SVC_NAME, bridge, &sstate) != 0)
1514 		return (nickname);
1515 
1516 	if (get_composed_properties("config", B_TRUE, &sstate) == 0 &&
1517 	    get_count("nickname", &sstate, &value) == 0)
1518 		nickname = value;
1519 	shut_down_scf(&sstate);
1520 	return (nickname);
1521 }
1522 
1523 /* Stores TRILL nickname in SMF configuraiton for the TRILL service */
1524 void
1525 dladm_bridge_set_nick(const char *bridge, uint16_t nick)
1526 {
1527 	scf_state_t sstate;
1528 	scf_transaction_t *tran = NULL;
1529 	boolean_t new_pg = B_FALSE;
1530 	int rv = 0;
1531 	char *fmri;
1532 
1533 	if (exact_instance(TRILL_SVC_NAME, &sstate) != DLADM_STATUS_OK)
1534 		return;
1535 
1536 	if (scf_service_get_instance(sstate.ss_svc, bridge, sstate.ss_inst) !=
1537 	    0)
1538 		goto out;
1539 	if ((tran = scf_transaction_create(sstate.ss_handle)) == NULL)
1540 		goto out;
1541 	if ((sstate.ss_pg = scf_pg_create(sstate.ss_handle)) == NULL)
1542 		goto out;
1543 	if (scf_instance_add_pg(sstate.ss_inst, "config",
1544 	    SCF_GROUP_APPLICATION, 0, sstate.ss_pg) == 0) {
1545 		new_pg = B_TRUE;
1546 	} else if (scf_instance_get_pg(sstate.ss_inst, "config",
1547 	    sstate.ss_pg) != 0) {
1548 		goto out;
1549 	}
1550 	do {
1551 		if (scf_transaction_start(tran, sstate.ss_pg) != 0)
1552 			goto out;
1553 		if (!set_count_property(sstate.ss_handle, tran, "nickname",
1554 		    nick))
1555 			goto out;
1556 		rv = scf_transaction_commit(tran);
1557 		scf_transaction_reset(tran);
1558 		if (rv == 0 && scf_pg_update(sstate.ss_pg) == -1)
1559 			goto out;
1560 	} while (rv == 0);
1561 
1562 out:
1563 	if (tran != NULL) {
1564 		scf_transaction_destroy_children(tran);
1565 		scf_transaction_destroy(tran);
1566 	}
1567 
1568 	if (rv != 1 && new_pg)
1569 		(void) scf_pg_delete(sstate.ss_pg);
1570 
1571 	drop_composed(&sstate);
1572 	shut_down_scf(&sstate);
1573 	if (rv == 1 && (fmri = alloc_fmri(TRILL_SVC_NAME, bridge)) != NULL) {
1574 		(void) smf_refresh_instance(fmri);
1575 		free(fmri);
1576 	}
1577 }
1578