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