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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright (c) 2016, Chris Fraire <cfraire@me.com>.
25 */
26
27 #include <sys/types.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <ctype.h>
31 #include <dhcpmsg.h>
32 #include <stdio.h>
33 #include <sys/stat.h>
34 #include <libnvpair.h>
35
36 #include "common.h"
37 #include "defaults.h"
38
39 struct dhcp_default {
40
41 const char *df_name; /* parameter name */
42 const char *df_default; /* default value */
43 int df_min; /* min value if type DF_INTEGER */
44 int df_max; /* max value if type DF_INTEGER */
45 };
46
47 /*
48 * note: keep in the same order as tunable parameter constants in defaults.h
49 */
50
51 static struct dhcp_default defaults[] = {
52
53 { "RELEASE_ON_SIGTERM", "0", 0, 0 },
54 { "IGNORE_FAILED_ARP", "1", 0, -1 },
55 { "OFFER_WAIT", "3", 1, 20 },
56 { "ARP_WAIT", "1000", 0, -1 },
57 { "CLIENT_ID", NULL, 0, 0 },
58 { "PARAM_REQUEST_LIST", NULL, 0, 0 },
59 { "REQUEST_HOSTNAME", "1", 0, 0 },
60 { "DEBUG_LEVEL", "0", 0, 3 },
61 { "VERBOSE", "0", 0, 0 },
62 { "VERIFIED_LEASE_ONLY", "0", 0, 0 },
63 { "PARAM_IGNORE_LIST", NULL, 0, 0 },
64 { "REQUEST_FQDN", "1", 0, 0 },
65 { "V4_DEFAULT_IAID_DUID", "0", 0, 0 },
66 };
67
68 /*
69 * df_build_cache(): builds the defaults nvlist cache
70 *
71 * input: void
72 * output: a pointer to an nvlist of the current defaults, or NULL on failure
73 */
74
75 static nvlist_t *
76 df_build_cache(void)
77 {
78 char entry[1024];
79 int i;
80 char *param, *pastv6, *value, *end;
81 FILE *fp;
82 nvlist_t *nvlist;
83 struct dhcp_default *defp;
84
85 if ((fp = fopen(DHCP_AGENT_DEFAULTS, "r")) == NULL)
86 return (NULL);
87
88 if (nvlist_alloc(&nvlist, NV_UNIQUE_NAME, 0) != 0) {
89 dhcpmsg(MSG_WARNING, "cannot build default value cache; "
90 "using built-in defaults");
91 (void) fclose(fp);
92 return (NULL);
93 }
94
95 while (fgets(entry, sizeof (entry), fp) != NULL) {
96 for (i = 0; entry[i] == ' '; i++)
97 ;
98
99 end = strrchr(entry, '\n');
100 value = strchr(entry, '=');
101 if (end == NULL || value == NULL || entry[i] == '#')
102 continue;
103
104 *end = '\0';
105 *value++ = '\0';
106
107 /*
108 * to be compatible with the old defread()-based code
109 * which ignored case, store the parameters (except for the
110 * leading interface name) in upper case.
111 */
112
113 if ((param = strchr(entry, '.')) == NULL) {
114 pastv6 = param = entry;
115 } else {
116 pastv6 = ++param;
117 if (strncasecmp(param, "v6.", 3) == 0)
118 pastv6 += 3;
119 }
120
121 for (defp = defaults;
122 (char *)defp < (char *)defaults + sizeof (defaults);
123 defp++) {
124 if (strcasecmp(pastv6, defp->df_name) == 0) {
125 if (defp->df_max == -1) {
126 dhcpmsg(MSG_WARNING, "parameter %s is "
127 "obsolete; ignored", defp->df_name);
128 }
129 break;
130 }
131 }
132
133 for (; *param != '\0'; param++)
134 *param = toupper(*param);
135
136 if (nvlist_add_string(nvlist, &entry[i], value) != 0) {
137 dhcpmsg(MSG_WARNING, "cannot build default value cache;"
138 " using built-in defaults");
139 nvlist_free(nvlist);
140 nvlist = NULL;
141 break;
142 }
143 }
144
145 (void) fclose(fp);
146 return (nvlist);
147 }
148
149 /*
150 * df_get_string(): gets the string value of a given user-tunable parameter
151 *
152 * input: const char *: the interface the parameter applies to
153 * boolean_t: B_TRUE for DHCPv6, B_FALSE for IPv4 DHCP
154 * uint_t: the parameter number to look up
155 * output: const char *: the parameter's value, or default if not set
156 * (must be copied by caller to be kept)
157 * NOTE: df_get_string() is both used by functions outside this source
158 * file to retrieve strings from the defaults file, *and*
159 * internally by other df_get_*() functions.
160 */
161
162 const char *
163 df_get_string(const char *if_name, boolean_t isv6, uint_t param)
164 {
165 char *value;
166 char paramstr[256];
167 char name[256];
168 struct stat statbuf;
169 static struct stat df_statbuf;
170 static boolean_t df_unavail_msg = B_FALSE;
171 static nvlist_t *df_nvlist = NULL;
172
173 if (param >= (sizeof (defaults) / sizeof (*defaults)))
174 return (NULL);
175
176 if (stat(DHCP_AGENT_DEFAULTS, &statbuf) != 0) {
177 if (!df_unavail_msg) {
178 dhcpmsg(MSG_WARNING, "cannot access %s; using "
179 "built-in defaults", DHCP_AGENT_DEFAULTS);
180 df_unavail_msg = B_TRUE;
181 }
182 return (defaults[param].df_default);
183 }
184
185 /*
186 * if our cached parameters are stale, rebuild.
187 */
188
189 if (statbuf.st_mtime != df_statbuf.st_mtime ||
190 statbuf.st_size != df_statbuf.st_size) {
191 df_statbuf = statbuf;
192 nvlist_free(df_nvlist);
193 df_nvlist = df_build_cache();
194 }
195
196 if (isv6) {
197 (void) snprintf(name, sizeof (name), ".V6.%s",
198 defaults[param].df_name);
199 (void) snprintf(paramstr, sizeof (paramstr), "%s%s", if_name,
200 name);
201 } else {
202 (void) strlcpy(name, defaults[param].df_name, sizeof (name));
203 (void) snprintf(paramstr, sizeof (paramstr), "%s.%s", if_name,
204 name);
205 }
206
207 /*
208 * first look for `if_name.[v6.]param', then `[v6.]param'. if neither
209 * has been set, use the built-in default.
210 */
211
212 if (nvlist_lookup_string(df_nvlist, paramstr, &value) == 0 ||
213 nvlist_lookup_string(df_nvlist, name, &value) == 0)
214 return (value);
215
216 return (defaults[param].df_default);
217 }
218
219 /*
220 * df_get_int(): gets the integer value of a given user-tunable parameter
221 *
222 * input: const char *: the interface the parameter applies to
223 * boolean_t: B_TRUE for DHCPv6, B_FALSE for IPv4 DHCP
224 * uint_t: the parameter number to look up
225 * output: int: the parameter's value, or default if not set
226 */
227
228 int
229 df_get_int(const char *if_name, boolean_t isv6, uint_t param)
230 {
231 const char *value;
232 int value_int;
233
234 if (param >= (sizeof (defaults) / sizeof (*defaults)))
235 return (0);
236
237 value = df_get_string(if_name, isv6, param);
238 if (value == NULL || !isdigit(*value))
239 goto failure;
240
241 value_int = atoi(value);
242 if (value_int > defaults[param].df_max ||
243 value_int < defaults[param].df_min)
244 goto failure;
245
246 return (value_int);
247
248 failure:
249 dhcpmsg(MSG_WARNING, "df_get_int: parameter `%s' is not between %d and "
250 "%d, defaulting to `%s'", defaults[param].df_name,
251 defaults[param].df_min, defaults[param].df_max,
252 defaults[param].df_default);
253 return (atoi(defaults[param].df_default));
254 }
255
256 /*
257 * df_get_bool(): gets the boolean value of a given user-tunable parameter
258 *
259 * input: const char *: the interface the parameter applies to
260 * boolean_t: B_TRUE for DHCPv6, B_FALSE for IPv4 DHCP
261 * uint_t: the parameter number to look up
262 * output: boolean_t: B_TRUE if true, B_FALSE if false, default if not set
263 */
264
265 boolean_t
266 df_get_bool(const char *if_name, boolean_t isv6, uint_t param)
267 {
268 const char *value;
269
270 if (param >= (sizeof (defaults) / sizeof (*defaults)))
271 return (0);
272
273 value = df_get_string(if_name, isv6, param);
274 if (value != NULL) {
275
276 if (strcasecmp(value, "true") == 0 ||
277 strcasecmp(value, "yes") == 0 || strcmp(value, "1") == 0)
278 return (B_TRUE);
279
280 if (strcasecmp(value, "false") == 0 ||
281 strcasecmp(value, "no") == 0 || strcmp(value, "0") == 0)
282 return (B_FALSE);
283 }
284
285 dhcpmsg(MSG_WARNING, "df_get_bool: parameter `%s' has invalid value "
286 "`%s', defaulting to `%s'", defaults[param].df_name,
287 value != NULL ? value : "NULL", defaults[param].df_default);
288
289 return ((atoi(defaults[param].df_default) == 0) ? B_FALSE : B_TRUE);
290 }