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 /* 23 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2016-2017, Chris Fraire <cfraire@me.com>. 25 */ 26 27 /* 28 * Main door handler functions used by ipmgmtd to process the different door 29 * call requests, issued by the library libipadm.so. 30 */ 31 32 #include <alloca.h> 33 #include <pwd.h> 34 #include <auth_attr.h> 35 #include <secdb.h> 36 #include <stdlib.h> 37 #include <stdio.h> 38 #include <string.h> 39 #include <strings.h> 40 #include <errno.h> 41 #include <assert.h> 42 #include <libnvpair.h> 43 #include "ipmgmt_impl.h" 44 45 /* Handler declaration for each door command */ 46 typedef void ipmgmt_door_handler_t(void *argp); 47 48 static ipmgmt_door_handler_t ipmgmt_getaddr_handler, 49 ipmgmt_getprop_handler, 50 ipmgmt_getif_handler, 51 ipmgmt_initif_handler, 52 ipmgmt_aobjop_handler, 53 ipmgmt_resetaddr_handler, 54 ipmgmt_setif_handler, 55 ipmgmt_resetif_handler, 56 ipmgmt_resetprop_handler, 57 ipmgmt_setaddr_handler, 58 ipmgmt_setprop_handler; 59 60 typedef struct ipmgmt_door_info_s { 61 uint_t idi_cmd; 62 boolean_t idi_set; 63 ipmgmt_door_handler_t *idi_handler; 64 } ipmgmt_door_info_t; 65 66 /* maps door commands to door handler functions */ 67 static ipmgmt_door_info_t i_ipmgmt_door_info_tbl[] = { 68 { IPMGMT_CMD_SETPROP, B_TRUE, ipmgmt_setprop_handler }, 69 { IPMGMT_CMD_SETIF, B_TRUE, ipmgmt_setif_handler }, 70 { IPMGMT_CMD_SETADDR, B_TRUE, ipmgmt_setaddr_handler }, 71 { IPMGMT_CMD_GETPROP, B_FALSE, ipmgmt_getprop_handler }, 72 { IPMGMT_CMD_GETIF, B_FALSE, ipmgmt_getif_handler }, 73 { IPMGMT_CMD_GETADDR, B_FALSE, ipmgmt_getaddr_handler }, 74 { IPMGMT_CMD_RESETIF, B_TRUE, ipmgmt_resetif_handler }, 75 { IPMGMT_CMD_RESETADDR, B_TRUE, ipmgmt_resetaddr_handler }, 76 { IPMGMT_CMD_RESETPROP, B_TRUE, ipmgmt_resetprop_handler }, 77 { IPMGMT_CMD_INITIF, B_TRUE, ipmgmt_initif_handler }, 78 { IPMGMT_CMD_ADDROBJ_LOOKUPADD, B_TRUE, ipmgmt_aobjop_handler }, 79 { IPMGMT_CMD_ADDROBJ_SETLIFNUM, B_TRUE, ipmgmt_aobjop_handler }, 80 { IPMGMT_CMD_ADDROBJ_ADD, B_TRUE, ipmgmt_aobjop_handler }, 81 { IPMGMT_CMD_AOBJNAME2ADDROBJ, B_FALSE, ipmgmt_aobjop_handler }, 82 { IPMGMT_CMD_LIF2ADDROBJ, B_FALSE, ipmgmt_aobjop_handler }, 83 { 0, 0, NULL }, 84 }; 85 86 /* 87 * The main server procedure function that gets invoked for any of the incoming 88 * door commands. Inside this function we identify the incoming command and 89 * invoke the right door handler function. 90 */ 91 /* ARGSUSED */ 92 void 93 ipmgmt_handler(void *cookie, char *argp, size_t argsz, door_desc_t *dp, 94 uint_t n_desc) 95 { 96 ipmgmt_door_info_t *infop = NULL; 97 ipmgmt_retval_t retval; 98 int i; 99 uint_t err; 100 ucred_t *cred = NULL; 101 102 for (i = 0; i_ipmgmt_door_info_tbl[i].idi_cmd != 0; i++) { 103 if (i_ipmgmt_door_info_tbl[i].idi_cmd == 104 ((ipmgmt_arg_t *)(void *)argp)->ia_cmd) { 105 infop = &i_ipmgmt_door_info_tbl[i]; 106 break; 107 } 108 } 109 110 if (infop == NULL) { 111 ipmgmt_log(LOG_ERR, "Invalid door command specified"); 112 err = EINVAL; 113 goto fail; 114 } 115 116 /* check for solaris.network.interface.config authorization */ 117 if (infop->idi_set) { 118 uid_t uid; 119 struct passwd pwd; 120 char buf[1024]; 121 122 if (door_ucred(&cred) != 0) { 123 err = errno; 124 ipmgmt_log(LOG_ERR, "Could not get user credentials."); 125 goto fail; 126 } 127 uid = ucred_getruid(cred); 128 if ((int)uid < 0) { 129 err = errno; 130 ipmgmt_log(LOG_ERR, "Could not get user id."); 131 goto fail; 132 } 133 if (getpwuid_r(uid, &pwd, buf, sizeof (buf)) == 134 NULL) { 135 err = errno; 136 ipmgmt_log(LOG_ERR, "Could not get password entry."); 137 goto fail; 138 } 139 if (chkauthattr(NETWORK_INTERFACE_CONFIG_AUTH, 140 pwd.pw_name) != 1) { 141 err = EPERM; 142 ipmgmt_log(LOG_ERR, "Not authorized for operation."); 143 goto fail; 144 } 145 ucred_free(cred); 146 } 147 148 /* individual handlers take care of calling door_return */ 149 infop->idi_handler((void *)argp); 150 return; 151 fail: 152 ucred_free(cred); 153 retval.ir_err = err; 154 (void) door_return((char *)&retval, sizeof (retval), NULL, 0); 155 } 156 157 /* 158 * Handles the door command IPMGMT_CMD_GETPROP. It retrieves the persisted 159 * property value for the given property. 160 */ 161 static void 162 ipmgmt_getprop_handler(void *argp) 163 { 164 ipmgmt_prop_arg_t *pargp = argp; 165 ipmgmt_getprop_rval_t rval, *rvalp = &rval; 166 167 assert(pargp->ia_cmd == IPMGMT_CMD_GETPROP); 168 169 rvalp->ir_err = ipmgmt_db_walk(ipmgmt_db_getprop, pargp, IPADM_DB_READ); 170 if (rvalp->ir_err == 0) 171 (void) strlcpy(rvalp->ir_pval, pargp->ia_pval, 172 sizeof (rvalp->ir_pval)); 173 (void) door_return((char *)rvalp, sizeof (*rvalp), NULL, 0); 174 } 175 176 /* 177 * Handles the door command IPMGMT_CMD_SETPROP. It persists the property value 178 * for the given property in the DB. 179 */ 180 static void 181 ipmgmt_setprop_handler(void *argp) 182 { 183 ipmgmt_prop_arg_t *pargp = argp; 184 ipmgmt_retval_t rval; 185 ipadm_dbwrite_cbarg_t cb; 186 nvlist_t *nvl = NULL; 187 int err; 188 189 assert(pargp->ia_cmd == IPMGMT_CMD_SETPROP); 190 191 if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0) 192 goto fail; 193 if (pargp->ia_module[0] != '\0' && 194 (err = nvlist_add_string(nvl, IPADM_NVP_PROTONAME, 195 pargp->ia_module)) != 0) { 196 goto fail; 197 } 198 if (pargp->ia_ifname[0] != '\0' && 199 (err = nvlist_add_string(nvl, IPADM_NVP_IFNAME, 200 pargp->ia_ifname)) != 0) 201 goto fail; 202 if (pargp->ia_aobjname[0] != '\0' && 203 (err = nvlist_add_string(nvl, IPADM_NVP_AOBJNAME, 204 pargp->ia_aobjname)) != 0) 205 goto fail; 206 if ((err = nvlist_add_string(nvl, pargp->ia_pname, 207 pargp->ia_pval)) != 0) 208 goto fail; 209 210 cb.dbw_nvl = nvl; 211 cb.dbw_flags = pargp->ia_flags; 212 err = ipmgmt_db_walk(ipmgmt_db_update, &cb, IPADM_DB_WRITE); 213 fail: 214 nvlist_free(nvl); 215 rval.ir_err = err; 216 (void) door_return((char *)&rval, sizeof (rval), NULL, 0); 217 } 218 219 /* 220 * Helper function for ipmgmt_setaddr_handler(). 221 * It converts the nvlist_t, `nvl', to aobjmap node `nodep'. 222 */ 223 static int 224 i_ipmgmt_nvl2aobjnode(nvlist_t *nvl, ipmgmt_aobjmap_t *nodep) 225 { 226 char *aobjname = NULL, *ifname = NULL; 227 int32_t lnum; 228 nvlist_t *nvladdr; 229 sa_family_t af = AF_UNSPEC; 230 ipadm_addr_type_t addrtype = IPADM_ADDR_NONE; 231 int err = 0; 232 233 /* 234 * Retrieve all the information needed to build '*nodep' from 235 * nvlist_t nvl. 236 */ 237 if ((err = nvlist_lookup_string(nvl, IPADM_NVP_AOBJNAME, 238 &aobjname)) != 0 || 239 (err = nvlist_lookup_string(nvl, IPADM_NVP_IFNAME, &ifname)) != 0 || 240 (err = nvlist_lookup_int32(nvl, IPADM_NVP_LIFNUM, &lnum)) != 0) { 241 return (err); 242 } 243 if (nvlist_exists(nvl, IPADM_NVP_IPV4ADDR)) { 244 af = AF_INET; 245 addrtype = IPADM_ADDR_STATIC; 246 } else if (nvlist_lookup_nvlist(nvl, IPADM_NVP_DHCP, &nvladdr) == 0) { 247 char *reqhost; 248 249 af = AF_INET; 250 addrtype = IPADM_ADDR_DHCP; 251 252 /* 253 * ipmgmt_am_reqhost comes through in `nvl' for purposes of 254 * updating the cached representation, but it is persisted as 255 * a stand-alone DB line; so remove it after copying it. 256 */ 257 if (!nvlist_exists(nvl, IPADM_NVP_REQHOST)) { 258 *nodep->ipmgmt_am_reqhost = '\0'; 259 } else { 260 if ((err = nvlist_lookup_string(nvl, IPADM_NVP_REQHOST, 261 &reqhost)) != 0) 262 return (err); 263 264 (void) strlcpy(nodep->ipmgmt_am_reqhost, reqhost, 265 sizeof (nodep->ipmgmt_am_reqhost)); 266 (void) nvlist_remove(nvl, IPADM_NVP_REQHOST, 267 DATA_TYPE_STRING); 268 } 269 } else if (nvlist_exists(nvl, IPADM_NVP_IPV6ADDR)) { 270 af = AF_INET6; 271 addrtype = IPADM_ADDR_STATIC; 272 } else if (nvlist_lookup_nvlist(nvl, IPADM_NVP_INTFID, &nvladdr) == 0) { 273 struct sockaddr_in6 sin6 = {0}; 274 uint8_t *addr6; 275 uint32_t plen; 276 uint_t n; 277 278 af = AF_INET6; 279 addrtype = IPADM_ADDR_IPV6_ADDRCONF; 280 if (nvlist_lookup_uint32(nvladdr, IPADM_NVP_PREFIXLEN, 281 &plen) != 0) 282 return (EINVAL); 283 if (plen != 0) { 284 if (nvlist_lookup_uint8_array(nvladdr, 285 IPADM_NVP_IPNUMADDR, &addr6, &n) != 0) 286 return (EINVAL); 287 bcopy(addr6, &sin6.sin6_addr, n); 288 } 289 290 nodep->ipmgmt_am_linklocal = B_TRUE; 291 nodep->ipmgmt_am_ifid = sin6; 292 } 293 294 /* 295 * populate the non-addrtype-specific `*nodep' with retrieved values. 296 */ 297 (void) strlcpy(nodep->am_ifname, ifname, sizeof (nodep->am_ifname)); 298 (void) strlcpy(nodep->am_aobjname, aobjname, 299 sizeof (nodep->am_aobjname)); 300 nodep->am_lnum = lnum; 301 nodep->am_family = af; 302 nodep->am_atype = addrtype; 303 nodep->am_next = NULL; 304 305 /* 306 * Do not store logical interface number in persistent store as it 307 * takes different value on reboot. So remove it from `nvl'. 308 */ 309 if (nvlist_exists(nvl, IPADM_NVP_LIFNUM)) 310 (void) nvlist_remove(nvl, IPADM_NVP_LIFNUM, DATA_TYPE_INT32); 311 312 return (0); 313 } 314 315 /* 316 * Handles the door command IPMGMT_CMD_SETADDR. It adds a new address object 317 * node to the list `aobjmap' and optionally persists the address 318 * information in the DB. 319 */ 320 static void 321 ipmgmt_setaddr_handler(void *argp) 322 { 323 ipmgmt_setaddr_arg_t *sargp = argp; 324 ipmgmt_retval_t rval; 325 ipmgmt_aobjmap_t node = {0}; 326 nvlist_t *nvl = NULL; 327 char *nvlbuf; 328 size_t nvlsize = sargp->ia_nvlsize; 329 uint32_t flags = sargp->ia_flags; 330 int err = 0; 331 332 nvlbuf = (char *)argp + sizeof (ipmgmt_setaddr_arg_t); 333 if ((err = nvlist_unpack(nvlbuf, nvlsize, &nvl, NV_ENCODE_NATIVE)) != 0) 334 goto ret; 335 if (flags & (IPMGMT_ACTIVE|IPMGMT_INIT)) { 336 if ((err = i_ipmgmt_nvl2aobjnode(nvl, &node)) != 0) 337 goto ret; 338 if (flags & IPMGMT_INIT) 339 node.am_flags = (IPMGMT_ACTIVE|IPMGMT_PERSIST); 340 else 341 node.am_flags = flags & ~IPMGMT_PROPS_ONLY; 342 if ((err = ipmgmt_aobjmap_op(&node, ADDROBJ_ADD)) != 0) 343 goto ret; 344 } 345 if ((flags & IPMGMT_PERSIST) && !(flags & IPMGMT_PROPS_ONLY)) { 346 ipadm_dbwrite_cbarg_t cb; 347 348 cb.dbw_nvl = nvl; 349 cb.dbw_flags = 0; 350 err = ipmgmt_db_walk(ipmgmt_db_add, &cb, IPADM_DB_WRITE); 351 } 352 ret: 353 nvlist_free(nvl); 354 rval.ir_err = err; 355 (void) door_return((char *)&rval, sizeof (rval), NULL, 0); 356 } 357 358 /* 359 * Handles the door commands that read or modify the `aobjmap' structure. 360 * 361 * IPMGMT_CMD_ADDROBJ_LOOKUPADD - places a stub address object in `aobjmap' 362 * after ensuring that the namespace is not taken. If required, also 363 * generates an `aobjname' for address object for the library to use. 364 * IPMGMT_CMD_ADDROBJ_ADD - add/update address object in `aobjmap' 365 * IPMGMT_CMD_LIF2ADDROBJ - given a logical interface, return address object 366 * associated with that logical interface. 367 * IPMGMT_CMD_AOBJNAME2ADDROBJ - given an address object name return logical 368 * interface associated with that address object. 369 */ 370 static void 371 ipmgmt_aobjop_handler(void *argp) 372 { 373 ipmgmt_aobjop_arg_t *largp = argp; 374 ipmgmt_retval_t rval; 375 ipmgmt_aobjop_rval_t aobjrval; 376 void *rvalp; 377 size_t rsize; 378 ipmgmt_aobjmap_t node; 379 int err = 0; 380 char *ifname = largp->ia_ifname; 381 char *aobjname = largp->ia_aobjname; 382 int32_t lnum = largp->ia_lnum; 383 sa_family_t af = largp->ia_family; 384 ipadm_addr_type_t atype = largp->ia_atype; 385 ipmgmt_aobjmap_t *head; 386 387 switch (largp->ia_cmd) { 388 case IPMGMT_CMD_ADDROBJ_LOOKUPADD: 389 rsize = sizeof (ipmgmt_aobjop_rval_t); 390 rvalp = &aobjrval; 391 bzero(&node, sizeof (node)); 392 (void) strlcpy(node.am_aobjname, aobjname, 393 sizeof (node.am_aobjname)); 394 (void) strlcpy(node.am_ifname, ifname, 395 sizeof (node.am_ifname)); 396 node.am_family = af; 397 node.am_atype = atype; 398 /* no logical number is associated with this addrobj yet */ 399 node.am_lnum = -1; 400 /* The address object is not persisted yet. */ 401 node.am_flags = IPMGMT_ACTIVE; 402 err = ipmgmt_aobjmap_op(&node, ADDROBJ_LOOKUPADD); 403 if (err == 0) { 404 (void) strlcpy(aobjrval.ir_aobjname, node.am_aobjname, 405 sizeof (aobjrval.ir_aobjname)); 406 } 407 break; 408 case IPMGMT_CMD_ADDROBJ_SETLIFNUM: 409 rsize = sizeof (ipmgmt_retval_t); 410 rvalp = &rval; 411 bzero(&node, sizeof (node)); 412 (void) strlcpy(node.am_aobjname, aobjname, 413 sizeof (node.am_aobjname)); 414 (void) strlcpy(node.am_ifname, ifname, 415 sizeof (node.am_ifname)); 416 node.am_family = af; 417 node.am_lnum = lnum; 418 err = ipmgmt_aobjmap_op(&node, ADDROBJ_SETLIFNUM); 419 break; 420 case IPMGMT_CMD_ADDROBJ_ADD: 421 rsize = sizeof (ipmgmt_retval_t); 422 rvalp = &rval; 423 if (aobjname[0] == '\0' || ifname[0] == '\0' || lnum == -1 || 424 af == AF_UNSPEC) { 425 err = EINVAL; 426 break; 427 } 428 bzero(&node, sizeof (node)); 429 (void) strlcpy(node.am_aobjname, aobjname, 430 sizeof (node.am_aobjname)); 431 (void) strlcpy(node.am_ifname, ifname, 432 sizeof (node.am_ifname)); 433 node.am_atype = atype; 434 node.am_lnum = lnum; 435 node.am_family = af; 436 /* The address object is not persisted. */ 437 node.am_flags = IPMGMT_ACTIVE; 438 err = ipmgmt_aobjmap_op(&node, ADDROBJ_ADD); 439 break; 440 case IPMGMT_CMD_AOBJNAME2ADDROBJ: 441 rsize = sizeof (ipmgmt_aobjop_rval_t); 442 rvalp = &aobjrval; 443 bzero(&aobjrval, sizeof (aobjrval)); 444 if (aobjname[0] == '\0') { 445 err = EINVAL; 446 break; 447 } 448 (void) pthread_rwlock_rdlock(&aobjmap.aobjmap_rwlock); 449 head = aobjmap.aobjmap_head; 450 for (; head; head = head->am_next) { 451 if (strcmp(head->am_aobjname, aobjname) != 0) 452 continue; 453 /* 454 * For an auto-configured interface, return 455 * the lifnum that has the link-local on it. 456 * Other logical interfaces were created for 457 * prefixes and dhcpv6 addresses and do not 458 * have am_ifid set. 459 */ 460 if (head->am_atype != IPADM_ADDR_IPV6_ADDRCONF || 461 head->ipmgmt_am_linklocal) { 462 break; 463 } 464 } 465 if (head == NULL) { 466 err = ENOENT; 467 (void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock); 468 break; 469 } 470 (void) strlcpy(aobjrval.ir_ifname, head->am_ifname, 471 sizeof (aobjrval.ir_ifname)); 472 aobjrval.ir_lnum = head->am_lnum; 473 aobjrval.ir_family = head->am_family; 474 aobjrval.ir_flags = head->am_flags; 475 aobjrval.ir_atype = head->am_atype; 476 aobjrval.ir_atype_cache = head->am_atype_cache; 477 (void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock); 478 break; 479 case IPMGMT_CMD_LIF2ADDROBJ: 480 rsize = sizeof (ipmgmt_aobjop_rval_t); 481 rvalp = &aobjrval; 482 bzero(&aobjrval, sizeof (aobjrval)); 483 if (ifname[0] == '\0') { 484 err = EINVAL; 485 break; 486 } 487 (void) pthread_rwlock_rdlock(&aobjmap.aobjmap_rwlock); 488 head = aobjmap.aobjmap_head; 489 for (; head; head = head->am_next) { 490 if (strcmp(head->am_ifname, ifname) == 0 && 491 head->am_lnum == lnum && 492 head->am_family == af) { 493 break; 494 } 495 } 496 if (head == NULL) { 497 err = ENOENT; 498 (void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock); 499 break; 500 } 501 (void) strlcpy(aobjrval.ir_aobjname, head->am_aobjname, 502 sizeof (aobjrval.ir_aobjname)); 503 aobjrval.ir_atype = head->am_atype; 504 aobjrval.ir_flags = head->am_flags; 505 aobjrval.ir_atype_cache = head->am_atype_cache; 506 (void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock); 507 break; 508 default: 509 rsize = sizeof (ipmgmt_retval_t); 510 rvalp = &rval; 511 err = EINVAL; 512 } 513 ((ipmgmt_retval_t *)rvalp)->ir_err = err; 514 (void) door_return((char *)rvalp, rsize, NULL, 0); 515 } 516 517 /* 518 * Given an interface name and family, deletes all the address objects 519 * associated with it. 520 */ 521 void 522 i_ipmgmt_delif_aobjs(char *ifname, sa_family_t af, uint32_t flags) 523 { 524 ipmgmt_aobjmap_t *head, *next, *prev; 525 ipadm_db_op_t db_op; 526 527 prev = NULL; 528 529 (void) pthread_rwlock_wrlock(&aobjmap.aobjmap_rwlock); 530 head = aobjmap.aobjmap_head; 531 for (; head; head = next) { 532 next = head->am_next; 533 if (strcmp(head->am_ifname, ifname) != 0 || 534 head->am_family != af) { 535 prev = head; 536 continue; 537 } 538 539 if (head->am_flags == (IPMGMT_ACTIVE|IPMGMT_PERSIST) && 540 flags == IPMGMT_ACTIVE) { 541 /* 542 * If the addres is present in both active and 543 * persistent store, and if we are performing 544 * a temporary delete, we update the node to 545 * indicate that the address is only present in 546 * persistent store and we proceed. Otherwise 547 * we always delete the node from aobjmap. 548 */ 549 head->am_flags &= ~IPMGMT_ACTIVE; 550 head->am_lnum = -1; 551 db_op = IPADM_DB_WRITE; 552 } else { 553 db_op = IPADM_DB_DELETE; 554 if (prev == NULL) 555 aobjmap.aobjmap_head = next; 556 else 557 prev->am_next = next; 558 } 559 (void) ipmgmt_persist_aobjmap(head, db_op); 560 if (db_op == IPADM_DB_DELETE) 561 free(head); 562 } 563 (void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock); 564 } 565 566 /* 567 * Handles the door command IPMGMT_CMD_SETIF. It persists the interface 568 * information in the DB. 569 */ 570 static void 571 ipmgmt_setif_handler(void *argp) 572 { 573 ipmgmt_retval_t rval; 574 575 rval.ir_err = ipmgmt_persist_if(argp); 576 (void) door_return((char *)&rval, sizeof (rval), NULL, 0); 577 } 578 579 /* 580 * Handles the door command IPMGMT_CMD_RESETIF. For the given interface, 581 * deletes all the persisted interface configuration. It also deletes, from 582 * `aobjmap', all the address objects configured on the given interface. 583 */ 584 static void 585 ipmgmt_resetif_handler(void *argp) 586 { 587 ipmgmt_if_arg_t *rargp = argp; 588 ipmgmt_retval_t rval; 589 ipmgmt_if_cbarg_t cbarg; 590 uint32_t flags = rargp->ia_flags; 591 int err = 0; 592 593 cbarg.cb_family = rargp->ia_family; 594 cbarg.cb_ifname = rargp->ia_ifname; 595 if (flags & IPMGMT_PERSIST) 596 err = ipmgmt_db_walk(ipmgmt_db_resetif, &cbarg, 597 IPADM_DB_DELETE); 598 599 if (flags & IPMGMT_ACTIVE) 600 i_ipmgmt_delif_aobjs(rargp->ia_ifname, rargp->ia_family, 601 flags); 602 603 rval.ir_err = err; 604 (void) door_return((char *)&rval, sizeof (rval), NULL, 0); 605 } 606 607 /* 608 * Handles the door command IPMGMT_CMD_RESETADDR. For the given addrobj 609 * deletes all the persisted addrobj configuration. It also deletes the 610 * corresponding node, from `aobjmap'. 611 */ 612 static void 613 ipmgmt_resetaddr_handler(void *argp) 614 { 615 ipmgmt_addr_arg_t *rargp = argp; 616 ipmgmt_retval_t rval; 617 ipmgmt_aobjmap_t node; 618 uint32_t flags = rargp->ia_flags; 619 int err = 0; 620 ipmgmt_resetaddr_cbarg_t cbarg; 621 622 cbarg.cb_aobjname = rargp->ia_aobjname; 623 624 if (flags & IPMGMT_PERSIST) 625 err = ipmgmt_db_walk(ipmgmt_db_resetaddr, &cbarg, 626 IPADM_DB_DELETE); 627 628 if (flags & IPMGMT_ACTIVE) { 629 bzero(&node, sizeof (node)); 630 (void) strlcpy(node.am_aobjname, rargp->ia_aobjname, 631 sizeof (node.am_aobjname)); 632 633 /* 634 * am_lnum is used only for IPv6 autoconf case, since there 635 * can be multiple nodes with the same aobjname. 636 */ 637 node.am_lnum = rargp->ia_lnum; 638 node.am_flags = flags; 639 (void) ipmgmt_aobjmap_op(&node, ADDROBJ_DELETE); 640 } 641 642 rval.ir_err = err; 643 (void) door_return((char *)&rval, sizeof (rval), NULL, 0); 644 } 645 646 /* 647 * Handles the door command IPMGMT_CMD_GETADDR. It retrieves the persisted 648 * address for a given `gargp->ia_aobjname'. If it is not defined then it 649 * retrieves all the addresses configured on `gargp->ia_ifname'. The 650 * "ipadm show-addr addrobj" or "ipadm show-addr <ifname>/\*" will call this 651 * handler through library. 652 */ 653 static void 654 ipmgmt_getaddr_handler(void *argp) 655 { 656 size_t buflen, onvlsize; 657 char *buf, *onvlbuf; 658 ipmgmt_getaddr_arg_t *gargp = argp; 659 ipmgmt_getaddr_cbarg_t cbarg; 660 ipmgmt_get_rval_t rval, *rvalp = &rval; 661 int err = 0; 662 663 cbarg.cb_ifname = gargp->ia_ifname; 664 cbarg.cb_aobjname = gargp->ia_aobjname; 665 cbarg.cb_ocnt = 0; 666 if (nvlist_alloc(&cbarg.cb_onvl, NV_UNIQUE_NAME, 0) != 0) 667 goto fail; 668 err = ipmgmt_db_walk(ipmgmt_db_getaddr, &cbarg, IPADM_DB_READ); 669 if (err == ENOENT && cbarg.cb_ocnt > 0) { 670 /* 671 * If there is atleast one entry in the nvlist, 672 * do not return error. 673 */ 674 err = 0; 675 } 676 if (err != 0) 677 goto fail; 678 679 if ((err = nvlist_size(cbarg.cb_onvl, &onvlsize, 680 NV_ENCODE_NATIVE)) != 0) { 681 goto fail; 682 } 683 buflen = onvlsize + sizeof (ipmgmt_get_rval_t); 684 /* 685 * We cannot use malloc() here because door_return never returns, and 686 * memory allocated by malloc() would get leaked. Use alloca() instead. 687 */ 688 buf = alloca(buflen); 689 onvlbuf = buf + sizeof (ipmgmt_get_rval_t); 690 if ((err = nvlist_pack(cbarg.cb_onvl, &onvlbuf, &onvlsize, 691 NV_ENCODE_NATIVE, 0)) != 0) { 692 goto fail; 693 } 694 nvlist_free(cbarg.cb_onvl); 695 rvalp = (ipmgmt_get_rval_t *)(void *)buf; 696 rvalp->ir_err = 0; 697 rvalp->ir_nvlsize = onvlsize; 698 699 (void) door_return(buf, buflen, NULL, 0); 700 return; 701 fail: 702 nvlist_free(cbarg.cb_onvl); 703 rvalp->ir_err = err; 704 (void) door_return((char *)rvalp, sizeof (*rvalp), NULL, 0); 705 } 706 707 /* 708 * Handles the door command IPMGMT_CMD_RESETPROP. It deletes the property line 709 * from the DB. 710 */ 711 static void 712 ipmgmt_resetprop_handler(void *argp) 713 { 714 ipmgmt_prop_arg_t *pargp = argp; 715 ipmgmt_retval_t rval; 716 717 assert(pargp->ia_cmd == IPMGMT_CMD_RESETPROP); 718 719 rval.ir_err = ipmgmt_db_walk(ipmgmt_db_resetprop, pargp, 720 IPADM_DB_DELETE); 721 (void) door_return((char *)&rval, sizeof (rval), NULL, 0); 722 } 723 724 /* 725 * Handles the door command IPMGMT_CMD_GETIF. It retrieves the name of all the 726 * persisted interfaces and the IP protocols (IPv4 or IPv6) they support. 727 */ 728 static void 729 ipmgmt_getif_handler(void *argp) 730 { 731 ipmgmt_getif_arg_t *getif = argp; 732 ipmgmt_getif_rval_t *rvalp; 733 ipmgmt_retval_t rval; 734 ipmgmt_getif_cbarg_t cbarg; 735 ipadm_if_info_t *ifp, *rifp, *curifp; 736 int i, err = 0, count = 0; 737 size_t rbufsize; 738 739 assert(getif->ia_cmd == IPMGMT_CMD_GETIF); 740 741 bzero(&cbarg, sizeof (cbarg)); 742 cbarg.cb_ifname = getif->ia_ifname; 743 err = ipmgmt_db_walk(ipmgmt_db_getif, &cbarg, IPADM_DB_READ); 744 if (err == ENOENT && cbarg.cb_ifinfo) { 745 /* 746 * If there is atleast one entry in the nvlist, 747 * do not return error. 748 */ 749 err = 0; 750 } 751 if (err != 0) { 752 rval.ir_err = err; 753 (void) door_return((char *)&rval, sizeof (rval), NULL, 0); 754 return; 755 } 756 757 /* allocate sufficient buffer to return the interface info */ 758 for (ifp = cbarg.cb_ifinfo; ifp != NULL; ifp = ifp->ifi_next) 759 ++count; 760 rbufsize = sizeof (*rvalp) + count * sizeof (*ifp); 761 rvalp = alloca(rbufsize); 762 bzero(rvalp, rbufsize); 763 764 rvalp->ir_ifcnt = count; 765 rifp = rvalp->ir_ifinfo; 766 ifp = cbarg.cb_ifinfo; 767 768 /* 769 * copy the interface info to buffer allocated on stack. The reason 770 * we do this is to avoid memory leak, as door_return() would never 771 * return 772 */ 773 for (i = 0; i < count; i++) { 774 rifp = rvalp->ir_ifinfo + i; 775 (void) bcopy(ifp, rifp, sizeof (*rifp)); 776 rifp->ifi_next = NULL; 777 curifp = ifp->ifi_next; 778 free(ifp); 779 ifp = curifp; 780 } 781 rvalp->ir_err = err; 782 (void) door_return((char *)rvalp, rbufsize, NULL, 0); 783 } 784 785 /* 786 * Handles the door command IPMGMT_CMD_INITIF. It retrieves all the persisted 787 * interface configuration (interface properties and addresses), for all those 788 * interfaces that need to be initialized. 789 */ 790 static void 791 ipmgmt_initif_handler(void *argp) 792 { 793 ipmgmt_initif_arg_t *initif = argp; 794 size_t buflen, nvlsize; 795 char *buf = NULL, *onvlbuf, *invlbuf; 796 ipmgmt_get_rval_t rval, *rvalp = &rval; 797 ipmgmt_initif_cbarg_t cbarg; 798 int err; 799 800 assert(initif->ia_cmd == IPMGMT_CMD_INITIF); 801 802 bzero(&cbarg, sizeof (cbarg)); 803 invlbuf = (char *)argp + sizeof (ipmgmt_initif_arg_t); 804 nvlsize = initif->ia_nvlsize; 805 err = nvlist_unpack(invlbuf, nvlsize, &cbarg.cb_invl, NV_ENCODE_NATIVE); 806 if (err != 0) 807 goto fail; 808 809 cbarg.cb_family = initif->ia_family; 810 if (nvlist_alloc(&cbarg.cb_onvl, NV_UNIQUE_NAME, 0) != 0) 811 goto fail; 812 813 err = ipmgmt_db_walk(ipmgmt_db_initif, &cbarg, IPADM_DB_READ); 814 if (err == ENOENT && cbarg.cb_ocnt > 0) { 815 /* 816 * If there is atleast one entry in the nvlist, 817 * do not return error. 818 */ 819 err = 0; 820 } 821 if (err != 0) 822 goto fail; 823 824 if ((err = nvlist_size(cbarg.cb_onvl, &nvlsize, NV_ENCODE_NATIVE)) != 0) 825 goto fail; 826 buflen = nvlsize + sizeof (ipmgmt_get_rval_t); 827 /* 828 * We cannot use malloc() here because door_return never returns, and 829 * memory allocated by malloc() would get leaked. Use alloca() instead. 830 */ 831 buf = alloca(buflen); 832 onvlbuf = buf + sizeof (ipmgmt_get_rval_t); 833 if ((err = nvlist_pack(cbarg.cb_onvl, &onvlbuf, &nvlsize, 834 NV_ENCODE_NATIVE, 0)) != 0) { 835 goto fail; 836 } 837 nvlist_free(cbarg.cb_invl); 838 nvlist_free(cbarg.cb_onvl); 839 rvalp = (ipmgmt_get_rval_t *)(void *)buf; 840 rvalp->ir_err = 0; 841 rvalp->ir_nvlsize = nvlsize; 842 843 (void) door_return(buf, buflen, NULL, 0); 844 return; 845 fail: 846 nvlist_free(cbarg.cb_invl); 847 nvlist_free(cbarg.cb_onvl); 848 rvalp->ir_err = err; 849 (void) door_return((char *)rvalp, sizeof (*rvalp), NULL, 0); 850 } 851 852 int 853 ipmgmt_persist_if(ipmgmt_if_arg_t *sargp) 854 { 855 ipadm_dbwrite_cbarg_t cb; 856 uint32_t flags = sargp->ia_flags; 857 nvlist_t *nvl = NULL; 858 int err = 0; 859 char strval[IPMGMT_STRSIZE]; 860 861 if (!(flags & IPMGMT_PERSIST) || sargp->ia_family == AF_UNSPEC || 862 sargp->ia_ifname[0] == '\0') { 863 err = EINVAL; 864 goto ret; 865 } 866 if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0) 867 goto ret; 868 if ((err = nvlist_add_string(nvl, IPADM_NVP_IFNAME, 869 sargp->ia_ifname)) != 0) 870 goto ret; 871 (void) snprintf(strval, IPMGMT_STRSIZE, "%d", sargp->ia_family); 872 if ((err = nvlist_add_string(nvl, IPADM_NVP_FAMILY, strval)) != 0) 873 goto ret; 874 cb.dbw_nvl = nvl; 875 cb.dbw_flags = 0; 876 err = ipmgmt_db_walk(ipmgmt_db_add, &cb, IPADM_DB_WRITE); 877 ret: 878 nvlist_free(nvl); 879 return (err); 880 } 881