/* tables of names for values defined in constants.h * Copyright (C) 1998-2002 D. Hugh Redelmeier. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. See . * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * for more details. * * RCSID $Id$ */ /* * Note that the array sizes are all specified; this is to enable range * checking by code that only includes constants.h. */ #include #include #include #include #include #include #include "constants.h" #include "defs.h" #include "log.h" #include "packet.h" /* string naming compile-time options that have interop implications */ const char compile_time_interop_options[] = "" #ifdef THREADS " THREADS" #endif #ifdef LIBCURL " LIBCURL" #endif #ifdef LIBLDAP " LIBLDAP" #endif #ifdef SMARTCARD " SMARTCARD" #endif #ifdef VENDORID " VENDORID" #endif #ifdef CISCO_QUIRKS " CISCO_QUIRKS" #endif #ifdef USE_KEYRR " KEYRR" #endif ; /* version */ static const char *const version_name[] = { "ISAKMP Version 1.0", }; enum_names version_names = { ISAKMP_MAJOR_VERSION< if not officially defined */ static const char *const esp_transform_name_high[] = { "ESP_SERPENT", "ESP_TWOFISH" }; enum_names esp_transformid_names_high = { ESP_SERPENT, ESP_TWOFISH, esp_transform_name_high, NULL }; enum_names esp_transformid_names = { ESP_DES_IV64, ESP_CAMELLIA, esp_transform_name, &esp_transformid_names_high }; /* IPCOMP transform values */ static const char *const ipcomp_transform_name[] = { "IPCOMP_OUI", "IPCOMP_DEFLAT", "IPCOMP_LZS", "IPCOMP_LZJH", }; enum_names ipcomp_transformid_names = { IPCOMP_OUI, IPCOMP_LZJH, ipcomp_transform_name, NULL }; /* Identification type values */ static const char *const ident_name[] = { "ID_IPV4_ADDR", "ID_FQDN", "ID_USER_FQDN", "ID_IPV4_ADDR_SUBNET", "ID_IPV6_ADDR", "ID_IPV6_ADDR_SUBNET", "ID_IPV4_ADDR_RANGE", "ID_IPV6_ADDR_RANGE", "ID_DER_ASN1_DN", "ID_DER_ASN1_GN", "ID_KEY_ID", }; enum_names ident_names = { ID_IPV4_ADDR, ID_KEY_ID, ident_name, NULL }; /* Certificate type values */ static const char *const cert_type_name[] = { "CERT_NONE", "CERT_PKCS7_WRAPPED_X509", "CERT_PGP", "CERT_DNS_SIGNED_KEY", "CERT_X509_SIGNATURE", "CERT_X509_KEY_EXCHANGE", "CERT_KERBEROS_TOKENS", "CERT_CRL", "CERT_ARL", "CERT_SPKI", "CERT_X509_ATTRIBUTE", }; enum_names cert_type_names = { CERT_NONE, CERT_X509_ATTRIBUTE, cert_type_name, NULL }; /* Certificate policy names */ static const char *const cert_policy_name[] = { "ALWAYS_SEND", "SEND_IF_ASKED", "NEVER_SEND", }; enum_names cert_policy_names = { CERT_ALWAYS_SEND, CERT_NEVER_SEND, cert_policy_name, NULL }; /* Goal BITs for establishing an SA * Note: we drop the POLICY_ prefix so that logs are more concise. */ const char *const sa_policy_bit_names[] = { "PSK", "RSASIG", "ENCRYPT", "AUTHENTICATE", "COMPRESS", "TUNNEL", "PFS", "DISABLEARRIVALCHECK", "SHUNT0", "SHUNT1", "FAILSHUNT0", "FAILSHUNT1", "DONTREKEY", "OPPORTUNISTIC", "GROUP", "GROUTED", "UP", "MODECFGPUSH", "XAUTHPSK", "XAUTHRSASIG", "XAUTHSERVER", "DONTREAUTH", "BEET", "MOBIKE", "ECDSA", "PROXY", NULL }; const char *const policy_shunt_names[4] = { "TRAP", "PASS", "DROP", "REJECT", }; const char *const policy_fail_names[4] = { "NONE", "PASS", "DROP", "REJECT", }; /* Oakley transform attributes * oakley_attr_bit_names does double duty: it is used for enum names * and bit names. */ const char *const oakley_attr_bit_names[] = { "OAKLEY_ENCRYPTION_ALGORITHM", "OAKLEY_HASH_ALGORITHM", "OAKLEY_AUTHENTICATION_METHOD", "OAKLEY_GROUP_DESCRIPTION", "OAKLEY_GROUP_TYPE", "OAKLEY_GROUP_PRIME", "OAKLEY_GROUP_GENERATOR_ONE", "OAKLEY_GROUP_GENERATOR_TWO", "OAKLEY_GROUP_CURVE_A", "OAKLEY_GROUP_CURVE_B", "OAKLEY_LIFE_TYPE", "OAKLEY_LIFE_DURATION", "OAKLEY_PRF", "OAKLEY_KEY_LENGTH", "OAKLEY_FIELD_SIZE", "OAKLEY_GROUP_ORDER", "OAKLEY_BLOCK_SIZE", NULL }; static const char *const oakley_var_attr_name[] = { "OAKLEY_GROUP_PRIME (variable length)", "OAKLEY_GROUP_GENERATOR_ONE (variable length)", "OAKLEY_GROUP_GENERATOR_TWO (variable length)", "OAKLEY_GROUP_CURVE_A (variable length)", "OAKLEY_GROUP_CURVE_B (variable length)", NULL, "OAKLEY_LIFE_DURATION (variable length)", NULL, NULL, NULL, "OAKLEY_GROUP_ORDER (variable length)", }; static enum_names oakley_attr_desc_tv = { OAKLEY_ENCRYPTION_ALGORITHM + ISAKMP_ATTR_AF_TV, OAKLEY_GROUP_ORDER + ISAKMP_ATTR_AF_TV, oakley_attr_bit_names, NULL }; enum_names oakley_attr_names = { OAKLEY_GROUP_PRIME, OAKLEY_GROUP_ORDER, oakley_var_attr_name, &oakley_attr_desc_tv }; /* for each Oakley attribute, which enum_names describes its values? */ enum_names *oakley_attr_val_descs[] = { NULL, /* (none) */ &oakley_enc_names, /* OAKLEY_ENCRYPTION_ALGORITHM */ &oakley_hash_names, /* OAKLEY_HASH_ALGORITHM */ &oakley_auth_names, /* OAKLEY_AUTHENTICATION_METHOD */ &oakley_group_names, /* OAKLEY_GROUP_DESCRIPTION */ &oakley_group_type_names,/* OAKLEY_GROUP_TYPE */ NULL, /* OAKLEY_GROUP_PRIME */ NULL, /* OAKLEY_GROUP_GENERATOR_ONE */ NULL, /* OAKLEY_GROUP_GENERATOR_TWO */ NULL, /* OAKLEY_GROUP_CURVE_A */ NULL, /* OAKLEY_GROUP_CURVE_B */ &oakley_lifetime_names, /* OAKLEY_LIFE_TYPE */ NULL, /* OAKLEY_LIFE_DURATION */ &oakley_prf_names, /* OAKLEY_PRF */ NULL, /* OAKLEY_KEY_LENGTH */ NULL, /* OAKLEY_FIELD_SIZE */ NULL, /* OAKLEY_GROUP_ORDER */ }; /* IPsec DOI attributes (RFC 2407 "IPsec DOI" section 4.5) */ static const char *const ipsec_attr_name[] = { "SA_LIFE_TYPE", "SA_LIFE_DURATION", "GROUP_DESCRIPTION", "ENCAPSULATION_MODE", "AUTH_ALGORITHM", "KEY_LENGTH", "KEY_ROUNDS", "COMPRESS_DICT_SIZE", "COMPRESS_PRIVATE_ALG", }; static const char *const ipsec_var_attr_name[] = { "SA_LIFE_DURATION (variable length)", NULL, NULL, NULL, NULL, NULL, NULL, "COMPRESS_PRIVATE_ALG (variable length)", }; static enum_names ipsec_attr_desc_tv = { SA_LIFE_TYPE + ISAKMP_ATTR_AF_TV, COMPRESS_PRIVATE_ALG + ISAKMP_ATTR_AF_TV, ipsec_attr_name, NULL }; enum_names ipsec_attr_names = { SA_LIFE_DURATION, COMPRESS_PRIVATE_ALG, ipsec_var_attr_name, &ipsec_attr_desc_tv }; /* for each IPsec attribute, which enum_names describes its values? */ enum_names *ipsec_attr_val_descs[] = { NULL, /* (none) */ &sa_lifetime_names, /* SA_LIFE_TYPE */ NULL, /* SA_LIFE_DURATION */ &oakley_group_names, /* GROUP_DESCRIPTION */ &enc_mode_names, /* ENCAPSULATION_MODE */ &auth_alg_names, /* AUTH_ALGORITHM */ NULL, /* KEY_LENGTH */ NULL, /* KEY_ROUNDS */ NULL, /* COMPRESS_DICT_SIZE */ NULL, /* COMPRESS_PRIVATE_ALG */ }; /* SA Lifetime Type attribute */ static const char *const sa_lifetime_name[] = { "SA_LIFE_TYPE_SECONDS", "SA_LIFE_TYPE_KBYTES", }; enum_names sa_lifetime_names = { SA_LIFE_TYPE_SECONDS, SA_LIFE_TYPE_KBYTES, sa_lifetime_name, NULL }; /* Encapsulation Mode attribute */ static const char *const enc_mode_name[] = { "ENCAPSULATION_MODE_TUNNEL", "ENCAPSULATION_MODE_TRANSPORT", "ENCAPSULATION_MODE_UDP_TUNNEL", "ENCAPSULATION_MODE_UDP_TRANSPORT", }; static const char *const enc_udp_mode_name[] = { "ENCAPSULATION_MODE_UDP_TUNNEL", "ENCAPSULATION_MODE_UDP_TRANSPORT", }; static enum_names enc_udp_mode_names = { ENCAPSULATION_MODE_UDP_TUNNEL_DRAFTS, ENCAPSULATION_MODE_UDP_TRANSPORT_DRAFTS, enc_udp_mode_name, NULL }; enum_names enc_mode_names = { ENCAPSULATION_MODE_TUNNEL, ENCAPSULATION_MODE_UDP_TRANSPORT_RFC, enc_mode_name, &enc_udp_mode_names }; /* Auth Algorithm attribute */ static const char *const auth_alg_name[] = { "AUTH_ALGORITHM_HMAC_MD5", "AUTH_ALGORITHM_HMAC_SHA1", "AUTH_ALGORITHM_DES_MAC", "AUTH_ALGORITHM_KPDK", "AUTH_ALGORITHM_HMAC_SHA2_256", "AUTH_ALGORITHM_HMAC_SHA2_384", "AUTH_ALGORITHM_HMAC_SHA2_512", "AUTH_ALGORITHM_HMAC_RIPEMD", "AUTH_ALGORITHM_AES_XCBC_MAC", "AUTH_ALGORITHM_SIG_RSA" }; static const char *const extended_auth_alg_name[] = { "AUTH_ALGORITHM_NULL" }; enum_names extended_auth_alg_names = { AUTH_ALGORITHM_NULL, AUTH_ALGORITHM_NULL, extended_auth_alg_name, NULL }; enum_names auth_alg_names = { AUTH_ALGORITHM_HMAC_MD5, AUTH_ALGORITHM_SIG_RSA, auth_alg_name , &extended_auth_alg_names }; /* From draft-beaulieu-ike-xauth */ static const char *const xauth_type_name[] = { "Generic", "RADIUS-CHAP", "OTP", "S/KEY", }; enum_names xauth_type_names = { XAUTH_TYPE_GENERIC, XAUTH_TYPE_SKEY, xauth_type_name, NULL}; /* From draft-beaulieu-ike-xauth */ static const char *const xauth_attr_tv_name[] = { "XAUTH_TYPE", NULL, NULL, NULL, NULL, NULL, NULL, "XAUTH_STATUS", }; enum_names xauth_attr_tv_names = { XAUTH_TYPE + ISAKMP_ATTR_AF_TV, XAUTH_STATUS + ISAKMP_ATTR_AF_TV, xauth_attr_tv_name, NULL }; static const char *const unity_attr_name[] = { "UNITY_BANNER", "UNITY_SAVE_PASSWD", "UNITY_DEF_DOMAIN", "UNITY_SPLITDNS_NAME", "UNITY_SPLIT_INCLUDE", "UNITY_NATT_PORT", "UNITY_LOCAL_LAN", "UNITY_PFS", "UNITY_FW_TYPE", "UNITY_BACKUP_SERVERS", "UNITY_DDNS_HOSTNAME", }; enum_names unity_attr_names = { UNITY_BANNER , UNITY_DDNS_HOSTNAME, unity_attr_name , &xauth_attr_tv_names }; static const char *const xauth_attr_name[] = { "XAUTH_USER_NAME", "XAUTH_USER_PASSWORD", "XAUTH_PASSCODE", "XAUTH_MESSAGE", "XAUTH_CHALLENGE", "XAUTH_DOMAIN", "XAUTH_STATUS (wrong TLV syntax, should be TV)", "XAUTH_NEXT_PIN", "XAUTH_ANSWER", }; enum_names xauth_attr_names = { XAUTH_USER_NAME , XAUTH_ANSWER, xauth_attr_name , &unity_attr_names }; static const char *const modecfg_attr_name[] = { "INTERNAL_IP4_ADDRESS", "INTERNAL_IP4_NETMASK", "INTERNAL_IP4_DNS", "INTERNAL_IP4_NBNS", "INTERNAL_ADDRESS_EXPIRY", "INTERNAL_IP4_DHCP", "APPLICATION_VERSION", "INTERNAL_IP6_ADDRESS", "INTERNAL_IP6_NETMASK", "INTERNAL_IP6_DNS", "INTERNAL_IP6_NBNS", "INTERNAL_IP6_DHCP", "INTERNAL_IP4_SUBNET", "SUPPORTED_ATTRIBUTES", "INTERNAL_IP6_SUBNET", }; enum_names modecfg_attr_names = { INTERNAL_IP4_ADDRESS, INTERNAL_IP6_SUBNET, modecfg_attr_name , &xauth_attr_names }; /* Oakley Lifetime Type attribute */ static const char *const oakley_lifetime_name[] = { "OAKLEY_LIFE_SECONDS", "OAKLEY_LIFE_KILOBYTES", }; enum_names oakley_lifetime_names = { OAKLEY_LIFE_SECONDS, OAKLEY_LIFE_KILOBYTES, oakley_lifetime_name, NULL }; /* Oakley PRF attribute (none defined) */ enum_names oakley_prf_names = { 1, 0, NULL, NULL }; /* Oakley Encryption Algorithm attribute */ static const char *const oakley_enc_name[] = { "OAKLEY_DES_CBC", "OAKLEY_IDEA_CBC", "OAKLEY_BLOWFISH_CBC", "OAKLEY_RC5_R16_B64_CBC", "OAKLEY_3DES_CBC", "OAKLEY_CAST_CBC", "OAKLEY_AES_CBC", }; #ifdef NO_EXTRA_IKE enum_names oakley_enc_names = { OAKLEY_DES_CBC, OAKLEY_AES_CBC, oakley_enc_name, NULL }; #else static const char *const oakley_enc_name_draft_aes_cbc_02[] = { "OAKLEY_MARS_CBC" /* 65001 */, "OAKLEY_RC6_CBC" /* 65002 */, "OAKLEY_ID_65003" /* 65003 */, "OAKLEY_SERPENT_CBC" /* 65004 */, "OAKLEY_TWOFISH_CBC" /* 65005 */, }; static const char *const oakley_enc_name_ssh[] = { "OAKLEY_TWOFISH_CBC_SSH", }; enum_names oakley_enc_names_ssh = { OAKLEY_TWOFISH_CBC_SSH, OAKLEY_TWOFISH_CBC_SSH, oakley_enc_name_ssh , NULL }; enum_names oakley_enc_names_draft_aes_cbc_02 = { OAKLEY_MARS_CBC, OAKLEY_TWOFISH_CBC, oakley_enc_name_draft_aes_cbc_02 , &oakley_enc_names_ssh }; enum_names oakley_enc_names = { OAKLEY_DES_CBC, OAKLEY_AES_CBC, oakley_enc_name , &oakley_enc_names_draft_aes_cbc_02 }; #endif /* Oakley Hash Algorithm attribute */ static const char *const oakley_hash_name[] = { "OAKLEY_MD5", "OAKLEY_SHA", "OAKLEY_TIGER", "OAKLEY_SHA2_256", "OAKLEY_SHA2_384", "OAKLEY_SHA2_512", }; enum_names oakley_hash_names = { OAKLEY_MD5, OAKLEY_SHA2_512, oakley_hash_name, NULL }; /* Oakley Authentication Method attribute */ static const char *const oakley_auth_name1[] = { "OAKLEY_PRESHARED_KEY", "OAKLEY_DSS_SIG", "OAKLEY_RSA_SIG", "OAKLEY_RSA_ENC", "OAKLEY_RSA_ENC_REV", "OAKLEY_ELGAMAL_ENC", "OAKLEY_ELGAMAL_ENC_REV", }; static const char *const oakley_auth_name2[] = { "HybridInitRSA", "HybridRespRSA", "HybridInitDSS", "HybridRespDSS", }; static const char *const oakley_auth_name3[] = { "XAUTHInitPreShared", "XAUTHRespPreShared", "XAUTHInitDSS", "XAUTHRespDSS", "XAUTHInitRSA", "XAUTHRespRSA", "XAUTHInitRSAEncryption", "XAUTHRespRSAEncryption", "XAUTHInitRSARevisedEncryption", "XAUTHRespRSARevisedEncryption", }; static enum_names oakley_auth_names1 = { OAKLEY_PRESHARED_KEY, OAKLEY_ELGAMAL_ENC_REV , oakley_auth_name1, NULL }; static enum_names oakley_auth_names2 = { HybridInitRSA, HybridRespDSS , oakley_auth_name2, &oakley_auth_names1 }; enum_names oakley_auth_names = { XAUTHInitPreShared, XAUTHRespRSARevisedEncryption , oakley_auth_name3, &oakley_auth_names2 }; /* Oakley Group Description attribute */ static const char *const oakley_group_name[] = { "OAKLEY_GROUP_MODP768", "OAKLEY_GROUP_MODP1024", "OAKLEY_GROUP_GP155", "OAKLEY_GROUP_GP185", "OAKLEY_GROUP_MODP1536", }; static const char *const oakley_group_name_rfc3526[] = { "OAKLEY_GROUP_MODP2048", "OAKLEY_GROUP_MODP3072", "OAKLEY_GROUP_MODP4096", "OAKLEY_GROUP_MODP6144", "OAKLEY_GROUP_MODP8192" }; enum_names oakley_group_names_rfc3526 = { OAKLEY_GROUP_MODP2048, OAKLEY_GROUP_MODP8192, oakley_group_name_rfc3526, NULL }; enum_names oakley_group_names = { OAKLEY_GROUP_MODP768, OAKLEY_GROUP_MODP1536, oakley_group_name, &oakley_group_names_rfc3526 }; /* Oakley Group Type attribute */ static const char *const oakley_group_type_name[] = { "OAKLEY_GROUP_TYPE_MODP", "OAKLEY_GROUP_TYPE_ECP", "OAKLEY_GROUP_TYPE_EC2N", }; enum_names oakley_group_type_names = { OAKLEY_GROUP_TYPE_MODP, OAKLEY_GROUP_TYPE_EC2N, oakley_group_type_name, NULL }; /* Notify messages -- error types */ static const char *const notification_name[] = { "INVALID_PAYLOAD_TYPE", "DOI_NOT_SUPPORTED", "SITUATION_NOT_SUPPORTED", "INVALID_COOKIE", "INVALID_MAJOR_VERSION", "INVALID_MINOR_VERSION", "INVALID_EXCHANGE_TYPE", "INVALID_FLAGS", "INVALID_MESSAGE_ID", "INVALID_PROTOCOL_ID", "INVALID_SPI", "INVALID_TRANSFORM_ID", "ATTRIBUTES_NOT_SUPPORTED", "NO_PROPOSAL_CHOSEN", "BAD_PROPOSAL_SYNTAX", "PAYLOAD_MALFORMED", "INVALID_KEY_INFORMATION", "INVALID_ID_INFORMATION", "INVALID_CERT_ENCODING", "INVALID_CERTIFICATE", "CERT_TYPE_UNSUPPORTED", "INVALID_CERT_AUTHORITY", "INVALID_HASH_INFORMATION", "AUTHENTICATION_FAILED", "INVALID_SIGNATURE", "ADDRESS_NOTIFICATION", "NOTIFY_SA_LIFETIME", "CERTIFICATE_UNAVAILABLE", "UNSUPPORTED_EXCHANGE_TYPE", "UNEQUAL_PAYLOAD_LENGTHS", }; static const char *const notification_status_name[] = { "CONNECTED", }; static const char *const ipsec_notification_name[] = { "IPSEC_RESPONDER_LIFETIME", "IPSEC_REPLAY_STATUS", "IPSEC_INITIAL_CONTACT", }; static const char *const notification_dpd_name[] = { "R_U_THERE", "R_U_THERE_ACK", }; enum_names notification_dpd_names = { R_U_THERE, R_U_THERE_ACK, notification_dpd_name, NULL }; enum_names ipsec_notification_names = { IPSEC_RESPONDER_LIFETIME, IPSEC_INITIAL_CONTACT, ipsec_notification_name, ¬ification_dpd_names }; enum_names notification_status_names = { CONNECTED, CONNECTED, notification_status_name, &ipsec_notification_names }; enum_names notification_names = { INVALID_PAYLOAD_TYPE, UNEQUAL_PAYLOAD_LENGTHS, notification_name, ¬ification_status_names }; /* MODECFG * From draft-dukes-ike-mode-cfg */ const char *const attr_msg_type_name[] = { "ISAKMP_CFG_RESERVED", "ISAKMP_CFG_REQUEST", "ISAKMP_CFG_REPLY", "ISAKMP_CFG_SET", "ISAKMP_CFG_ACK", NULL }; enum_names attr_msg_type_names = { 0 , ISAKMP_CFG_ACK, attr_msg_type_name , NULL }; /* socket address family info */ static const char *const af_inet_name[] = { "AF_INET", }; static const char *const af_inet6_name[] = { "AF_INET6", }; static enum_names af_names6 = { AF_INET6, AF_INET6, af_inet6_name, NULL }; enum_names af_names = { AF_INET, AF_INET, af_inet_name, &af_names6 }; static ip_address ipv4_any, ipv6_any; static ip_subnet ipv4_wildcard, ipv6_wildcard; static ip_subnet ipv4_all, ipv6_all; const struct af_info af_inet4_info = { AF_INET, "AF_INET", sizeof(struct in_addr), sizeof(struct sockaddr_in), 32, ID_IPV4_ADDR, ID_IPV4_ADDR_SUBNET, ID_IPV4_ADDR_RANGE, &ipv4_any, &ipv4_wildcard, &ipv4_all, }; const struct af_info af_inet6_info = { AF_INET6, "AF_INET6", sizeof(struct in6_addr), sizeof(struct sockaddr_in6), 128, ID_IPV6_ADDR, ID_IPV6_ADDR_SUBNET, ID_IPV6_ADDR_RANGE, &ipv6_any, &ipv6_wildcard, &ipv6_all, }; const struct af_info * aftoinfo(int af) { switch (af) { case AF_INET: return &af_inet4_info; case AF_INET6: return &af_inet6_info; default: return NULL; } } bool subnetisnone(const ip_subnet *sn) { ip_address base; networkof(sn, &base); return isanyaddr(&base) && subnetishost(sn); } /* BIND enumerated types */ #include static const char *const rr_type_name[] = { "T_A", /* 1 host address */ "T_NS", /* 2 authoritative server */ "T_MD", /* 3 mail destination */ "T_MF", /* 4 mail forwarder */ "T_CNAME", /* 5 canonical name */ "T_SOA", /* 6 start of authority zone */ "T_MB", /* 7 mailbox domain name */ "T_MG", /* 8 mail group member */ "T_MR", /* 9 mail rename name */ "T_NULL", /* 10 null resource record */ "T_WKS", /* 11 well known service */ "T_PTR", /* 12 domain name pointer */ "T_HINFO", /* 13 host information */ "T_MINFO", /* 14 mailbox information */ "T_MX", /* 15 mail routing information */ "T_TXT", /* 16 text strings */ "T_RP", /* 17 responsible person */ "T_AFSDB", /* 18 AFS cell database */ "T_X25", /* 19 X_25 calling address */ "T_ISDN", /* 20 ISDN calling address */ "T_RT", /* 21 router */ "T_NSAP", /* 22 NSAP address */ "T_NSAP_PTR", /* 23 reverse NSAP lookup (deprecated) */ "T_SIG", /* 24 security signature */ "T_KEY", /* 25 security key */ "T_PX", /* 26 X.400 mail mapping */ "T_GPOS", /* 27 geographical position (withdrawn) */ "T_AAAA", /* 28 IP6 Address */ "T_LOC", /* 29 Location Information */ "T_NXT", /* 30 Next Valid Name in Zone */ "T_EID", /* 31 Endpoint identifier */ "T_NIMLOC", /* 32 Nimrod locator */ "T_SRV", /* 33 Server selection */ "T_ATMA", /* 34 ATM Address */ "T_NAPTR", /* 35 Naming Authority PoinTeR */ NULL }; enum_names rr_type_names = { T_A, T_NAPTR, rr_type_name, NULL }; /* Query type values which do not appear in resource records */ static const char *const rr_qtype_name[] = { "T_IXFR", /* 251 incremental zone transfer */ "T_AXFR", /* 252 transfer zone of authority */ "T_MAILB", /* 253 transfer mailbox records */ "T_MAILA", /* 254 transfer mail agent records */ "T_ANY", /* 255 wildcard match */ NULL }; enum_names rr_qtype_names = { T_IXFR, T_ANY, rr_qtype_name, &rr_type_names }; static const char *const rr_class_name[] = { "C_IN", /* 1 the arpa internet */ NULL }; enum_names rr_class_names = { C_IN, C_IN, rr_class_name, NULL }; /* * NAT-Traversal defines for nat_traveral type from nat_traversal.h * */ const char *const natt_type_bitnames[] = { "draft-ietf-ipsec-nat-t-ike-00/01", /* 0 */ "draft-ietf-ipsec-nat-t-ike-02/03", "RFC 3947", "3", /* 3 */ "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "nat is behind me", "nat is behind peer" }; /* look up enum names in an enum_names */ const char * enum_name(enum_names *ed, unsigned long val) { enum_names *p; for (p = ed; p != NULL; p = p->en_next_range) { if (p->en_first <= val && val <= p->en_last) return p->en_names[val - p->en_first]; } return NULL; } /* find or construct a string to describe an enum value * Result may be in STATIC buffer! */ const char * enum_show(enum_names *ed, unsigned long val) { const char *p = enum_name(ed, val); if (p == NULL) { static char buf[12]; /* only one! I hope that it is big enough */ snprintf(buf, sizeof(buf), "%lu??", val); p = buf; } return p; } static char bitnamesbuf[200]; /* only one! I hope that it is big enough! */ int enum_search(enum_names *ed, const char *str) { enum_names *p; const char *ptr; unsigned en; for (p = ed; p != NULL; p = p->en_next_range) for (en = p->en_first; en <= p->en_last ;en++) { ptr = p->en_names[en - p->en_first]; if (ptr == 0) continue; /* if (strncmp(ptr, str, strlen(ptr))==0) */ if (strcmp(ptr, str) == 0) return en; } return -1; } /* construct a string to name the bits on in a set * Result may be in STATIC buffer! * Note: prettypolicy depends on internal details. */ const char * bitnamesof(const char *const table[], lset_t val) { char *p = bitnamesbuf; lset_t bit; const char *const *tp; if (val == 0) return "none"; for (tp = table, bit = 01; val != 0; bit <<= 1) { if (val & bit) { const char *n = *tp; size_t nl; if (n == NULL || *n == '\0') { /* no name for this bit, so use hex */ static char flagbuf[sizeof("0x80000000")]; snprintf(flagbuf, sizeof(flagbuf), "0x%llx", bit); n = flagbuf; } nl = strlen(n); if (p != bitnamesbuf && p < bitnamesbuf+sizeof(bitnamesbuf) - 1) *p++ = '+'; if (bitnamesbuf+sizeof(bitnamesbuf) - p > (ptrdiff_t)nl) { strcpy(p, n); p += nl; } val -= bit; } if (*tp != NULL) tp++; /* move on, but not past end */ } *p = '\0'; return bitnamesbuf; } /* print a policy: like bitnamesof, but it also does the non-bitfields. * Suppress the shunt and fail fields if 0. */ const char * prettypolicy(lset_t policy) { const char *bn = bitnamesof(sa_policy_bit_names , policy & ~(POLICY_SHUNT_MASK | POLICY_FAIL_MASK)); size_t len; lset_t shunt = (policy & POLICY_SHUNT_MASK) >> POLICY_SHUNT_SHIFT; lset_t fail = (policy & POLICY_FAIL_MASK) >> POLICY_FAIL_SHIFT; if (bn != bitnamesbuf) bitnamesbuf[0] = '\0'; len = strlen(bitnamesbuf); if (shunt != 0) { snprintf(bitnamesbuf + len, sizeof(bitnamesbuf) - len, "+%s" , policy_shunt_names[shunt]); len += strlen(bitnamesbuf + len); } if (fail != 0) { snprintf(bitnamesbuf + len, sizeof(bitnamesbuf) - len, "+failure%s" , policy_fail_names[fail]); len += strlen(bitnamesbuf + len); } if (NEVER_NEGOTIATE(policy)) { snprintf(bitnamesbuf + len, sizeof(bitnamesbuf) - len, "+NEVER_NEGOTIATE"); len += strlen(bitnamesbuf + len); } return bitnamesbuf; } /* test a set by seeing if all bits have names */ bool testset(const char *const table[], lset_t val) { lset_t bit; const char *const *tp; for (tp = table, bit = 01; val != 0; bit <<= 1, tp++) { const char *n = *tp; if (n == NULL || ((val & bit) && *n == '\0')) return FALSE; val &= ~bit; } return TRUE; } const char sparse_end[] = "end of sparse names"; /* look up enum names in a sparse_names */ const char *sparse_name(sparse_names sd, unsigned long val) { const struct sparse_name *p; for (p = sd; p->name != sparse_end; p++) if (p->val == val) return p->name; return NULL; } /* find or construct a string to describe an sparse value * Result may be in STATIC buffer! */ const char * sparse_val_show(sparse_names sd, unsigned long val) { const char *p = sparse_name(sd, val); if (p == NULL) { static char buf[12]; /* only one! I hope that it is big enough */ snprintf(buf, sizeof(buf), "%lu??", val); p = buf; } return p; } void init_constants(void) { happy(anyaddr(AF_INET, &ipv4_any)); happy(anyaddr(AF_INET6, &ipv6_any)); happy(addrtosubnet(&ipv4_any, &ipv4_wildcard)); happy(addrtosubnet(&ipv6_any, &ipv6_wildcard)); happy(initsubnet(&ipv4_any, 0, '0', &ipv4_all)); happy(initsubnet(&ipv6_any, 0, '0', &ipv6_all)); }