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 to read/write formatted entries from/to 27 * libipadm data store /etc/ipadm/ipadm.conf. Each entry in the DB is a 28 * series of IPADM_NVPAIR_SEP separated (name, value) pairs, as shown 29 * below: 30 * name=value[;...] 31 * 32 * The 'name' determines how to interpret 'value'. The supported names are: 33 * 34 * IPADM_NVP_IPV6ADDR - value holds local and remote IPv6 addresses and when 35 * converted to nvlist, will contain nvpairs for local and remote 36 * addresses. These nvpairs are of type DATA_TYPE_STRING 37 * 38 * IPADM_NVP_IPV4ADDR - value holds local and remote IPv4 addresses and when 39 * converted to nvlist, will contain nvpairs for local and remote 40 * addresses. These nvpairs are of type DATA_TYPE_STRING 41 * 42 * IPADM_NVP_INTFID - value holds token, prefixlen, stateless and stateful 43 * info and when converted to nvlist, will contain following nvpairs 44 * interface_id: DATA_TYPE_UINT8_ARRAY 45 * prefixlen: DATA_TYPE_UINT32 46 * stateless: DATA_TYPE_STRING 47 * stateful: DATA_TYPE_STRING 48 * 49 * IPADM_NVP_DHCP - value holds wait time and primary info and when converted 50 * to nvlist, will contain following nvpairs 51 * wait: DATA_TYPE_INT32 52 * primary: DATA_TYPE_BOOLEAN 53 * 54 * default - value is a single entity and when converted to nvlist, will 55 * contain nvpair of type DATA_TYPE_STRING. nvpairs private to 56 * ipadm are of this type. Further the property name and property 57 * values are stored as nvpairs of this type. 58 * 59 * The syntax for each line is described above the respective functions below. 60 */ 61 62 #include <stdlib.h> 63 #include <strings.h> 64 #include <errno.h> 65 #include <ctype.h> 66 #include <sys/types.h> 67 #include <sys/stat.h> 68 #include <sys/dld.h> 69 #include <fcntl.h> 70 #include <dirent.h> 71 #include <unistd.h> 72 #include <assert.h> 73 #include <sys/socket.h> 74 #include <netinet/in.h> 75 #include <arpa/inet.h> 76 #include <sys/sockio.h> 77 #include "libipadm_impl.h" 78 79 #define MAXLINELEN 1024 80 #define IPADM_NVPAIR_SEP ";" 81 #define IPADM_NAME_SEP "," 82 83 static char ipadm_rootdir[MAXPATHLEN] = "/"; 84 85 static int ipadm_process_db_line(db_wfunc_t *, void *, FILE *fp, FILE *nfp, 86 ipadm_db_op_t); 87 88 /* 89 * convert nvpair to a "name=value" string for writing to the DB. 90 */ 91 typedef size_t ipadm_wfunc_t(nvpair_t *, char *, size_t); 92 93 /* 94 * ipadm_rfunc_t takes (`name', `value') and adds the appropriately typed 95 * nvpair to the nvlist. 96 */ 97 typedef void ipadm_rfunc_t(nvlist_t *, char *name, char *value); 98 99 static ipadm_rfunc_t i_ipadm_str_dbline2nvl, i_ipadm_ip4_dbline2nvl, 100 i_ipadm_ip6_dbline2nvl, i_ipadm_intfid_dbline2nvl, 101 i_ipadm_dhcp_dbline2nvl; 102 103 static ipadm_wfunc_t i_ipadm_str_nvp2dbline, i_ipadm_ip4_nvp2dbline, 104 i_ipadm_ip6_nvp2dbline, i_ipadm_intfid_nvp2dbline, 105 i_ipadm_dhcp_nvp2dbline; 106 107 /* 108 * table of function pointers to read/write formatted entries from/to 109 * ipadm.conf. 110 */ 111 typedef struct ipadm_conf_ent_s { 112 const char *ipent_type_name; 113 ipadm_wfunc_t *ipent_wfunc; 114 ipadm_rfunc_t *ipent_rfunc; 115 } ipadm_conf_ent_t; 116 117 static ipadm_conf_ent_t ipadm_conf_ent[] = { 118 { IPADM_NVP_IPV6ADDR, i_ipadm_ip6_nvp2dbline, i_ipadm_ip6_dbline2nvl }, 119 { IPADM_NVP_IPV4ADDR, i_ipadm_ip4_nvp2dbline, i_ipadm_ip4_dbline2nvl }, 120 { IPADM_NVP_INTFID, i_ipadm_intfid_nvp2dbline, 121 i_ipadm_intfid_dbline2nvl }, 122 { IPADM_NVP_DHCP, i_ipadm_dhcp_nvp2dbline, i_ipadm_dhcp_dbline2nvl }, 123 { NULL, i_ipadm_str_nvp2dbline, i_ipadm_str_dbline2nvl } 124 }; 125 126 static ipadm_conf_ent_t * 127 i_ipadm_find_conf_type(const char *type) 128 { 129 int i; 130 131 for (i = 0; ipadm_conf_ent[i].ipent_type_name != NULL; i++) 132 if (strcmp(type, ipadm_conf_ent[i].ipent_type_name) == 0) 133 break; 134 return (&ipadm_conf_ent[i]); 135 } 136 137 /* 138 * Extracts the hostnames IPADM_NVP_IPADDRHNAME and IPADM_NVP_IPDADDRHNAME from 139 * the given nvlist `nvl' and adds the strings to `buf'. 140 */ 141 size_t 142 i_ipadm_ip_addhostname2dbline(nvlist_t *nvl, char *buf, size_t buflen) 143 { 144 char *cp; 145 char tmpbuf[IPADM_STRSIZE]; 146 147 /* Add the local hostname */ 148 if (nvlist_lookup_string(nvl, IPADM_NVP_IPADDRHNAME, &cp) != 0) 149 return (0); 150 (void) strlcat(buf, cp, buflen); /* local hostname */ 151 152 /* Add the dst hostname */ 153 if (nvlist_lookup_string(nvl, IPADM_NVP_IPDADDRHNAME, &cp) != 0) { 154 /* no dst addr. just add a NULL character */ 155 (void) snprintf(tmpbuf, sizeof (tmpbuf), ","); 156 } else { 157 (void) snprintf(tmpbuf, sizeof (tmpbuf), ",%s", cp); 158 } 159 return (strlcat(buf, tmpbuf, buflen)); 160 } 161 162 /* 163 * Converts IPADM_NVP_IPV4ADDR nvpair to a string representation for writing to 164 * the DB. The converted string format: 165 * ipv4addr=<local numeric IP string or hostname,remote numeric IP 166 * string or hostname> 167 */ 168 static size_t 169 i_ipadm_ip4_nvp2dbline(nvpair_t *nvp, char *buf, size_t buflen) 170 { 171 nvlist_t *v; 172 int nbytes; 173 174 assert(nvpair_type(nvp) == DATA_TYPE_NVLIST && 175 strcmp(nvpair_name(nvp), IPADM_NVP_IPV4ADDR) == 0); 176 177 (void) snprintf(buf, buflen, "%s=", IPADM_NVP_IPV4ADDR); 178 if (nvpair_value_nvlist(nvp, &v) != 0) 179 goto fail; 180 nbytes = i_ipadm_ip_addhostname2dbline(v, buf, buflen); 181 if (nbytes != 0) 182 return (nbytes); 183 fail: 184 buf[0] = '\0'; 185 return (0); 186 } 187 188 /* 189 * Converts IPADM_NVP_IPV6ADDR nvpair to a string representation for writing to 190 * the DB. The converted string format: 191 * ipv6addr=<local numeric IP string or hostname,remote numeric IP 192 * string or hostname> 193 */ 194 static size_t 195 i_ipadm_ip6_nvp2dbline(nvpair_t *nvp, char *buf, size_t buflen) 196 { 197 nvlist_t *v; 198 int nbytes; 199 200 assert(nvpair_type(nvp) == DATA_TYPE_NVLIST && 201 strcmp(nvpair_name(nvp), IPADM_NVP_IPV6ADDR) == 0); 202 203 (void) snprintf(buf, buflen, "%s=", IPADM_NVP_IPV6ADDR); 204 if (nvpair_value_nvlist(nvp, &v) != 0) 205 goto fail; 206 nbytes = i_ipadm_ip_addhostname2dbline(v, buf, buflen); 207 if (nbytes != 0) 208 return (nbytes); 209 fail: 210 buf[0] = '\0'; 211 return (0); 212 } 213 214 /* 215 * Converts IPADM_NVP_INTFID nvpair to a string representation for writing to 216 * the DB. The converted string format: 217 * IPADM_NVP_INTFID=<intfid/prefixlen>,{yes|no},{yes|no} 218 */ 219 static size_t 220 i_ipadm_intfid_nvp2dbline(nvpair_t *nvp, char *buf, size_t buflen) 221 { 222 char addrbuf[IPADM_STRSIZE]; 223 nvlist_t *v; 224 uint32_t prefixlen; 225 struct in6_addr in6addr; 226 char *stateless; 227 char *stateful; 228 229 assert(nvpair_type(nvp) == DATA_TYPE_NVLIST && 230 strcmp(nvpair_name(nvp), IPADM_NVP_INTFID) == 0); 231 232 (void) snprintf(buf, buflen, "%s=", IPADM_NVP_INTFID); 233 if (nvpair_value_nvlist(nvp, &v) != 0) 234 goto fail; 235 if (i_ipadm_nvl2in6_addr(v, IPADM_NVP_IPNUMADDR, &in6addr) != 236 IPADM_SUCCESS) 237 goto fail; 238 (void) inet_ntop(AF_INET6, &in6addr, addrbuf, 239 sizeof (addrbuf)); 240 (void) strlcat(buf, addrbuf, buflen); 241 if (nvlist_lookup_uint32(v, IPADM_NVP_PREFIXLEN, &prefixlen) != 0 || 242 nvlist_lookup_string(v, IPADM_NVP_STATELESS, &stateless) != 0 || 243 nvlist_lookup_string(v, IPADM_NVP_STATEFUL, &stateful) != 0) 244 goto fail; 245 (void) snprintf(addrbuf, sizeof (addrbuf), "/%d,%s,%s", 246 prefixlen, stateless, stateful); 247 return (strlcat(buf, addrbuf, buflen)); 248 fail: 249 buf[0] = '\0'; 250 return (0); 251 } 252 253 /* 254 * Converts IPADM_NVP_DHCP nvpair to a string representation for writing to the 255 * DB. The converted string format: 256 * IPADM_NVP_DHCP=<wait_time>,{yes|no} 257 */ 258 static size_t 259 i_ipadm_dhcp_nvp2dbline(nvpair_t *nvp, char *buf, size_t buflen) 260 { 261 char addrbuf[IPADM_STRSIZE]; 262 int32_t wait; 263 boolean_t primary; 264 nvlist_t *v; 265 266 assert(nvpair_type(nvp) == DATA_TYPE_NVLIST && 267 strcmp(nvpair_name(nvp), IPADM_NVP_DHCP) == 0); 268 269 if (nvpair_value_nvlist(nvp, &v) != 0 || 270 nvlist_lookup_int32(v, IPADM_NVP_WAIT, &wait) != 0 || 271 nvlist_lookup_boolean_value(v, IPADM_NVP_PRIMARY, &primary) != 0) { 272 return (0); 273 } 274 (void) snprintf(buf, buflen, "%s=", IPADM_NVP_DHCP); 275 (void) snprintf(addrbuf, sizeof (addrbuf), "%d,%s", wait, 276 (primary ? "yes" : "no")); 277 return (strlcat(buf, addrbuf, buflen)); 278 } 279 280 /* 281 * Constructs a "<name>=<value>" string from the nvpair, whose type must 282 * be STRING. 283 */ 284 static size_t 285 i_ipadm_str_nvp2dbline(nvpair_t *nvp, char *buf, size_t buflen) 286 { 287 char *str = NULL; 288 289 assert(nvpair_type(nvp) == DATA_TYPE_STRING); 290 if (nvpair_value_string(nvp, &str) != 0) 291 return (0); 292 return (snprintf(buf, buflen, "%s=%s", nvpair_name(nvp), str)); 293 } 294 295 /* 296 * Converts a nvlist to string of the form: 297 * <prop0>=<val0>,...,<valn>;...;<propn>=<val0>,...,<valn>; 298 */ 299 size_t 300 ipadm_nvlist2str(nvlist_t *nvl, char *buf, size_t buflen) 301 { 302 nvpair_t *nvp = NULL; 303 uint_t nbytes = 0, tbytes = 0; 304 ipadm_conf_ent_t *ipent; 305 size_t bufsize = buflen; 306 307 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL; 308 nvp = nvlist_next_nvpair(nvl, nvp)) { 309 ipent = i_ipadm_find_conf_type(nvpair_name(nvp)); 310 nbytes = (*ipent->ipent_wfunc)(nvp, buf, buflen); 311 /* add nvpair separator */ 312 nbytes += snprintf(buf + nbytes, buflen - nbytes, "%s", 313 IPADM_NVPAIR_SEP); 314 buflen -= nbytes; 315 buf += nbytes; 316 tbytes += nbytes; 317 if (tbytes >= bufsize) /* buffer overflow */ 318 return (0); 319 } 320 nbytes = snprintf(buf, buflen, "%c%c", '\n', '\0'); 321 tbytes += nbytes; 322 if (tbytes >= bufsize) 323 return (0); 324 return (tbytes); 325 } 326 327 /* 328 * Adds a nvpair, using the `name' and `value', to the nvlist in `nvl'. 329 * The value will be interpreted as explained at the top of this file. 330 */ 331 static void 332 i_ipadm_add_nvpair(nvlist_t *nvl, char *name, char *value) 333 { 334 ipadm_conf_ent_t *ipent; 335 336 ipent = i_ipadm_find_conf_type(name); 337 (*ipent->ipent_rfunc)(nvl, name, value); 338 } 339 340 /* 341 * Adds an nvpair for IPv4 addr to the nvlist. The "name" is the string in 342 * IPADM_NVP_IPV4ADDR. The "value" for IPADM_NVP_IPV4ADDR is another nvlist. 343 * Allocate the value nvlist for IPADM_NVP_IPV4ADDR if necessary, and add 344 * the address and hostnames from the address object `ipaddr' to it. 345 * Then add the allocated nvlist to `nvl'. 346 */ 347 ipadm_status_t 348 i_ipadm_add_ipaddr2nvl(nvlist_t *nvl, ipadm_addrobj_t ipaddr) 349 { 350 nvlist_t *nvl_addr = NULL; 351 int err; 352 char *name; 353 sa_family_t af = ipaddr->ipadm_af; 354 355 if (af == AF_INET) { 356 name = IPADM_NVP_IPV4ADDR; 357 } else { 358 assert(af == AF_INET6); 359 name = IPADM_NVP_IPV6ADDR; 360 } 361 362 if (!nvlist_exists(nvl, name)) { 363 if ((err = nvlist_alloc(&nvl_addr, NV_UNIQUE_NAME, 0)) != 0) 364 return (ipadm_errno2status(err)); 365 if ((err = nvlist_add_nvlist(nvl, name, nvl_addr)) != 0) { 366 nvlist_free(nvl_addr); 367 return (ipadm_errno2status(err)); 368 } 369 nvlist_free(nvl_addr); 370 } 371 if ((err = nvlist_lookup_nvlist(nvl, name, &nvl_addr)) != 0 || 372 (err = nvlist_add_string(nvl_addr, IPADM_NVP_IPADDRHNAME, 373 ipaddr->ipadm_static_aname)) != 0) 374 return (ipadm_errno2status(err)); 375 if (ipaddr->ipadm_static_dname[0] != '\0') { 376 if ((err = nvlist_add_string(nvl_addr, IPADM_NVP_IPDADDRHNAME, 377 ipaddr->ipadm_static_dname)) != 0) 378 return (ipadm_errno2status(err)); 379 } 380 381 return (IPADM_SUCCESS); 382 } 383 384 /* 385 * Adds an nvpair for IPv6 interface id to the nvlist. The "name" is 386 * the string in IPADM_NVP_INTFID. The "value" for IPADM_NVP_INTFID is another 387 * nvlist. Allocate the value nvlist for IPADM_NVP_INTFID if necessary, and add 388 * the interface id and its prefixlen from the address object `ipaddr' to it. 389 * Then add the allocated nvlist to `nvl'. 390 */ 391 ipadm_status_t 392 i_ipadm_add_intfid2nvl(nvlist_t *nvl, ipadm_addrobj_t addr) 393 { 394 nvlist_t *nvl_addr = NULL; 395 struct in6_addr addr6; 396 int err; 397 398 if (!nvlist_exists(nvl, IPADM_NVP_INTFID)) { 399 if ((err = nvlist_alloc(&nvl_addr, NV_UNIQUE_NAME, 0)) != 0) 400 return (ipadm_errno2status(err)); 401 if ((err = nvlist_add_nvlist(nvl, IPADM_NVP_INTFID, 402 nvl_addr)) != 0) { 403 nvlist_free(nvl_addr); 404 return (ipadm_errno2status(err)); 405 } 406 nvlist_free(nvl_addr); 407 } 408 if ((err = nvlist_lookup_nvlist(nvl, IPADM_NVP_INTFID, 409 &nvl_addr)) != 0 || (err = nvlist_add_uint32(nvl_addr, 410 IPADM_NVP_PREFIXLEN, addr->ipadm_intfidlen)) != 0) { 411 return (ipadm_errno2status(err)); 412 } 413 addr6 = addr->ipadm_intfid.sin6_addr; 414 if ((err = nvlist_add_uint8_array(nvl_addr, IPADM_NVP_IPNUMADDR, 415 addr6.s6_addr, 16)) != 0) { 416 return (ipadm_errno2status(err)); 417 } 418 if (addr->ipadm_stateless) 419 err = nvlist_add_string(nvl_addr, IPADM_NVP_STATELESS, "yes"); 420 else 421 err = nvlist_add_string(nvl_addr, IPADM_NVP_STATELESS, "no"); 422 if (err != 0) 423 return (ipadm_errno2status(err)); 424 if (addr->ipadm_stateful) 425 err = nvlist_add_string(nvl_addr, IPADM_NVP_STATEFUL, "yes"); 426 else 427 err = nvlist_add_string(nvl_addr, IPADM_NVP_STATEFUL, "no"); 428 if (err != 0) 429 return (ipadm_errno2status(err)); 430 431 return (IPADM_SUCCESS); 432 } 433 434 /* 435 * Adds an nvpair for a dhcp address object to the nvlist. The "name" is 436 * the string in IPADM_NVP_DHCP. The "value" for IPADM_NVP_DHCP is another 437 * nvlist. Allocate the value nvlist for IPADM_NVP_DHCP if necessary, and add 438 * the parameters from the arguments `primary' and `wait'. 439 * Then add the allocated nvlist to `nvl'. 440 */ 441 ipadm_status_t 442 i_ipadm_add_dhcp2nvl(nvlist_t *nvl, boolean_t primary, int32_t wait) 443 { 444 nvlist_t *nvl_dhcp = NULL; 445 int err; 446 447 if (!nvlist_exists(nvl, IPADM_NVP_DHCP)) { 448 if ((err = nvlist_alloc(&nvl_dhcp, NV_UNIQUE_NAME, 0)) != 0) 449 return (ipadm_errno2status(err)); 450 if ((err = nvlist_add_nvlist(nvl, IPADM_NVP_DHCP, 451 nvl_dhcp)) != 0) { 452 nvlist_free(nvl_dhcp); 453 return (ipadm_errno2status(err)); 454 } 455 nvlist_free(nvl_dhcp); 456 } 457 if ((err = nvlist_lookup_nvlist(nvl, IPADM_NVP_DHCP, &nvl_dhcp)) != 0 || 458 (err = nvlist_add_int32(nvl_dhcp, IPADM_NVP_WAIT, wait)) != 0 || 459 (err = nvlist_add_boolean_value(nvl_dhcp, IPADM_NVP_PRIMARY, 460 primary)) != 0) { 461 return (ipadm_errno2status(err)); 462 } 463 464 return (IPADM_SUCCESS); 465 } 466 467 /* 468 * Add (name, value) as an nvpair of type DATA_TYPE_STRING to nvlist. 469 */ 470 static void 471 i_ipadm_str_dbline2nvl(nvlist_t *nvl, char *name, char *value) 472 { 473 /* if value is NULL create an empty node */ 474 if (value == NULL) 475 (void) nvlist_add_string(nvl, name, ""); 476 else 477 (void) nvlist_add_string(nvl, name, value); 478 } 479 480 /* 481 * `name' = IPADM_NVP_IPV4ADDR and 482 * `value' = <local numeric IP string or hostname,remote numeric IP string or 483 * hostname> 484 * This function will add an nvlist with the hostname information in 485 * nvpairs to the nvlist in `nvl'. 486 */ 487 static void 488 i_ipadm_ip4_dbline2nvl(nvlist_t *nvl, char *name, char *value) 489 { 490 char *cp, *hname; 491 struct ipadm_addrobj_s ipaddr; 492 493 assert(strcmp(name, IPADM_NVP_IPV4ADDR) == 0 && value != NULL); 494 495 bzero(&ipaddr, sizeof (ipaddr)); 496 ipaddr.ipadm_af = AF_INET; 497 498 hname = value; /* local hostname */ 499 cp = strchr(hname, ','); 500 assert(cp != NULL); 501 *cp++ = '\0'; 502 (void) strlcpy(ipaddr.ipadm_static_aname, hname, 503 sizeof (ipaddr.ipadm_static_aname)); 504 505 if (*cp != '\0') { 506 /* we have a dst hostname */ 507 (void) strlcpy(ipaddr.ipadm_static_dname, cp, 508 sizeof (ipaddr.ipadm_static_dname)); 509 } 510 (void) i_ipadm_add_ipaddr2nvl(nvl, &ipaddr); 511 } 512 513 /* 514 * `name' = IPADM_NVP_IPV6ADDR and 515 * `value' = <local numeric IP string or hostname,remote numeric IP string or 516 * hostname> 517 * This function will add an nvlist with the hostname information in 518 * nvpairs to the nvlist in `nvl'. 519 */ 520 static void 521 i_ipadm_ip6_dbline2nvl(nvlist_t *nvl, char *name, char *value) 522 { 523 char *cp, *hname; 524 struct ipadm_addrobj_s ipaddr; 525 526 assert(strcmp(name, IPADM_NVP_IPV6ADDR) == 0 && value != NULL); 527 528 bzero(&ipaddr, sizeof (ipaddr)); 529 ipaddr.ipadm_af = AF_INET6; 530 531 hname = value; /* local hostname */ 532 cp = strchr(hname, ','); 533 assert(cp != NULL); 534 *cp++ = '\0'; 535 (void) strlcpy(ipaddr.ipadm_static_aname, hname, 536 sizeof (ipaddr.ipadm_static_aname)); 537 538 if (*cp != '\0') { 539 /* we have a dst hostname */ 540 (void) strlcpy(ipaddr.ipadm_static_dname, cp, 541 sizeof (ipaddr.ipadm_static_dname)); 542 } 543 (void) i_ipadm_add_ipaddr2nvl(nvl, &ipaddr); 544 } 545 546 /* 547 * `name' = IPADM_NVP_INTFID and `value' = <intfid/prefixlen>,{yes,no},{yes|no} 548 * This function will add an nvlist with the address object information in 549 * nvpairs to the nvlist in `nvl'. 550 */ 551 static void 552 i_ipadm_intfid_dbline2nvl(nvlist_t *nvl, char *name, char *value) 553 { 554 char *cp; 555 struct ipadm_addrobj_s ipaddr; 556 char *endp; 557 char *prefixlen; 558 char *stateless; 559 char *stateful; 560 561 assert(strcmp(name, IPADM_NVP_INTFID) == 0 && value != NULL); 562 563 bzero(&ipaddr, sizeof (ipaddr)); 564 565 cp = strchr(value, '/'); 566 assert(cp != NULL); 567 568 *cp++ = '\0'; 569 ipaddr.ipadm_intfid.sin6_family = AF_INET6; 570 (void) inet_pton(AF_INET6, value, &ipaddr.ipadm_intfid.sin6_addr); 571 572 prefixlen = cp; 573 cp = strchr(cp, ','); 574 assert(cp != NULL); 575 *cp++ = '\0'; 576 577 errno = 0; 578 ipaddr.ipadm_intfidlen = (uint32_t)strtoul(prefixlen, &endp, 10); 579 if (*endp != '\0' || errno != 0) 580 return; 581 582 stateless = cp; 583 stateful = strchr(stateless, ','); 584 assert(stateful != NULL); 585 *stateful++ = '\0'; 586 ipaddr.ipadm_stateless = (strcmp(stateless, "yes") == 0); 587 ipaddr.ipadm_stateful = (strcmp(stateful, "yes") == 0); 588 589 /* Add all of it to the given nvlist */ 590 (void) i_ipadm_add_intfid2nvl(nvl, &ipaddr); 591 } 592 593 /* 594 * `name' = IPADM_NVP_DHCP and `value' = <wait_time>,{yes|no} 595 * This function will add an nvlist with the dhcp address object information in 596 * nvpairs to the nvlist in `nvl'. 597 */ 598 static void 599 i_ipadm_dhcp_dbline2nvl(nvlist_t *nvl, char *name, char *value) 600 { 601 char *cp; 602 char *endp; 603 long wait_time; 604 boolean_t primary; 605 606 assert(strcmp(name, IPADM_NVP_DHCP) == 0 && value != NULL); 607 cp = strchr(value, ','); 608 assert(cp != NULL); 609 *cp++ = '\0'; 610 errno = 0; 611 wait_time = strtol(value, &endp, 10); 612 if (*endp != '\0' || errno != 0) 613 return; 614 primary = (strcmp(cp, "yes") == 0); 615 (void) i_ipadm_add_dhcp2nvl(nvl, primary, (int32_t)wait_time); 616 } 617 618 /* 619 * Parses the buffer, for name-value pairs and creates nvlist. The value 620 * is always considered to be a string. 621 */ 622 int 623 ipadm_str2nvlist(const char *inbuf, nvlist_t **ipnvl, uint_t flags) 624 { 625 char *nv, *name, *val, *buf, *cp, *sep; 626 int err; 627 628 if (inbuf == NULL || inbuf[0] == '\0' || ipnvl == NULL) 629 return (EINVAL); 630 *ipnvl = NULL; 631 632 /* 633 * If IPADM_NORVAL is set, then `inbuf' should be comma delimited values 634 */ 635 if ((flags & IPADM_NORVAL) && strchr(inbuf, '=') != NULL) 636 return (EINVAL); 637 638 if ((cp = buf = strdup(inbuf)) == NULL) 639 return (errno); 640 641 while (isspace(*buf)) 642 buf++; 643 644 if (*buf == '\0') { 645 err = EINVAL; 646 goto fail; 647 } 648 649 nv = buf; 650 /* 651 * work on one nvpair at a time and extract the name and value 652 */ 653 sep = ((flags & IPADM_NORVAL) ? IPADM_NAME_SEP : IPADM_NVPAIR_SEP); 654 while ((nv = strsep(&buf, sep)) != NULL) { 655 if (*nv == '\n') 656 continue; 657 name = nv; 658 if ((val = strchr(nv, '=')) != NULL) 659 *val++ = '\0'; 660 if (*ipnvl == NULL && 661 (err = nvlist_alloc(ipnvl, NV_UNIQUE_NAME, 0)) != 0) 662 goto fail; 663 if (nvlist_exists(*ipnvl, name)) { 664 err = EEXIST; 665 goto fail; 666 } 667 /* Add the extracted nvpair to the nvlist `ipnvl'. */ 668 (void) i_ipadm_add_nvpair(*ipnvl, name, val); 669 } 670 free(cp); 671 return (0); 672 fail: 673 free(cp); 674 nvlist_free(*ipnvl); 675 *ipnvl = NULL; 676 return (err); 677 } 678 679 /* 680 * Opens the data store for read/write operation. For write operation we open 681 * another file and scribble the changes to it and copy the new file back to 682 * old file. 683 */ 684 int 685 ipadm_rw_db(db_wfunc_t *db_walk_func, void *arg, const char *db_file, 686 mode_t db_perms, ipadm_db_op_t db_op) 687 { 688 FILE *fp, *nfp = NULL; 689 char file[MAXPATHLEN]; 690 char newfile[MAXPATHLEN]; 691 int nfd; 692 boolean_t writeop; 693 int err = 0; 694 695 writeop = (db_op != IPADM_DB_READ); 696 697 (void) snprintf(file, MAXPATHLEN, "%s/%s", ipadm_rootdir, db_file); 698 699 /* open the data store */ 700 if ((fp = fopen(file, (writeop ? "r+" : "r"))) == NULL) 701 return (errno); 702 703 if (writeop) { 704 (void) snprintf(newfile, MAXPATHLEN, "%s/%s.new", 705 ipadm_rootdir, db_file); 706 if ((nfd = open(newfile, O_WRONLY | O_CREAT | O_TRUNC, 707 db_perms)) < 0) { 708 err = errno; 709 (void) fclose(fp); 710 return (err); 711 } 712 713 if ((nfp = fdopen(nfd, "w")) == NULL) { 714 err = errno; 715 (void) close(nfd); 716 (void) fclose(fp); 717 (void) unlink(newfile); 718 return (err); 719 } 720 } 721 err = ipadm_process_db_line(db_walk_func, arg, fp, nfp, db_op); 722 if (!writeop) 723 goto done; 724 if (err != 0 && err != ENOENT) 725 goto done; 726 727 if (fflush(nfp) == EOF) { 728 err = errno; 729 goto done; 730 } 731 (void) fclose(fp); 732 (void) fclose(nfp); 733 734 if (rename(newfile, file) < 0) { 735 err = errno; 736 (void) unlink(newfile); 737 } 738 return (err); 739 done: 740 if (nfp != NULL) { 741 (void) fclose(nfp); 742 if (err != 0) 743 (void) unlink(newfile); 744 } 745 (void) fclose(fp); 746 return (err); 747 } 748 749 /* 750 * Processes each line of the configuration file, skipping lines with 751 * leading spaces, blank lines and comments. The line form the DB 752 * is converted to nvlist and the callback function is called to process 753 * the list. The buf could be modified by the callback function and 754 * if this is a write operation and buf is not truncated, buf will 755 * be written to disk. 756 * 757 * Further if cont is set to B_FALSE, the remainder of the file will 758 * continue to be read (however callback function will not be called) and, 759 * if necessary, written to disk as well. 760 */ 761 static int 762 ipadm_process_db_line(db_wfunc_t *db_walk_func, void *arg, FILE *fp, FILE *nfp, 763 ipadm_db_op_t db_op) 764 { 765 int err = 0; 766 char buf[MAXLINELEN]; 767 boolean_t cont = B_TRUE; 768 int i, len; 769 nvlist_t *db_nvl = NULL; 770 boolean_t line_deleted = B_FALSE; 771 772 while (fgets(buf, MAXLINELEN, fp) != NULL) { 773 /* 774 * Skip leading spaces, blank lines, and comments. 775 */ 776 len = strnlen(buf, MAXLINELEN); 777 for (i = 0; i < len; i++) { 778 if (!isspace(buf[i])) 779 break; 780 } 781 782 if (i != len && buf[i] != '#' && cont) { 783 if (ipadm_str2nvlist(buf, &db_nvl, 0) == 0) { 784 cont = db_walk_func(arg, db_nvl, buf, 785 MAXLINELEN, &err); 786 } else { 787 /* Delete corrupted line. */ 788 buf[0] = '\0'; 789 } 790 nvlist_free(db_nvl); 791 db_nvl = NULL; 792 } 793 if (err != 0) 794 break; 795 if (nfp != NULL && buf[0] == '\0') 796 line_deleted = B_TRUE; 797 if (nfp != NULL && buf[0] != '\0' && fputs(buf, nfp) == EOF) { 798 err = errno; 799 break; 800 } 801 } 802 803 if (err != 0 || !cont) 804 return (err); 805 806 if (db_op == IPADM_DB_WRITE) { 807 nvlist_t *nvl; 808 809 /* 810 * `arg' will be NULL when we are doing in-line update of 811 * entries. 812 */ 813 if (arg != NULL) { 814 nvl = ((ipadm_dbwrite_cbarg_t *)arg)->dbw_nvl; 815 /* 816 * If the specified entry is not found above, we add 817 * the entry to the configuration file, here. 818 */ 819 (void) memset(buf, 0, MAXLINELEN); 820 if (ipadm_nvlist2str(nvl, buf, MAXLINELEN) == 0) 821 err = ENOBUFS; 822 else if (fputs(buf, nfp) == EOF) 823 err = errno; 824 } 825 return (err); 826 } 827 828 if (db_op == IPADM_DB_DELETE && line_deleted) 829 return (0); 830 831 /* if we have come this far, then we didn't find any match */ 832 return (ENOENT); 833 } 834