patch tsoome-feedback

   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 
  35 #include "common.h"
  36 #include "defaults.h"
  37 
  38 struct dhcp_default {
  39 
  40         const char      *df_name;       /* parameter name */
  41         const char      *df_default;    /* default value */
  42         int             df_min;         /* min value if type DF_INTEGER */
  43         int             df_max;         /* max value if type DF_INTEGER */
  44 };
  45 
  46 /*
  47  * note: keep in the same order as tunable parameter constants in defaults.h
  48  */
  49 
  50 static struct dhcp_default defaults[] = {
  51 
  52         { "RELEASE_ON_SIGTERM",  "0",    0,   0   },
  53         { "IGNORE_FAILED_ARP",   "1",    0,   -1  },
  54         { "OFFER_WAIT",          "3",    1,   20  },
  55         { "ARP_WAIT",            "1000", 0,   -1  },
  56         { "CLIENT_ID",           NULL,   0,   0   },
  57         { "PARAM_REQUEST_LIST",  NULL,   0,   0   },
  58         { "REQUEST_HOSTNAME",    "1",    0,   0   },
  59         { "DEBUG_LEVEL",         "0",    0,   3   },
  60         { "VERBOSE",             "0",    0,   0   },
  61         { "VERIFIED_LEASE_ONLY", "0",    0,   0   },
  62         { "PARAM_IGNORE_LIST",   NULL,   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                 nvlist_free(df_nvlist);
 190                 df_nvlist = df_build_cache();
 191         }
 192 
 193         if (isv6) {
 194                 (void) snprintf(name, sizeof (name), ".V6.%s",
 195                     defaults[param].df_name);
 196                 (void) snprintf(paramstr, sizeof (paramstr), "%s%s", if_name,
 197                     name);
 198         } else {
 199                 (void) strlcpy(name, defaults[param].df_name, sizeof (name));
 200                 (void) snprintf(paramstr, sizeof (paramstr), "%s.%s", if_name,
 201                     name);
 202         }
 203 
 204         /*
 205          * first look for `if_name.[v6.]param', then `[v6.]param'.  if neither
 206          * has been set, use the built-in default.
 207          */
 208 
 209         if (nvlist_lookup_string(df_nvlist, paramstr, &value) == 0 ||
 210             nvlist_lookup_string(df_nvlist, name, &value) == 0)
 211                 return (value);
 212 
 213         return (defaults[param].df_default);
 214 }
 215 
 216 /*
 217  * df_get_int(): gets the integer value of a given user-tunable parameter
 218  *
 219  *   input: const char *: the interface the parameter applies to
 220  *          boolean_t: B_TRUE for DHCPv6, B_FALSE for IPv4 DHCP
 221  *          uint_t: the parameter number to look up
 222  *  output: int: the parameter's value, or default if not set
 223  */
 224 
 225 int
 226 df_get_int(const char *if_name, boolean_t isv6, uint_t param)
 227 {
 228         const char      *value;
 229         int             value_int;
 230 
 231         if (param >= (sizeof (defaults) / sizeof (*defaults)))
 232                 return (0);
 233 
 234         value = df_get_string(if_name, isv6, param);
 235         if (value == NULL || !isdigit(*value))
 236                 goto failure;
 237 
 238         value_int = atoi(value);
 239         if (value_int > defaults[param].df_max ||
 240             value_int < defaults[param].df_min)
 241                 goto failure;
 242 
 243         return (value_int);
 244 
 245 failure:
 246         dhcpmsg(MSG_WARNING, "df_get_int: parameter `%s' is not between %d and "
 247             "%d, defaulting to `%s'", defaults[param].df_name,
 248             defaults[param].df_min, defaults[param].df_max,
 249             defaults[param].df_default);
 250         return (atoi(defaults[param].df_default));
 251 }
 252 
 253 /*
 254  * df_get_bool(): gets the boolean value of a given user-tunable parameter
 255  *
 256  *   input: const char *: the interface the parameter applies to
 257  *          boolean_t: B_TRUE for DHCPv6, B_FALSE for IPv4 DHCP
 258  *          uint_t: the parameter number to look up
 259  *  output: boolean_t: B_TRUE if true, B_FALSE if false, default if not set
 260  */
 261 
 262 boolean_t
 263 df_get_bool(const char *if_name, boolean_t isv6, uint_t param)
 264 {
 265         const char      *value;
 266 
 267         if (param >= (sizeof (defaults) / sizeof (*defaults)))
 268                 return (0);
 269 
 270         value = df_get_string(if_name, isv6, param);
 271         if (value != NULL) {
 272 
 273                 if (strcasecmp(value, "true") == 0 ||
 274                     strcasecmp(value, "yes") == 0 || strcmp(value, "1") == 0)
 275                         return (B_TRUE);
 276 
 277                 if (strcasecmp(value, "false") == 0 ||
 278                     strcasecmp(value, "no") == 0 || strcmp(value, "0") == 0)
 279                         return (B_FALSE);
 280         }
 281 
 282         dhcpmsg(MSG_WARNING, "df_get_bool: parameter `%s' has invalid value "
 283             "`%s', defaulting to `%s'", defaults[param].df_name,
 284             value != NULL ? value : "NULL", defaults[param].df_default);
 285 
 286         return ((atoi(defaults[param].df_default) == 0) ? B_FALSE : B_TRUE);
 287 }
--- EOF ---