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