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 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
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
check_var_consistency(struct confvar * cv,void * save,int size)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
check_if_var_consistency(struct confvar * cv,void * save,int size)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
parse_config(char * config_file,boolean_t file_required)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
set_protocol_defaults(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
print_iflist(struct confvar * confvar)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
print_prefixlist(struct confvar * confvar)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
print_defaults(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
readline(FILE * fp,char * line,int length)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
parse_line(char * line,char * argvec[],int argcount)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
parse_var_value(config_type_t type,struct configinfo * list,char * varstr,char * valstr,struct confvar * confvar)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
parse_default(config_type_t type,struct configinfo * list,char * argvec[],int argcount,struct confvar * defaults)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
parse_if(struct configinfo * list,char * argvec[],int argcount)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
parse_prefix(struct configinfo * list,char * argvec[],int argcount)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
parse_onoff(char * str,uint_t * resp)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
parse_int(char * str,uint_t * resp)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
parse_ms(char * str,uint_t * resp)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
parse_s(char * str,uint_t * resp)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
parse_addrprefix(char * strin,struct in6_addr * in6)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
parse_date(char * str,uint_t * resp)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
conferr(char * fmt,...)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 *
open_conffile(char * filename)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 }
983