/* tables of names for values defined in constants.h * Copyright (C) 1998-2002 D. Hugh Redelmeier. * Copyright (C) 2009 Andreas Steffen - Hochschule fuer Technik Rapperswil * * 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. */ /* * 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 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< 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 (streq(ptr, str)) { 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)); } u_char secret_of_the_day[HASH_SIZE_SHA1];