server/stables.c

   1 /* stables.c
   2
   3    Tables of information only used by server... */
   4
   5 /*
   6  * Copyright (c) 2004-2016 by Internet Systems Consortium, Inc. ("ISC")
   7  * Copyright (c) 1995-2003 by Internet Software Consortium
   8  *
   9  * Permission to use, copy, modify, and distribute this software for any
  10  * purpose with or without fee is hereby granted, provided that the above
  11  * copyright notice and this permission notice appear in all copies.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  15  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  19  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20  *
  21  *   Internet Systems Consortium, Inc.
  22  *   950 Charter Street
  23  *   Redwood City, CA 94063
  24  *   <info@isc.org>
  25  *   https://www.isc.org/
  26  *
  27  */
  28
  29 #include "dhcpd.h"
  30 #include <syslog.h>
  31
  32 #if defined (FAILOVER_PROTOCOL)
  33
  34 /* This is used to indicate some kind of failure when generating a
  35    failover option. */
  36 failover_option_t null_failover_option = { 0, 0 };
  37 failover_option_t skip_failover_option = { 0, 0 };
  38
  39 /* Information about failover options, for printing, encoding
  40    and decoding. */
  41 struct failover_option_info ft_options [] =
  42 {
  43         { 0, "unused", FT_UNDEF, 0, 0, 0 },
  44         { FTO_ADDRESSES_TRANSFERRED, "addresses-transferred", FT_UINT32, 1,
  45           FM_OFFSET(addresses_transferred), FTB_ADDRESSES_TRANSFERRED },
  46         { FTO_ASSIGNED_IP_ADDRESS, "assigned-IP-address", FT_IPADDR, 1,
  47           FM_OFFSET(assigned_addr), FTB_ASSIGNED_IP_ADDRESS },
  48         { FTO_BINDING_STATUS, "binding-status", FT_UINT8, 1,
  49           FM_OFFSET(binding_status), FTB_BINDING_STATUS },
  50         { FTO_CLIENT_IDENTIFIER, "client-identifier", FT_BYTES, 0,
  51           FM_OFFSET(client_identifier), FTB_CLIENT_IDENTIFIER },
  52         { FTO_CHADDR, "client-hardware-address", FT_BYTES, 0,
  53           FM_OFFSET(chaddr), FTB_CHADDR },
  54         { FTO_CLTT, "client-last-transaction-time", FT_UINT32, 1,
  55           FM_OFFSET(cltt), FTB_CLTT },
  56         { FTO_REPLY_OPTIONS, "client-reply-options", FT_BYTES, 0,
  57           FM_OFFSET(reply_options), FTB_REPLY_OPTIONS },
  58         { FTO_REQUEST_OPTIONS, "client-request-options", FT_BYTES, 0,
  59           FM_OFFSET(request_options), FTB_REQUEST_OPTIONS },
  60         { FTO_DDNS, "DDNS", FT_DDNS, 1, FM_OFFSET(ddns), FTB_DDNS },
  61         { FTO_DELAYED_SERVICE, "delayed-service", FT_UINT8, 1,
  62           FM_OFFSET(delayed_service), FTB_DELAYED_SERVICE },
  63         { FTO_HBA, "hash-bucket-assignment", FT_BYTES, 0,
  64           FM_OFFSET(hba), FTB_HBA },
  65         { FTO_IP_FLAGS, "IP-flags", FT_UINT16, 1,
  66           FM_OFFSET(ip_flags), FTB_IP_FLAGS },
  67         { FTO_LEASE_EXPIRY, "lease-expiration-time", FT_UINT32, 1,
  68           FM_OFFSET(expiry), FTB_LEASE_EXPIRY },
  69         { FTO_MAX_UNACKED, "max-unacked-bndupd", FT_UINT32, 1,
  70           FM_OFFSET(max_unacked), FTB_MAX_UNACKED },
  71         { FTO_MCLT, "MCLT", FT_UINT32, 1, FM_OFFSET(mclt), FTB_MCLT },
  72         { FTO_MESSAGE, "message", FT_TEXT, 0,
  73           FM_OFFSET(message), FTB_MESSAGE },
  74         { FTO_MESSAGE_DIGEST, "message-digest", FT_BYTES, 0,
  75           FM_OFFSET(message_digest), FTB_MESSAGE_DIGEST },
  76         { FTO_POTENTIAL_EXPIRY, "potential-expiration-time", FT_UINT32, 1,
  77           FM_OFFSET(potential_expiry), FTB_POTENTIAL_EXPIRY },
  78         { FTO_RECEIVE_TIMER, "receive-timer", FT_UINT32, 1,
  79           FM_OFFSET(receive_timer), FTB_RECEIVE_TIMER },
  80         { FTO_PROTOCOL_VERSION, "protocol-version", FT_UINT8, 1,
  81           FM_OFFSET(protocol_version), FTB_PROTOCOL_VERSION },
  82         { FTO_REJECT_REASON, "reject-reason", FT_UINT8, 1,
  83           FM_OFFSET(reject_reason), FTB_REJECT_REASON },
  84         { FTO_RELATIONSHIP_NAME, "relationship-name", FT_BYTES, 0,
  85           FM_OFFSET(relationship_name), FTB_RELATIONSHIP_NAME },
  86         { FTO_SERVER_FLAGS, "server-flags", FT_UINT8, 1,
  87           FM_OFFSET(server_flags), FTB_SERVER_FLAGS },
  88         { FTO_SERVER_STATE, "server-state", FT_UINT8, 1,
  89           FM_OFFSET(server_state), FTB_SERVER_STATE },
  90         { FTO_STOS, "start-time-of-state", FT_UINT32, 1,
  91           FM_OFFSET(stos), FTB_STOS },
  92         { FTO_TLS_REPLY, "TLS-reply", FT_UINT8, 1,
  93           FM_OFFSET(tls_reply), FTB_TLS_REPLY },
  94         { FTO_TLS_REQUEST, "TLS-request", FT_UINT8, 1,
  95           FM_OFFSET(tls_request), FTB_TLS_REQUEST },
  96         { FTO_VENDOR_CLASS, "vendor-class-identifier", FT_BYTES, 0,
  97           FM_OFFSET(vendor_class), FTB_VENDOR_CLASS },
  98         { FTO_VENDOR_OPTIONS, "vendor-specific-options", FT_BYTES, 0,
  99           FM_OFFSET(vendor_options), FTB_VENDOR_OPTIONS }
 100 };
 101
 102 /* These are really options that make sense for a particular request - if
 103    some other option comes in, we're not going to use it, so we can just
 104    discard it.  Note that the message-digest option is allowed for all
 105    message types, but is not saved - it's just used to validate the message
 106    and then discarded - so it's not mentioned here. */
 107
 108 u_int32_t fto_allowed [] = {
 109         0,      /* 0 unused */
 110         0,      /* 1 POOLREQ */
 111         FTB_ADDRESSES_TRANSFERRED, /* 2 POOLRESP */
 112         (FTB_ASSIGNED_IP_ADDRESS | FTB_BINDING_STATUS | FTB_CLIENT_IDENTIFIER |
 113          FTB_CHADDR | FTB_DDNS | FTB_IP_FLAGS | FTB_LEASE_EXPIRY |
 114          FTB_POTENTIAL_EXPIRY | FTB_STOS | FTB_CLTT | FTB_REQUEST_OPTIONS |
 115          FTB_REPLY_OPTIONS), /* 3 BNDUPD */
 116         (FTB_ASSIGNED_IP_ADDRESS | FTB_BINDING_STATUS | FTB_CLIENT_IDENTIFIER |
 117          FTB_CHADDR | FTB_DDNS | FTB_IP_FLAGS | FTB_LEASE_EXPIRY |
 118          FTB_POTENTIAL_EXPIRY | FTB_STOS | FTB_CLTT | FTB_REQUEST_OPTIONS |
 119          FTB_REPLY_OPTIONS | FTB_REJECT_REASON | FTB_MESSAGE), /* 4 BNDACK */
 120         (FTB_RELATIONSHIP_NAME | FTB_MAX_UNACKED | FTB_RECEIVE_TIMER |
 121          FTB_VENDOR_CLASS | FTB_PROTOCOL_VERSION | FTB_TLS_REQUEST |
 122          FTB_MCLT | FTB_HBA), /* 5 CONNECT */
 123         (FTB_RELATIONSHIP_NAME | FTB_MAX_UNACKED | FTB_RECEIVE_TIMER |
 124          FTB_VENDOR_CLASS | FTB_PROTOCOL_VERSION | FTB_TLS_REPLY |
 125          FTB_REJECT_REASON | FTB_MESSAGE), /* CONNECTACK */
 126         0, /* 7 UPDREQALL */
 127         0, /* 8 UPDDONE */
 128         0, /* 9 UPDREQ */
 129         (FTB_SERVER_STATE | FTB_SERVER_FLAGS | FTB_STOS), /* 10 STATE */
 130         0,      /* 11 CONTACT */
 131         (FTB_REJECT_REASON | FTB_MESSAGE) /* 12 DISCONNECT */
 132 };
 133
 134 /* Sizes of the various types. */
 135 int ft_sizes [] = {
 136         1, /* FT_UINT8 */
 137         4, /* FT_IPADDR */
 138         4, /* FT_UINT32 */
 139         1, /* FT_BYTES */
 140         1, /* FT_TEXT_OR_BYTES */
 141         0, /* FT_DDNS */
 142         0, /* FT_DDNS1 */
 143         2, /* FT_UINT16 */
 144         1, /* FT_TEXT */
 145         0, /* FT_UNDEF */
 146         0, /* FT_DIGEST */
 147 };
 148
 149 /* Names of the various failover link states. */
 150 const char *dhcp_flink_state_names [] = {
 151         "invalid state 0",
 152         "startup",
 153         "message length wait",
 154         "message wait",
 155         "disconnected"
 156 };
 157 #endif /* FAILOVER_PROTOCOL */
 158
 159 /* Failover binding state names.   These are used even if there is no
 160    failover protocol support. */
 161 const char *binding_state_names [] = {
 162         "free", "active", "expired", "released", "abandoned",
 163         "reset", "backup" };
 164
 165 struct universe agent_universe;
 166 static struct option agent_options[] = {
 167         { "circuit-id", "X",                    &agent_universe,   1, 1 },
 168         { "remote-id", "X",                     &agent_universe,   2, 1 },
 169         { "agent-id", "I",                      &agent_universe,   3, 1 },
 170         { "DOCSIS-device-class", "L",           &agent_universe,   4, 1 },
 171         { "link-selection", "I",                &agent_universe,   5, 1 },
 172         { NULL, NULL, NULL, 0, 0 }
 173 };
 174
 175 struct universe server_universe;
 176 static struct option server_options[] = {
 177         { "default-lease-time", "T",            &server_universe,   1, 1 },
 178         { "max-lease-time", "T",                &server_universe,   2, 1 },
 179         { "min-lease-time", "T",                &server_universe,   3, 1 },
 180         { "dynamic-bootp-lease-cutoff", "T",    &server_universe,   4, 1 },
 181         { "dynamic-bootp-lease-length", "L",    &server_universe,   5, 1 },
 182         { "boot-unknown-clients", "f",          &server_universe,   6, 1 },
 183         { "dynamic-bootp", "f",                 &server_universe,   7, 1 },
 184         { "allow-bootp", "f",                   &server_universe,   8, 1 },
 185         { "allow-booting", "f",                 &server_universe,   9, 1 },
 186         { "one-lease-per-client", "f",          &server_universe,  10, 1 },
 187         { "get-lease-hostnames", "f",           &server_universe,  11, 1 },
 188         { "use-host-decl-names", "f",           &server_universe,  12, 1 },
 189         { "use-lease-addr-for-default-route", "f",
 190                                                 &server_universe,  13, 1 },
 191         { "min-secs", "B",                      &server_universe,  14, 1 },
 192         { "filename", "t",                      &server_universe,  15, 1 },
 193         { "server-name", "t",                   &server_universe,  16, 1 },
 194         { "next-server", "I",                   &server_universe,  17, 1 },
 195         { "authoritative", "f",                 &server_universe,  18, 1 },
 196         { "vendor-option-space", "U",           &server_universe,  19, 1 },
 197         { "always-reply-rfc1048", "f",          &server_universe,  20, 1 },
 198         { "site-option-space", "X",             &server_universe,  21, 1 },
 199         { "always-broadcast", "f",              &server_universe,  22, 1 },
 200         { "ddns-domainname", "t",               &server_universe,  23, 1 },
 201         { "ddns-hostname", "t",                 &server_universe,  24, 1 },
 202         { "ddns-rev-domainname", "t",           &server_universe,  25, 1 },
 203         { "lease-file-name", "t",               &server_universe,  26, 1 },
 204         { "pid-file-name", "t",                 &server_universe,  27, 1 },
 205         { "duplicates", "f",                    &server_universe,  28, 1 },
 206         { "declines", "f",                      &server_universe,  29, 1 },
 207         { "ddns-updates", "f",                  &server_universe,  30, 1 },
 208         { "omapi-port", "S",                    &server_universe,  31, 1 },
 209         { "local-port", "S",                    &server_universe,  32, 1 },
 210         { "limited-broadcast-address", "I",     &server_universe,  33, 1 },
 211         { "remote-port", "S",                   &server_universe,  34, 1 },
 212         { "local-address", "I",                 &server_universe,  35, 1 },
 213         { "omapi-key", "d",                     &server_universe,  36, 1 },
 214         { "stash-agent-options", "f",           &server_universe,  37, 1 },
 215         { "ddns-ttl", "T",                      &server_universe,  38, 1 },
 216         { "ddns-update-style", "Nddns-styles.", &server_universe,  39, 1 },
 217         { "client-updates", "f",                &server_universe,  40, 1 },
 218         { "update-optimization", "f",           &server_universe,  41, 1 },
 219         { "ping-check", "f",                    &server_universe,  42, 1 },
 220         { "update-static-leases", "f",          &server_universe,  43, 1 },
 221         { "log-facility", "Nsyslog-facilities.",
 222                                                 &server_universe,  44, 1 },
 223         { "do-forward-updates", "f",            &server_universe,  45, 1 },
 224         { "ping-timeout", "T",                  &server_universe,  46, 1 },
 225         { "infinite-is-reserved", "f",          &server_universe,  47, 1 },
 226         { "update-conflict-detection", "f",     &server_universe,  48, 1 },
 227         { "leasequery", "f",                    &server_universe,  49, 1 },
 228         { "adaptive-lease-time-threshold", "B", &server_universe,  50, 1 },
 229         { "do-reverse-updates", "f",            &server_universe,  51, 1 },
 230         { "fqdn-reply", "f",                    &server_universe,  52, 1 },
 231         { "preferred-lifetime", "T",            &server_universe,  53, 1 },
 232         { "dhcpv6-lease-file-name", "t",        &server_universe,  54, 1 },
 233         { "dhcpv6-pid-file-name", "t",          &server_universe,  55, 1 },
 234         { "limit-addrs-per-ia", "L",            &server_universe,  56, 1 },
 235         { "limit-prefs-per-ia", "L",            &server_universe,  57, 1 },
 236 /* Assert a configuration parsing error if delayed-ack isn't compiled in. */
 237 #if defined(DELAYED_ACK) && !defined(DHCP4o6)
 238         { "delayed-ack", "S",                   &server_universe,  58, 1 },
 239         { "max-ack-delay", "L",                 &server_universe,  59, 1 },
 240 #endif
 241 #if defined(LDAP_CONFIGURATION)
 242         { "ldap-server", "t",                   &server_universe,  60, 1 },
 243         { "ldap-port", "d",                     &server_universe,  61, 1 },
 244         { "ldap-username", "t",                 &server_universe,  62, 1 },
 245         { "ldap-password", "t",                 &server_universe,  63, 1 },
 246         { "ldap-base-dn", "t",                  &server_universe,  64, 1 },
 247         { "ldap-method", "Nldap-methods.",      &server_universe,  65, 1 },
 248         { "ldap-debug-file", "t",               &server_universe,  66, 1 },
 249         { "ldap-dhcp-server-cn", "t",           &server_universe,  67, 1 },
 250         { "ldap-referrals", "f",                &server_universe,  68, 1 },
 251 #if defined(LDAP_USE_SSL)
 252         { "ldap-ssl", "Nldap-ssl-usage.",       &server_universe,  69, 1 },
 253         { "ldap-tls-reqcert", "Nldap-tls-reqcert.",     &server_universe,  70, 1 },
 254         { "ldap-tls-ca-file", "t",              &server_universe,  71, 1 },
 255         { "ldap-tls-ca-dir", "t",               &server_universe,  72, 1 },
 256         { "ldap-tls-cert", "t",                 &server_universe,  73, 1 },
 257         { "ldap-tls-key", "t",                  &server_universe,  74, 1 },
 258         { "ldap-tls-crlcheck", "Nldap-tls-crlcheck.",   &server_universe,  75, 1 },
 259         { "ldap-tls-ciphers", "t",              &server_universe,  76, 1 },
 260         { "ldap-tls-randfile", "t",             &server_universe,  77, 1 },
 261         { "ldap-init-retry", "d",               &server_universe,  SV_LDAP_INIT_RETRY, 1 },
 262 #endif /* LDAP_USE_SSL */
 263 #if defined(LDAP_USE_GSSAPI)
 264         { "ldap-gssapi-keytab", "t",        &server_universe,  SV_LDAP_GSSAPI_KEYTAB, 1},
 265         { "ldap-gssapi-principal", "t",     &server_universe,  SV_LDAP_GSSAPI_PRINCIPAL, 1},
 266 #endif /* LDAP_USE_GSSAPI */
 267 #endif /* LDAP_CONFIGURATION */
 268         { "dhcp-cache-threshold", "B",          &server_universe,  78, 1 },
 269         { "dont-use-fsync", "f",                &server_universe,  79, 1 },
 270         { "ddns-local-address4", "I",           &server_universe,  80, 1 },
 271         { "ddns-local-address6", "6",           &server_universe,  81, 1 },
 272         { "ignore-client-uids", "f",            &server_universe,  82, 1 },
 273         { "log-threshold-low", "B",             &server_universe,  83, 1 },
 274         { "log-threshold-high", "B",            &server_universe,  84, 1 },
 275         { "echo-client-id", "f",                &server_universe,  SV_ECHO_CLIENT_ID, 1 },
 276         { "server-id-check", "f",               &server_universe,  SV_SERVER_ID_CHECK, 1 },
 277         { "prefix-length-mode", "Nprefix_length_modes.",        &server_universe,  SV_PREFIX_LEN_MODE, 1 },
 278         { "dhcpv6-set-tee-times", "f",          &server_universe,  SV_DHCPV6_SET_TEE_TIMES, 1 },
 279         { "abandon-lease-time", "T",            &server_universe,  SV_ABANDON_LEASE_TIME, 1 },
 280         { NULL, NULL, NULL, 0, 0 }
 281 };
 282
 283 #if defined(LDAP_CONFIGURATION)
 284 struct enumeration_value ldap_values [] = {
 285         { "static", LDAP_METHOD_STATIC },
 286         { "dynamic", LDAP_METHOD_DYNAMIC },
 287         { (char *) 0, 0 }
 288 };
 289
 290 struct enumeration ldap_methods = {
 291         (struct enumeration *)0,
 292         "ldap-methods", 1,
 293         ldap_values
 294 };
 295
 296 #if defined(LDAP_USE_SSL)
 297 struct enumeration_value ldap_ssl_usage_values [] = {
 298         { "off", LDAP_SSL_OFF },
 299         { "on",LDAP_SSL_ON },
 300         { "ldaps", LDAP_SSL_LDAPS },
 301         { "start_tls", LDAP_SSL_TLS },
 302         { (char *) 0, 0 }
 303 };
 304
 305 struct enumeration ldap_ssl_usage_enum = {
 306         (struct enumeration *)0,
 307         "ldap-ssl-usage", 1,
 308         ldap_ssl_usage_values
 309 };
 310
 311 struct enumeration_value ldap_tls_reqcert_values [] = {
 312         { "never", LDAP_OPT_X_TLS_NEVER },
 313         { "hard", LDAP_OPT_X_TLS_HARD  },
 314         { "demand", LDAP_OPT_X_TLS_DEMAND},
 315         { "allow", LDAP_OPT_X_TLS_ALLOW },
 316         { "try", LDAP_OPT_X_TLS_TRY   },
 317         { (char *) 0, 0 }
 318 };
 319 struct enumeration ldap_tls_reqcert_enum = {
 320         (struct enumeration *)0,
 321         "ldap-tls-reqcert", 1,
 322         ldap_tls_reqcert_values
 323 };
 324
 325 struct enumeration_value ldap_tls_crlcheck_values [] = {
 326         { "none", LDAP_OPT_X_TLS_CRL_NONE},
 327         { "peer", LDAP_OPT_X_TLS_CRL_PEER},
 328         { "all",  LDAP_OPT_X_TLS_CRL_ALL },
 329         { (char *) 0, 0 }
 330 };
 331 struct enumeration ldap_tls_crlcheck_enum = {
 332         (struct enumeration *)0,
 333         "ldap-tls-crlcheck", 1,
 334         ldap_tls_crlcheck_values
 335 };
 336 #endif
 337 #endif
 338
 339 struct enumeration_value ddns_styles_values [] = {
 340         { "none", 0 },
 341         { "ad-hoc", 1 },
 342         { "interim", 2 },
 343         { "standard", 3 },
 344         { (char *)0, 0 }
 345 };
 346
 347 struct enumeration ddns_styles = {
 348         (struct enumeration *)0,
 349         "ddns-styles", 1,
 350         ddns_styles_values
 351 };
 352
 353 struct enumeration_value prefix_length_modes_values[] = {
 354         { "ignore", PLM_IGNORE },
 355         { "prefer", PLM_PREFER },
 356         { "exact", PLM_EXACT },
 357         { "minimum", PLM_MINIMUM },
 358         { "maximum", PLM_MAXIMUM },
 359         { (char *)0, 0 }
 360 };
 361
 362 struct enumeration prefix_length_modes = {
 363         (struct enumeration *)0,
 364         "prefix_length_modes", 1,
 365         prefix_length_modes_values
 366 };
 367
 368 struct enumeration_value syslog_values [] = {
 369 #if defined (LOG_KERN)
 370         { "kern", LOG_KERN },
 371 #endif
 372 #if defined (LOG_USER)
 373         { "user", LOG_USER },
 374 #endif
 375 #if defined (LOG_MAIL)
 376         { "mail", LOG_MAIL },
 377 #endif
 378 #if defined (LOG_DAEMON)
 379         { "daemon", LOG_DAEMON },
 380 #endif
 381 #if defined (LOG_AUTH)
 382         { "auth", LOG_AUTH },
 383 #endif
 384 #if defined (LOG_SYSLOG)
 385         { "syslog", LOG_SYSLOG },
 386 #endif
 387 #if defined (LOG_LPR)
 388         { "lpr", LOG_LPR },
 389 #endif
 390 #if defined (LOG_NEWS)
 391         { "news", LOG_NEWS },
 392 #endif
 393 #if defined (LOG_UUCP)
 394         { "uucp", LOG_UUCP },
 395 #endif
 396 #if defined (LOG_CRON)
 397         { "cron", LOG_CRON },
 398 #endif
 399 #if defined (LOG_AUTHPRIV)
 400         { "authpriv", LOG_AUTHPRIV },
 401 #endif
 402 #if defined (LOG_FTP)
 403         { "ftp", LOG_FTP },
 404 #endif
 405 #if defined (LOG_LOCAL0)
 406         { "local0", LOG_LOCAL0 },
 407 #endif
 408 #if defined (LOG_LOCAL1)
 409         { "local1", LOG_LOCAL1 },
 410 #endif
 411 #if defined (LOG_LOCAL2)
 412         { "local2", LOG_LOCAL2 },
 413 #endif
 414 #if defined (LOG_LOCAL3)
 415         { "local3", LOG_LOCAL3 },
 416 #endif
 417 #if defined (LOG_LOCAL4)
 418         { "local4", LOG_LOCAL4 },
 419 #endif
 420 #if defined (LOG_LOCAL5)
 421         { "local5", LOG_LOCAL5 },
 422 #endif
 423 #if defined (LOG_LOCAL6)
 424         { "local6", LOG_LOCAL6 },
 425 #endif
 426 #if defined (LOG_LOCAL7)
 427         { "local7", LOG_LOCAL7 },
 428 #endif
 429         { (char *)0, 0 }
 430 };
 431
 432 struct enumeration syslog_enum = {
 433         (struct enumeration *)0,
 434         "syslog-facilities", 1,
 435         syslog_values
 436 };
 437
 438 void initialize_server_option_spaces()
 439 {
 440         int i;
 441         unsigned code;
 442
 443         /* Set up the Relay Agent Information Option suboption space... */
 444         agent_universe.name = "agent";
 445         agent_universe.concat_duplicates = 0;
 446         agent_universe.option_state_dereference =
 447                 linked_option_state_dereference;
 448         agent_universe.lookup_func = lookup_linked_option;
 449         agent_universe.save_func = save_linked_option;
 450         agent_universe.delete_func = delete_linked_option;
 451         agent_universe.encapsulate = linked_option_space_encapsulate;
 452         agent_universe.foreach = linked_option_space_foreach;
 453         agent_universe.decode = parse_option_buffer;
 454         agent_universe.index = universe_count++;
 455         agent_universe.length_size = 1;
 456         agent_universe.tag_size = 1;
 457         agent_universe.get_tag = getUChar;
 458         agent_universe.store_tag = putUChar;
 459         agent_universe.get_length = getUChar;
 460         agent_universe.store_length = putUChar;
 461         agent_universe.site_code_min = 0;
 462         agent_universe.end = 0;
 463         universes [agent_universe.index] = &agent_universe;
 464         if (!option_name_new_hash(&agent_universe.name_hash,
 465                                   AGENT_HASH_SIZE, MDL) ||
 466             !option_code_new_hash(&agent_universe.code_hash,
 467                                   AGENT_HASH_SIZE, MDL))
 468                 log_fatal ("Can't allocate agent option hash table.");
 469         for (i = 0 ; agent_options[i].name ; i++) {
 470                 option_code_hash_add(agent_universe.code_hash,
 471                                      &agent_options[i].code, 0,
 472                                      &agent_options[i], MDL);
 473                 option_name_hash_add(agent_universe.name_hash,
 474                                      agent_options[i].name, 0,
 475                                      &agent_options[i], MDL);
 476         }
 477 #if defined(REPORT_HASH_PERFORMANCE)
 478         log_info("Relay Agent name hash: %s",
 479                  option_name_hash_report(agent_universe.name_hash));
 480         log_info("Relay Agent code hash: %s",
 481                  option_code_hash_report(agent_universe.code_hash));
 482 #endif
 483         code = DHO_DHCP_AGENT_OPTIONS;
 484         option_code_hash_lookup(&agent_universe.enc_opt,
 485                                 dhcp_universe.code_hash, &code, 0, MDL);
 486
 487         /* Set up the server option universe... */
 488         server_universe.name = "server";
 489         server_universe.concat_duplicates = 0;
 490         server_universe.lookup_func = lookup_hashed_option;
 491         server_universe.option_state_dereference =
 492                 hashed_option_state_dereference;
 493         server_universe.save_func = save_hashed_option;
 494         server_universe.delete_func = delete_hashed_option;
 495         server_universe.encapsulate = hashed_option_space_encapsulate;
 496         server_universe.foreach = hashed_option_space_foreach;
 497         server_universe.length_size = 1; /* Never used ... */
 498         server_universe.tag_size = 4;
 499         server_universe.store_tag = putUChar;
 500         server_universe.store_length = putUChar;
 501         server_universe.site_code_min = 0;
 502         server_universe.end = 0;
 503         server_universe.index = universe_count++;
 504         universes [server_universe.index] = &server_universe;
 505         if (!option_name_new_hash(&server_universe.name_hash,
 506                                   SERVER_HASH_SIZE, MDL) ||
 507             !option_code_new_hash(&server_universe.code_hash,
 508                                   SERVER_HASH_SIZE, MDL))
 509                 log_fatal ("Can't allocate server option hash table.");
 510         for (i = 0 ; server_options[i].name ; i++) {
 511                 option_code_hash_add(server_universe.code_hash,
 512                                      &server_options[i].code, 0,
 513                                      &server_options[i], MDL);
 514                 option_name_hash_add(server_universe.name_hash,
 515                                      server_options[i].name, 0,
 516                                      &server_options[i], MDL);
 517         }
 518 #if defined(REPORT_HASH_PERFORMANCE)
 519         log_info("Server-Config Option name hash: %s",
 520                  option_name_hash_report(server_universe.name_hash));
 521         log_info("Server-Config Option code hash: %s",
 522                  option_code_hash_report(server_universe.code_hash));
 523 #endif
 524
 525         /* Add the server and agent option spaces to the option space hash. */
 526         universe_hash_add (universe_hash,
 527                            agent_universe.name, 0, &agent_universe, MDL);
 528         universe_hash_add (universe_hash,
 529                            server_universe.name, 0, &server_universe, MDL);
 530
 531         /* Make the server universe the configuration option universe. */
 532         config_universe = &server_universe;
 533
 534         code = SV_VENDOR_OPTION_SPACE;
 535         option_code_hash_lookup(&vendor_cfg_option, server_universe.code_hash,
 536                                 &code, 0, MDL);
 537 }