Mercurial > illumos > onarm
annotate usr/src/cmd/cmd-inet/usr.lib/in.ndpd/config.c @ 4:1a15d5aaf794
synchronized with onnv_86 (6202) in onnv-gate
| author | Koji Uno <koji.uno@sun.com> |
|---|---|
| date | Mon, 31 Aug 2009 14:38:03 +0900 |
| parents | c9caec207d52 |
| children |
| rev | line source |
|---|---|
| 0 | 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 2007 Sun Microsystems, Inc. All rights reserved. | |
| 23 * Use is subject to license terms. | |
| 24 */ | |
| 25 | |
|
4
1a15d5aaf794
synchronized with onnv_86 (6202) in onnv-gate
Koji Uno <koji.uno@sun.com>
parents:
0
diff
changeset
|
26 #pragma ident "%Z%%M% %I% %E% SMI" |
| 0 | 27 |
| 28 #include "defs.h" | |
| 29 #include "tables.h" | |
| 30 | |
| 31 /* | |
| 32 * Parse the config file which consists of entries of the form: | |
| 33 * ifdefault [<variable> <value>]* | |
| 34 * prefixdefault [<variable> <value>]* | |
| 35 * if <ifname> [<variable> <value>]* | |
| 36 * prefix <prefix>/<length> <ifname> [<variable> <value>]* | |
| 37 * | |
| 38 * All "ifdefault" and "prefixdefault" entries must preceed any | |
| 39 * "if" and "prefix" entries. | |
| 40 * | |
| 41 * Values (such as expiry dates) which contain white space | |
| 42 * can be quoted with single or double quotes. | |
| 43 */ | |
| 44 | |
| 45 /* maximum length of messages we send to syslog */ | |
| 46 #define NDPD_LOGMSGSIZE 1024 | |
| 47 typedef boolean_t (*pfb_t)(char *, uint_t *); | |
| 48 | |
| 49 struct configinfo { | |
| 50 char *ci_name; | |
| 51 uint_t ci_min; /* 0: no min check */ | |
| 52 uint_t ci_max; /* ~0U: no max check */ | |
| 53 uint_t ci_default; | |
| 54 uint_t ci_index; /* Into result array */ | |
| 55 pfb_t ci_parsefunc; /* Parse function returns -1 on failure */ | |
| 56 }; | |
| 57 | |
| 58 enum config_type { CONFIG_IF, CONFIG_PREFIX}; | |
| 59 typedef enum config_type config_type_t; | |
| 60 | |
| 61 static void set_protocol_defaults(void); | |
| 62 static void print_defaults(void); | |
| 63 static void parse_var_value(config_type_t, struct configinfo *, char *, char *, | |
| 64 struct confvar *); | |
| 65 static void parse_default(config_type_t, struct configinfo *, char **, int, | |
| 66 struct confvar *); | |
| 67 static void parse_if(struct configinfo *, char **, int); | |
| 68 static void parse_prefix(struct configinfo *, char **, int); | |
| 69 static boolean_t parse_onoff(char *, uint_t *); /* boolean */ | |
| 70 static boolean_t parse_int(char *, uint_t *); /* integer */ | |
| 71 static boolean_t parse_ms(char *, uint_t *); /* milliseconds */ | |
| 72 static boolean_t parse_s(char *, uint_t *); /* seconds */ | |
| 73 static boolean_t parse_date(char *, uint_t *); /* date format */ | |
| 74 static void conferr(char *fmt, ...); | |
| 75 static FILE *open_conffile(char *filename); | |
| 76 static int parse_line(char *line, char *argvec[], int argcount); | |
| 77 static int readline(FILE *fp, char *line, int length); | |
| 78 static int parse_addrprefix(char *strin, struct in6_addr *in6); | |
| 79 | |
| 80 /* | |
| 81 * Per interface configuration variables. | |
| 82 * Min, max, and default values are from RFC 2461. | |
| 83 */ | |
| 84 static struct configinfo iflist[] = { | |
| 85 /* Name, Min, Max, Default, Index */ | |
| 86 { "DupAddrDetectTransmits", 0, 100, 1, I_DupAddrDetectTransmits, | |
| 87 parse_int }, | |
| 88 { "AdvSendAdvertisements", 0, 1, 0, I_AdvSendAdvertisements, | |
| 89 parse_onoff }, | |
| 90 { "MaxRtrAdvInterval", 4, 1800, 600, I_MaxRtrAdvInterval, parse_s }, | |
| 91 { "MinRtrAdvInterval", 3, 1350, 200, I_MinRtrAdvInterval, parse_s }, | |
| 92 /* | |
| 93 * No greater than .75 * MaxRtrAdvInterval. | |
| 94 * Default: 0.33 * MaxRtrAdvInterval | |
| 95 */ | |
| 96 { "AdvManagedFlag", 0, 1, 0, I_AdvManagedFlag, parse_onoff }, | |
| 97 { "AdvOtherConfigFlag", 0, 1, 0, I_AdvOtherConfigFlag, parse_onoff }, | |
| 98 { "AdvLinkMTU", IPV6_MIN_MTU, 65535, 0, I_AdvLinkMTU, parse_int }, | |
| 99 { "AdvReachableTime", 0, 3600000, 0, I_AdvReachableTime, parse_ms }, | |
| 100 { "AdvRetransTimer", 0, ~0U, 0, I_AdvRetransTimer, parse_ms }, | |
| 101 { "AdvCurHopLimit", 0, 255, 0, I_AdvCurHopLimit, parse_int }, | |
| 102 { "AdvDefaultLifetime", 0, 9000, 1800, I_AdvDefaultLifetime, parse_s }, | |
| 103 /* | |
| 104 * MUST be either zero or between MaxRtrAdvInterval and 9000 seconds. | |
| 105 * Default: 3 * MaxRtrAdvInterval | |
| 106 */ | |
| 107 { "StatelessAddrConf", 0, 1, 1, I_StatelessAddrConf, parse_onoff }, | |
| 108 { "StatefulAddrConf", 0, 1, 1, I_StatefulAddrConf, parse_onoff }, | |
| 109 /* | |
| 110 * Tmp* variables from RFC 3041, where defaults are defined. | |
| 111 */ | |
| 112 { "TmpAddrsEnabled", 0, 1, 0, I_TmpAddrsEnabled, parse_onoff }, | |
| 113 { "TmpValidLifetime", 0, ~0U, 604800, I_TmpValidLifetime, parse_s }, | |
| 114 { "TmpPreferredLifetime", 0, ~0U, 86400, I_TmpPreferredLifetime, | |
| 115 parse_s }, | |
| 116 { "TmpRegenAdvance", 0, 60, 5, I_TmpRegenAdvance, parse_s }, | |
| 117 { "TmpMaxDesyncFactor", 0, 600, 600, I_TmpMaxDesyncFactor, parse_s }, | |
| 118 { NULL, 0, 0, 0, 0 } | |
| 119 }; | |
| 120 | |
| 121 /* | |
| 122 * Per prefix: AdvPrefixList configuration variables. | |
| 123 * Min, max, and default values are from RFC 2461. | |
| 124 */ | |
| 125 static struct configinfo prefixlist[] = { | |
| 126 /* Name, Min, Max, Default, Index */ | |
| 127 { "AdvValidLifetime", 0, ~0U, 2592000, I_AdvValidLifetime, | |
| 128 parse_s }, | |
| 129 { "AdvOnLinkFlag", 0, 1, 1, I_AdvOnLinkFlag, parse_onoff }, | |
| 130 { "AdvPreferredLifetime", 0, ~0U, 604800, I_AdvPreferredLifetime, | |
| 131 parse_s}, | |
| 132 { "AdvAutonomousFlag", 0, 1, 1, I_AdvAutonomousFlag, parse_onoff }, | |
| 133 { "AdvValidExpiration", 0, ~0U, 0, I_AdvValidExpiration, | |
| 134 parse_date }, | |
| 135 { "AdvPreferredExpiration", 0, ~0U, 0, I_AdvPreferredExpiration, | |
| 136 parse_date}, | |
| 137 { NULL, 0, 0, 0, 0 }, | |
| 138 }; | |
| 139 | |
| 140 /* | |
| 141 * Data structures used to merge above protocol defaults | |
| 142 * with defaults specified in the configuration file. | |
| 143 * ifdefault is not static because new interfaces can be | |
| 144 * created outside of the configuration context. | |
| 145 */ | |
| 146 struct confvar ifdefaults[I_IFSIZE]; | |
| 147 static struct confvar prefixdefaults[I_PREFIXSIZE]; | |
| 148 | |
| 149 static char conf_filename[MAXPATHLEN]; | |
| 150 static int lineno; | |
| 151 | |
| 152 /* | |
| 153 * Checks for violations of section 5.5.3 (c) of RFC 2462. | |
| 154 */ | |
| 155 static void | |
| 156 check_var_consistency(struct confvar *cv, void *save, int size) | |
| 157 { | |
| 158 boolean_t rollback = _B_FALSE; | |
| 159 int prefl, prefe, valid; | |
| 160 | |
| 161 prefl = cv[I_AdvPreferredLifetime].cf_value; | |
| 162 prefe = cv[I_AdvPreferredExpiration].cf_value; | |
| 163 valid = cv[I_AdvValidLifetime].cf_value; | |
| 164 | |
| 165 if (prefl > valid) { | |
| 166 conferr("AdvPreferredLifetime (%u) is greater than " | |
| 167 "valid lifetime (%u)\n", prefl, valid); | |
| 168 rollback = _B_TRUE; | |
| 169 } | |
| 170 | |
| 171 if (prefe > valid) { | |
| 172 conferr("AdvPreferredExpiration (%u) is greater than " | |
| 173 "valid lifetime (%u)\n", prefe, valid); | |
| 174 rollback = _B_TRUE; | |
| 175 } | |
| 176 | |
| 177 if (rollback) { | |
| 178 (void) memcpy(cv, save, size); | |
| 179 } | |
| 180 } | |
| 181 | |
| 182 /* | |
| 183 * Check for invalid lifetime values for RFC3041 addresses | |
| 184 */ | |
| 185 static void | |
| 186 check_if_var_consistency(struct confvar *cv, void *save, int size) | |
| 187 { | |
| 188 boolean_t rollback = _B_FALSE; | |
| 189 int tpref, tvalid, tdesync, tregen; | |
| 190 | |
| 191 tpref = cv[I_TmpPreferredLifetime].cf_value; | |
| 192 tvalid = cv[I_TmpValidLifetime].cf_value; | |
| 193 tdesync = cv[I_TmpMaxDesyncFactor].cf_value; | |
| 194 tregen = cv[I_TmpRegenAdvance].cf_value; | |
| 195 | |
| 196 /* | |
| 197 * Only need to do this if tmp addrs are enabled. | |
| 198 */ | |
| 199 if (cv[I_TmpAddrsEnabled].cf_value == 0) | |
| 200 return; | |
| 201 | |
| 202 if (tdesync > tpref) { | |
| 203 conferr("TmpDesyncFactor (%u) is greater than " | |
| 204 "TmpPreferredLifetime (%u)\n", tdesync, tpref); | |
| 205 rollback = _B_TRUE; | |
| 206 } | |
| 207 | |
| 208 if (tpref > tvalid) { | |
| 209 conferr("TmpPreferredLifetime (%u) is greater than " | |
| 210 "TmpValidLifetime (%u)\n", tpref, tvalid); | |
| 211 rollback = _B_TRUE; | |
| 212 } | |
| 213 | |
| 214 if (tregen > tvalid) { | |
| 215 conferr("TmpRegenAdvance (%u) is greater than " | |
| 216 "TmpValidLifetime (%u)\n", tregen, tvalid); | |
| 217 rollback = _B_TRUE; | |
| 218 } | |
| 219 | |
| 220 if (rollback) { | |
| 221 (void) memcpy(cv, save, size); | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 int | |
| 226 parse_config(char *config_file, boolean_t file_required) | |
| 227 { | |
| 228 FILE *fp; | |
| 229 char line[MAXLINELEN]; | |
| 230 char pline[MAXLINELEN]; | |
| 231 int argcount; | |
| 232 char *argvec[MAXARGSPERLINE]; | |
| 233 int defaultdone = 0; /* Set when first non-default command found */ | |
| 234 | |
| 235 if (debug & D_CONFIG) | |
| 236 logmsg(LOG_DEBUG, "parse_config()\n"); | |
| 237 | |
| 238 set_protocol_defaults(); | |
| 239 if (debug & D_DEFAULTS) | |
| 240 print_defaults(); | |
| 241 | |
| 242 fp = open_conffile(config_file); | |
| 243 if (fp == NULL) { | |
| 244 if (errno == ENOENT && !file_required) | |
| 245 return (0); | |
| 246 logperror(config_file); | |
| 247 return (-1); | |
| 248 } | |
| 249 while (readline(fp, line, sizeof (line)) != 0) { | |
| 250 (void) strncpy(pline, line, sizeof (pline)); | |
| 251 pline[sizeof (pline) - 1] = '\0'; /* NULL terminate */ | |
| 252 argcount = parse_line(pline, argvec, | |
| 253 sizeof (argvec) / sizeof (argvec[0])); | |
| 254 if (debug & D_PARSE) { | |
| 255 int i; | |
| 256 | |
| 257 logmsg(LOG_DEBUG, "scanned %d args\n", argcount); | |
| 258 for (i = 0; i < argcount; i++) | |
| 259 logmsg(LOG_DEBUG, "arg[%d]: %s\n", | |
| 260 i, argvec[i]); | |
| 261 } | |
| 262 if (argcount == 0) { | |
| 263 /* Empty line - or comment only line */ | |
| 264 continue; | |
| 265 } | |
| 266 if (strcmp(argvec[0], "ifdefault") == 0) { | |
| 267 char save[sizeof (ifdefaults)]; | |
| 268 | |
| 269 if (defaultdone) { | |
| 270 conferr("ifdefault after non-default " | |
| 271 "command\n"); | |
| 272 continue; | |
| 273 } | |
| 274 /* | |
| 275 * Save existing values in case what we read is | |
| 276 * invalid and we need to restore previous settings. | |
| 277 */ | |
| 278 (void) memcpy(save, ifdefaults, sizeof (ifdefaults)); | |
| 279 parse_default(CONFIG_IF, iflist, argvec+1, argcount-1, | |
| 280 ifdefaults); | |
| 281 check_if_var_consistency(ifdefaults, save, | |
| 282 sizeof (save)); | |
| 283 } else if (strcmp(argvec[0], "prefixdefault") == 0) { | |
| 284 char save[sizeof (prefixdefaults)]; | |
| 285 | |
| 286 if (defaultdone) { | |
| 287 conferr("prefixdefault after non-default " | |
| 288 "command\n"); | |
| 289 continue; | |
| 290 } | |
| 291 /* | |
| 292 * Save existing values in case what we read is | |
| 293 * invalid and we need to restore previous settings. | |
| 294 */ | |
| 295 (void) memcpy(save, prefixdefaults, | |
| 296 sizeof (prefixdefaults)); | |
| 297 parse_default(CONFIG_PREFIX, prefixlist, argvec+1, | |
| 298 argcount-1, prefixdefaults); | |
| 299 check_var_consistency(prefixdefaults, save, | |
| 300 sizeof (save)); | |
| 301 } else if (strcmp(argvec[0], "if") == 0) { | |
| 302 defaultdone = 1; | |
| 303 parse_if(iflist, argvec+1, argcount-1); | |
| 304 } else if (strcmp(argvec[0], "prefix") == 0) { | |
| 305 defaultdone = 1; | |
| 306 parse_prefix(prefixlist, argvec+1, argcount-1); | |
| 307 } else { | |
| 308 conferr("Unknown command: %s\n", argvec[0]); | |
| 309 } | |
| 310 } | |
| 311 (void) fclose(fp); | |
| 312 if (debug & D_DEFAULTS) | |
| 313 print_defaults(); | |
| 314 return (0); | |
| 315 } | |
| 316 | |
| 317 /* | |
| 318 * Extract the defaults from the configinfo tables to initialize | |
| 319 * the ifdefaults and prefixdefaults arrays. | |
| 320 * The arrays are needed to track which defaults have been changed | |
| 321 * by the config file. | |
| 322 */ | |
| 323 static void | |
| 324 set_protocol_defaults(void) | |
| 325 { | |
| 326 struct configinfo *cip; | |
| 327 | |
| 328 if (debug & D_DEFAULTS) | |
| 329 logmsg(LOG_DEBUG, "extract_protocol_defaults\n"); | |
| 330 for (cip = iflist; cip->ci_name != NULL; cip++) { | |
| 331 ifdefaults[cip->ci_index].cf_value = cip->ci_default; | |
| 332 ifdefaults[cip->ci_index].cf_notdefault = _B_FALSE; | |
| 333 } | |
| 334 for (cip = prefixlist; cip->ci_name != NULL; cip++) { | |
| 335 prefixdefaults[cip->ci_index].cf_value = cip->ci_default; | |
| 336 prefixdefaults[cip->ci_index].cf_notdefault = _B_FALSE; | |
| 337 } | |
| 338 } | |
| 339 | |
| 340 void | |
| 341 print_iflist(struct confvar *confvar) | |
| 342 { | |
| 343 struct configinfo *cip; | |
| 344 | |
| 345 for (cip = iflist; cip->ci_name != NULL; cip++) { | |
| 346 logmsg(LOG_DEBUG, "\t%s min %u max %u def %u value %u set %d\n", | |
| 347 cip->ci_name, cip->ci_min, cip->ci_max, cip->ci_default, | |
| 348 confvar[cip->ci_index].cf_value, | |
| 349 confvar[cip->ci_index].cf_notdefault); | |
| 350 } | |
| 351 } | |
| 352 | |
| 353 void | |
| 354 print_prefixlist(struct confvar *confvar) | |
| 355 { | |
| 356 struct configinfo *cip; | |
| 357 | |
| 358 for (cip = prefixlist; cip->ci_name != NULL; cip++) { | |
| 359 logmsg(LOG_DEBUG, "\t%s min %u max %u def %u value %u set %d\n", | |
| 360 cip->ci_name, cip->ci_min, cip->ci_max, cip->ci_default, | |
| 361 confvar[cip->ci_index].cf_value, | |
| 362 confvar[cip->ci_index].cf_notdefault); | |
| 363 } | |
| 364 } | |
| 365 | |
| 366 | |
| 367 static void | |
| 368 print_defaults(void) | |
| 369 { | |
| 370 logmsg(LOG_DEBUG, "Default interface variables:\n"); | |
| 371 print_iflist(ifdefaults); | |
| 372 logmsg(LOG_DEBUG, "Default prefix variables:\n"); | |
| 373 print_prefixlist(prefixdefaults); | |
| 374 } | |
| 375 | |
| 376 /* | |
| 377 * Read from fp. Handle \ at the end of the line by joining lines together. | |
| 378 * Return 0 on EOF. | |
| 379 */ | |
| 380 static int | |
| 381 readline(FILE *fp, char *line, int length) | |
| 382 { | |
| 383 int got = 0; | |
| 384 | |
| 385 retry: | |
| 386 errno = 0; | |
| 387 if (fgets(line, length, fp) == NULL) { | |
| 388 if (errno == EINTR) | |
| 389 goto retry; | |
| 390 if (got != 0) | |
| 391 return (1); | |
| 392 else | |
| 393 return (0); | |
| 394 } | |
| 395 lineno++; | |
| 396 got = strlen(line); | |
| 397 /* Look for trailing \. Note that fgets includes the linefeed. */ | |
| 398 if (got >= 2 && line[got-2] == '\\') { | |
| 399 /* Skip \ and LF */ | |
| 400 line += got - 2; | |
| 401 length -= got - 2; | |
| 402 goto retry; | |
| 403 } | |
| 404 /* Remove the trailing linefeed */ | |
| 405 if (got > 0) | |
| 406 line[got-1] = '\0'; | |
| 407 | |
| 408 return (1); | |
| 409 } | |
| 410 | |
| 411 /* | |
| 412 * Parse a line splitting it off at whitspace characters. | |
| 413 * Modifies the content of the string by inserting NULLs. | |
| 414 * If more arguments than fits in argvec/argcount then ignore the last. | |
| 415 * Returns argcount. | |
| 416 * Handles single quotes and double quotes. | |
| 417 */ | |
| 418 static int | |
| 419 parse_line(char *line, char *argvec[], int argcount) | |
| 420 { | |
| 421 int i = 0; | |
| 422 char *cp; | |
| 423 boolean_t insingle_quote = _B_FALSE; | |
| 424 boolean_t indouble_quote = _B_FALSE; | |
| 425 | |
| 426 /* Truncate at the beginning of a comment */ | |
| 427 cp = strchr(line, '#'); | |
| 428 if (cp != NULL) | |
| 429 *cp = '\0'; | |
| 430 | |
| 431 for (;;) { | |
| 432 /* Skip any whitespace */ | |
| 433 while (isspace(*line) && *line != '\0') | |
| 434 line++; | |
| 435 | |
| 436 if (*line == '\'') { | |
| 437 line++; | |
| 438 if (*line == '\0') | |
| 439 return (i); | |
| 440 insingle_quote = _B_TRUE; | |
| 441 } else if (*line == '"') { | |
| 442 line++; | |
| 443 if (*line == '\0') | |
| 444 return (i); | |
| 445 indouble_quote = _B_TRUE; | |
| 446 } | |
| 447 argvec[i] = line; | |
| 448 if (*line == '\0') | |
| 449 return (i); | |
| 450 i++; | |
| 451 /* Skip until next whitespace or end of quoted text */ | |
| 452 if (insingle_quote) { | |
| 453 while (*line != '\'' && *line != '\0') | |
| 454 line++; | |
| 455 if (*line == '\'') { | |
| 456 *line = ' '; | |
| 457 } else { | |
| 458 /* Handle missing quote at end */ | |
| 459 i--; | |
| 460 conferr("Missing end quote - ignoring <%s>\n", | |
| 461 argvec[i]); | |
| 462 return (i); | |
| 463 } | |
| 464 insingle_quote = _B_FALSE; | |
| 465 } else if (indouble_quote) { | |
| 466 while (*line != '"' && *line != '\0') | |
| 467 line++; | |
| 468 if (*line == '"') { | |
| 469 *line = ' '; | |
| 470 } else { | |
| 471 /* Handle missing quote at end */ | |
| 472 i--; | |
| 473 conferr("Missing end quote - ignoring <%s>\n", | |
| 474 argvec[i]); | |
| 475 return (i); | |
| 476 } | |
| 477 indouble_quote = _B_FALSE; | |
| 478 } else { | |
| 479 while (!isspace(*line) && *line != '\0') | |
| 480 line++; | |
| 481 } | |
| 482 if (*line != '\0') { | |
| 483 /* Break off argument */ | |
| 484 *line++ = '\0'; | |
| 485 } | |
| 486 if (i > argcount) | |
| 487 return (argcount); | |
| 488 } | |
| 489 /* NOTREACHED */ | |
| 490 } | |
| 491 | |
| 492 static void | |
| 493 parse_var_value(config_type_t type, struct configinfo *list, char *varstr, | |
| 494 char *valstr, struct confvar *confvar) | |
| 495 { | |
| 496 struct configinfo *cip; | |
| 497 uint_t val; | |
| 498 | |
| 499 if (debug & D_CONFIG) { | |
| 500 logmsg(LOG_DEBUG, "parse_var_value(%d, %s, %s)\n", | |
| 501 (int)type, varstr, valstr); | |
| 502 } | |
| 503 | |
| 504 for (cip = list; cip->ci_name != NULL; cip++) { | |
| 505 if (strcasecmp(cip->ci_name, varstr) == 0) | |
| 506 break; | |
| 507 } | |
| 508 if (cip->ci_name == NULL) { | |
| 509 conferr("Unknown variable: <%s>\n", varstr); | |
| 510 return; | |
| 511 } | |
| 512 if (!(*cip->ci_parsefunc)(valstr, &val)) { | |
| 513 conferr("Bad value: <%s>\n", valstr); | |
| 514 return; | |
| 515 } | |
| 516 if (cip->ci_min != 0 && val < cip->ci_min) { | |
| 517 conferr("Value %s is below minimum %u for %s\n", | |
| 518 valstr, cip->ci_min, varstr); | |
| 519 return; | |
| 520 } | |
| 521 if (cip->ci_max != ~0U && val > cip->ci_max) { | |
| 522 conferr("Value %s is above maximum %u for %s\n", | |
| 523 valstr, cip->ci_max, varstr); | |
| 524 return; | |
| 525 } | |
| 526 /* Check against dynamic/relative limits */ | |
| 527 if (type == CONFIG_IF) { | |
| 528 if (cip->ci_index == I_MinRtrAdvInterval && | |
| 529 confvar[I_MaxRtrAdvInterval].cf_notdefault && | |
| 530 val > confvar[I_MaxRtrAdvInterval].cf_value * 0.75) { | |
| 531 conferr("MinRtrAdvInterval exceeds .75 * " | |
| 532 "MaxRtrAdvInterval (%u)\n", | |
| 533 confvar[I_MaxRtrAdvInterval].cf_value); | |
| 534 return; | |
| 535 } | |
| 536 if (cip->ci_index == I_MaxRtrAdvInterval && | |
| 537 confvar[I_MinRtrAdvInterval].cf_notdefault && | |
| 538 confvar[I_MinRtrAdvInterval].cf_value > val * 0.75) { | |
| 539 conferr("MinRtrAdvInterval (%u) exceeds .75 * " | |
| 540 "MaxRtrAdvInterval\n", | |
| 541 confvar[I_MinRtrAdvInterval].cf_value); | |
| 542 return; | |
| 543 } | |
| 544 if (cip->ci_index == I_AdvDefaultLifetime && | |
| 545 confvar[I_MaxRtrAdvInterval].cf_notdefault && | |
| 546 val != 0 && | |
| 547 val < confvar[I_MaxRtrAdvInterval].cf_value) { | |
| 548 conferr("AdvDefaultLifetime is not between " | |
| 549 "MaxRtrAdrInterval (%u) and 9000 seconds\n", | |
| 550 confvar[I_MaxRtrAdvInterval].cf_value); | |
| 551 return; | |
| 552 } | |
| 553 if (cip->ci_index == I_MaxRtrAdvInterval && | |
| 554 confvar[I_AdvDefaultLifetime].cf_notdefault && | |
| 555 confvar[I_AdvDefaultLifetime].cf_value < val) { | |
| 556 conferr("AdvDefaultLifetime (%u) is not between " | |
| 557 "MaxRtrAdrInterval and 9000 seconds\n", | |
| 558 confvar[I_AdvDefaultLifetime].cf_value); | |
| 559 return; | |
| 560 } | |
| 561 } | |
| 562 confvar[cip->ci_index].cf_value = val; | |
| 563 confvar[cip->ci_index].cf_notdefault = _B_TRUE; | |
| 564 | |
| 565 /* Derive dynamic/relative variables based on this one */ | |
| 566 if (type == CONFIG_IF) { | |
| 567 if (cip->ci_index == I_MaxRtrAdvInterval && | |
| 568 !confvar[I_MinRtrAdvInterval].cf_notdefault) | |
| 569 confvar[I_MinRtrAdvInterval].cf_value = val / 3; | |
| 570 if (cip->ci_index == I_MaxRtrAdvInterval && | |
| 571 !confvar[I_AdvDefaultLifetime].cf_notdefault) | |
| 572 confvar[I_AdvDefaultLifetime].cf_value = 3 * val; | |
| 573 } | |
| 574 } | |
| 575 | |
| 576 /* | |
| 577 * Split up the line into <variable> <value> pairs | |
| 578 */ | |
| 579 static void | |
| 580 parse_default(config_type_t type, struct configinfo *list, | |
| 581 char *argvec[], int argcount, struct confvar *defaults) | |
| 582 { | |
| 583 if (debug & D_CONFIG) | |
| 584 logmsg(LOG_DEBUG, "parse_default: argc %d\n", argcount); | |
| 585 while (argcount >= 2) { | |
| 586 parse_var_value(type, list, argvec[0], argvec[1], defaults); | |
| 587 | |
| 588 argcount -= 2; | |
| 589 argvec += 2; | |
| 590 } | |
| 591 if (argcount != 0) | |
| 592 conferr("Trailing text <%s> ignored\n", argvec[0]); | |
| 593 } | |
| 594 | |
| 595 /* | |
| 596 * Returns true if ok; otherwise false. | |
| 597 */ | |
| 598 static void | |
| 599 parse_if(struct configinfo *list, char *argvec[], int argcount) | |
| 600 { | |
| 601 char *ifname; | |
| 602 struct phyint *pi; | |
| 603 char save[sizeof (pi->pi_config)]; | |
| 604 | |
| 605 if (debug & D_CONFIG) | |
| 606 logmsg(LOG_DEBUG, "parse_if: argc %d\n", argcount); | |
| 607 | |
| 608 if (argcount < 1) { | |
| 609 conferr("Missing interface name\n"); | |
| 610 return; | |
| 611 } | |
| 612 ifname = argvec[0]; | |
| 613 argvec++; | |
| 614 argcount--; | |
| 615 | |
| 616 pi = phyint_lookup(ifname); | |
| 617 if (pi == NULL) { | |
| 618 /* | |
| 619 * Create the physical interface structure. | |
| 620 * Note, phyint_create() sets the interface | |
| 621 * defaults in pi_config. | |
| 622 */ | |
| 623 pi = phyint_create(ifname); | |
| 624 if (pi == NULL) { | |
| 625 conferr("Unable to use interface %s\n", ifname); | |
| 626 return; | |
| 627 } | |
| 628 } | |
| 629 | |
| 630 (void) memcpy(save, pi->pi_config, sizeof (save)); | |
| 631 while (argcount >= 2) { | |
| 632 parse_var_value(CONFIG_IF, list, argvec[0], argvec[1], | |
| 633 pi->pi_config); | |
| 634 | |
| 635 argcount -= 2; | |
| 636 argvec += 2; | |
| 637 } | |
| 638 if (argcount != 0) | |
| 639 logmsg(LOG_ERR, "Trailing text <%s> ignored\n", argvec[0]); | |
| 640 check_if_var_consistency(pi->pi_config, save, sizeof (save)); | |
| 641 } | |
| 642 | |
| 643 static void | |
| 644 parse_prefix(struct configinfo *list, char *argvec[], int argcount) | |
| 645 { | |
| 646 char *ifname, *prefix; | |
| 647 struct phyint *pi; | |
| 648 struct adv_prefix *adv_pr; | |
| 649 struct in6_addr in6; | |
| 650 int prefixlen; | |
| 651 char save[sizeof (adv_pr->adv_pr_config)]; | |
| 652 | |
| 653 if (debug & D_CONFIG) | |
| 654 logmsg(LOG_DEBUG, "parse_prefix: argc %d\n", argcount); | |
| 655 | |
| 656 if (argcount < 2) { | |
| 657 conferr("Missing prefix and/or interface name\n"); | |
| 658 return; | |
| 659 } | |
| 660 prefix = argvec[0]; | |
| 661 ifname = argvec[1]; | |
| 662 argvec += 2; | |
| 663 argcount -= 2; | |
| 664 | |
| 665 prefixlen = parse_addrprefix(prefix, &in6); | |
| 666 if (prefixlen == -1) { | |
| 667 conferr("Bad prefix %s\n", prefix); | |
| 668 return; | |
| 669 } | |
| 670 | |
| 671 pi = phyint_lookup(ifname); | |
| 672 if (pi == NULL) { | |
| 673 /* | |
| 674 * Create the physical interface structure. | |
| 675 * Note, phyint_create() sets the interface | |
| 676 * defaults in pi_config. | |
| 677 */ | |
| 678 pi = phyint_create(ifname); | |
| 679 if (pi == NULL) { | |
| 680 conferr("Unable to use interface %s\n", ifname); | |
| 681 return; | |
| 682 } | |
| 683 } | |
| 684 adv_pr = adv_prefix_lookup(pi, in6, prefixlen); | |
| 685 if (adv_pr == NULL) { | |
| 686 int i; | |
| 687 | |
| 688 adv_pr = adv_prefix_create(pi, in6, prefixlen); | |
| 689 if (adv_pr == NULL) { | |
| 690 conferr("Unable to create prefix %s\n", prefix); | |
| 691 return; | |
| 692 } | |
| 693 /* | |
| 694 * Copy the defaults from the default array. | |
| 695 */ | |
| 696 for (i = 0; i < I_PREFIXSIZE; i++) { | |
| 697 adv_pr->adv_pr_config[i].cf_value = | |
| 698 prefixdefaults[i].cf_value; | |
| 699 adv_pr->adv_pr_config[i].cf_notdefault = | |
| 700 prefixdefaults[i].cf_notdefault; | |
| 701 } | |
| 702 } | |
| 703 | |
| 704 (void) memcpy(save, adv_pr->adv_pr_config, sizeof (save)); | |
| 705 while (argcount >= 2) { | |
| 706 parse_var_value(CONFIG_PREFIX, list, argvec[0], argvec[1], | |
| 707 adv_pr->adv_pr_config); | |
| 708 | |
| 709 argcount -= 2; | |
| 710 argvec += 2; | |
| 711 } | |
| 712 check_var_consistency(adv_pr->adv_pr_config, save, sizeof (save)); | |
| 713 if (argcount != 0) | |
| 714 logmsg(LOG_ERR, "Trailing text <%s> ignored\n", argvec[0]); | |
| 715 } | |
| 716 | |
| 717 /* | |
| 718 * Returns true if ok (and *resp updated) and false if failed. | |
| 719 */ | |
| 720 static boolean_t | |
| 721 parse_onoff(char *str, uint_t *resp) | |
| 722 { | |
| 723 if (strcasecmp(str, "on") == 0) { | |
| 724 *resp = 1; | |
| 725 return (_B_TRUE); | |
| 726 } | |
| 727 if (strcasecmp(str, "off") == 0) { | |
| 728 *resp = 0; | |
| 729 return (_B_TRUE); | |
| 730 } | |
| 731 if (strcasecmp(str, "true") == 0) { | |
| 732 *resp = 1; | |
| 733 return (_B_TRUE); | |
| 734 } | |
| 735 if (strcasecmp(str, "false") == 0) { | |
| 736 *resp = 0; | |
| 737 return (_B_TRUE); | |
| 738 } | |
| 739 if (parse_int(str, resp)) { | |
| 740 if (*resp == 0 || *resp == 1) | |
| 741 return (_B_TRUE); | |
| 742 } | |
| 743 return (_B_FALSE); | |
| 744 } | |
| 745 | |
| 746 /* | |
| 747 * Returns true if ok (and *resp updated) and false if failed. | |
| 748 */ | |
| 749 static boolean_t | |
| 750 parse_int(char *str, uint_t *resp) | |
| 751 { | |
| 752 char *end; | |
| 753 int res; | |
| 754 | |
| 755 res = strtoul(str, &end, 0); | |
| 756 if (end == str) | |
| 757 return (_B_FALSE); | |
| 758 *resp = res; | |
| 759 return (_B_TRUE); | |
| 760 } | |
| 761 | |
| 762 /* | |
| 763 * Parse something with a unit of millseconds. | |
| 764 * Regognizes the suffixes "ms", "s", "m", "h", and "d". | |
| 765 * | |
| 766 * Returns true if ok (and *resp updated) and false if failed. | |
| 767 */ | |
| 768 static boolean_t | |
| 769 parse_ms(char *str, uint_t *resp) | |
| 770 { | |
| 771 /* Look at the last and next to last character */ | |
| 772 char *cp, *last, *nlast; | |
| 773 char str2[BUFSIZ]; /* For local modification */ | |
| 774 int multiplier = 1; | |
| 775 | |
| 776 (void) strncpy(str2, str, sizeof (str2)); | |
| 777 str2[sizeof (str2) - 1] = '\0'; | |
| 778 | |
| 779 last = str2; | |
| 780 nlast = NULL; | |
| 781 for (cp = str2; *cp != '\0'; cp++) { | |
| 782 nlast = last; | |
| 783 last = cp; | |
| 784 } | |
| 785 if (debug & D_PARSE) { | |
| 786 logmsg(LOG_DEBUG, "parse_ms: last <%c> nlast <%c>\n", | |
| 787 (last != NULL ? *last : ' '), | |
| 788 (nlast != NULL ? *nlast : ' ')); | |
| 789 } | |
| 790 switch (*last) { | |
| 791 case 'd': | |
| 792 multiplier *= 24; | |
| 793 /* FALLTHRU */ | |
| 794 case 'h': | |
| 795 multiplier *= 60; | |
| 796 /* FALLTHRU */ | |
| 797 case 'm': | |
| 798 multiplier *= 60; | |
| 799 *last = '\0'; | |
| 800 multiplier *= 1000; /* Convert to milliseconds */ | |
| 801 break; | |
| 802 case 's': | |
| 803 /* Could be "ms" or "s" */ | |
| 804 if (nlast != NULL && *nlast == 'm') { | |
| 805 /* "ms" */ | |
| 806 *nlast = '\0'; | |
| 807 } else { | |
| 808 *last = '\0'; | |
| 809 multiplier *= 1000; /* Convert to milliseconds */ | |
| 810 } | |
| 811 break; | |
| 812 } | |
| 813 | |
| 814 if (!parse_int(str2, resp)) | |
| 815 return (_B_FALSE); | |
| 816 | |
| 817 *resp *= multiplier; | |
| 818 return (_B_TRUE); | |
| 819 } | |
| 820 | |
| 821 /* | |
| 822 * Parse something with a unit of seconds. | |
| 823 * Regognizes the suffixes "s", "m", "h", and "d". | |
| 824 * | |
| 825 * Returns true if ok (and *resp updated) and false if failed. | |
| 826 */ | |
| 827 static boolean_t | |
| 828 parse_s(char *str, uint_t *resp) | |
| 829 { | |
| 830 /* Look at the last character */ | |
| 831 char *cp, *last; | |
| 832 char str2[BUFSIZ]; /* For local modification */ | |
| 833 int multiplier = 1; | |
| 834 | |
| 835 (void) strncpy(str2, str, sizeof (str2)); | |
| 836 str2[sizeof (str2) - 1] = '\0'; | |
| 837 | |
| 838 last = str2; | |
| 839 for (cp = str2; *cp != '\0'; cp++) { | |
| 840 last = cp; | |
| 841 } | |
| 842 if (debug & D_PARSE) { | |
| 843 logmsg(LOG_DEBUG, "parse_s: last <%c>\n", | |
| 844 (last != NULL ? *last : ' ')); | |
| 845 } | |
| 846 switch (*last) { | |
| 847 case 'd': | |
| 848 multiplier *= 24; | |
| 849 /* FALLTHRU */ | |
| 850 case 'h': | |
| 851 multiplier *= 60; | |
| 852 /* FALLTHRU */ | |
| 853 case 'm': | |
| 854 multiplier *= 60; | |
| 855 /* FALLTHRU */ | |
| 856 case 's': | |
| 857 *last = '\0'; | |
| 858 break; | |
| 859 } | |
| 860 if (!parse_int(str2, resp)) | |
| 861 return (_B_FALSE); | |
| 862 | |
| 863 *resp *= multiplier; | |
| 864 return (_B_TRUE); | |
| 865 } | |
| 866 | |
| 867 /* | |
| 868 * Return prefixlen (0 to 128) if ok; -1 if failed. | |
| 869 */ | |
| 870 static int | |
| 871 parse_addrprefix(char *strin, struct in6_addr *in6) | |
| 872 { | |
| 873 char str[BUFSIZ]; /* Local copy for modification */ | |
| 874 int prefixlen; | |
| 875 char *cp; | |
| 876 char *end; | |
| 877 | |
| 878 (void) strncpy(str, strin, sizeof (str)); | |
| 879 str[sizeof (str) - 1] = '\0'; | |
| 880 | |
| 881 cp = strchr(str, '/'); | |
| 882 if (cp == NULL) | |
| 883 return (-1); | |
| 884 *cp = '\0'; | |
| 885 cp++; | |
| 886 | |
| 887 prefixlen = strtol(cp, &end, 10); | |
| 888 if (cp == end) | |
| 889 return (-1); | |
| 890 | |
| 891 if (prefixlen < 0 || prefixlen > IPV6_ABITS) | |
| 892 return (-1); | |
| 893 | |
| 894 if (inet_pton(AF_INET6, str, in6) != 1) | |
| 895 return (-1); | |
| 896 | |
| 897 return (prefixlen); | |
| 898 } | |
| 899 | |
| 900 /* | |
| 901 * Parse an absolute date using a datemsk config file. | |
| 902 * Return the difference (measured in seconds) between that date/time and | |
| 903 * the current date/time. | |
| 904 * If the date has passed return zero. | |
| 905 * | |
| 906 * Returns true if ok (and *resp updated) and false if failed. | |
| 907 * XXX Due to getdate limitations can not exceed year 2038. | |
| 908 */ | |
| 909 static boolean_t | |
| 910 parse_date(char *str, uint_t *resp) | |
| 911 { | |
| 912 struct tm *tm; | |
| 913 struct timeval tvs; | |
| 914 time_t time, ntime; | |
| 915 | |
| 916 if (getenv("DATEMSK") == NULL) { | |
| 917 (void) putenv("DATEMSK=/etc/inet/datemsk.ndpd"); | |
| 918 } | |
| 919 | |
| 920 if (gettimeofday(&tvs, NULL) < 0) { | |
| 921 logperror("gettimeofday"); | |
| 922 return (_B_FALSE); | |
| 923 } | |
| 924 time = tvs.tv_sec; | |
| 925 tm = getdate(str); | |
| 926 if (tm == NULL) { | |
| 927 logmsg(LOG_ERR, "Bad date <%s> (error %d)\n", | |
| 928 str, getdate_err); | |
| 929 return (_B_FALSE); | |
| 930 } | |
| 931 | |
| 932 ntime = mktime(tm); | |
| 933 | |
| 934 if (debug & D_PARSE) { | |
| 935 char buf[BUFSIZ]; | |
| 936 | |
| 937 (void) strftime(buf, sizeof (buf), "%Y-%m-%d %R %Z", tm); | |
| 938 logmsg(LOG_DEBUG, "parse_date: <%s>, delta %ld seconds\n", | |
| 939 buf, ntime - time); | |
| 940 } | |
| 941 if (ntime < time) { | |
| 942 conferr("Date in the past <%s>\n", str); | |
| 943 *resp = 0; | |
| 944 return (_B_TRUE); | |
| 945 } | |
| 946 *resp = (ntime - time); | |
| 947 return (_B_TRUE); | |
| 948 } | |
| 949 | |
| 950 /* PRINTFLIKE1 */ | |
| 951 static void | |
| 952 conferr(char *fmt, ...) | |
| 953 { | |
| 954 char msg[NDPD_LOGMSGSIZE]; | |
| 955 size_t slen; | |
| 956 | |
| 957 va_list ap; | |
| 958 va_start(ap, fmt); | |
| 959 | |
| 960 (void) snprintf(msg, NDPD_LOGMSGSIZE, "%s line %d: ", | |
| 961 conf_filename, lineno); | |
| 962 slen = strlen(msg); | |
| 963 (void) vsnprintf(msg + slen, NDPD_LOGMSGSIZE - slen, fmt, ap); | |
| 964 | |
| 965 logmsg(LOG_ERR, "%s", msg); | |
| 966 | |
| 967 va_end(ap); | |
| 968 } | |
| 969 | |
| 970 static FILE * | |
| 971 open_conffile(char *filename) | |
| 972 { | |
| 973 if (strlcpy(conf_filename, filename, MAXPATHLEN) >= MAXPATHLEN) { | |
| 974 logmsg(LOG_ERR, "config file pathname is too long\n"); | |
| 975 return (NULL); | |
| 976 } | |
| 977 | |
| 978 lineno = 0; | |
| 979 | |
| 980 return (fopen(filename, "r")); | |
| 981 | |
| 982 } |