freeswan/pluto/constants.c

   1 /* tables of names for values defined in constants.h
   2  * Copyright (C) 1998-2002  D. Hugh Redelmeier.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2 of the License, or (at your
   7  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * for more details.
  13  *
  14  * RCSID $Id: constants.c,v 1.60 2002/03/21 22:43:26 dhr Exp $
  15  */
  16
  17 /*
  18  * Note that the array sizes are all specified; this is to enable range
  19  * checking by code that only includes constants.h.
  20  */
  21
  22 #include <stddef.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25 #include <netinet/in.h>
  26
  27 #include <freeswan.h>
  28
  29 #include "constants.h"
  30 #include "defs.h"
  31 #include "log.h"
  32 #include "packet.h"
  33
  34 struct enum_names {
  35     unsigned long en_first;  /* first value in range */
  36     unsigned long en_last;   /* last value in range (inclusive) */
  37     const char *const *en_names;
  38     const struct enum_names *en_next_range;     /* descriptor of next range */
  39 };
  40
  41 /* version */
  42
  43 static const char *const version_name[] = {
  44         "ISAKMP Version 1.0",
  45 };
  46
  47 enum_names version_names =
  48     { ISAKMP_MAJOR_VERSION<<ISA_MAJ_SHIFT | ISAKMP_MINOR_VERSION,
  49         ISAKMP_MAJOR_VERSION<<ISA_MAJ_SHIFT | ISAKMP_MINOR_VERSION,
  50         version_name, NULL };
  51
  52 /* Timer events */
  53
  54 static const char *const timer_event_name[] = {
  55         "EVENT_NULL",
  56         "EVENT_REINIT_SECRET",
  57         "EVENT_SHUNT_SCAN",
  58         "EVENT_SO_DISCARD",
  59         "EVENT_RETRANSMIT",
  60         "EVENT_SA_REPLACE",
  61         "EVENT_SA_EXPIRE",
  62 #ifdef NAT_TRAVERSAL
  63         "EVENT_NAT_T_KEEPALIVE",
  64 #endif
  65         "EVENT_DPD",
  66         "EVENT_DPD_TIMEOUT",
  67     };
  68
  69 enum_names timer_event_names =
  70     { EVENT_NULL, EVENT_DPD_TIMEOUT, timer_event_name, NULL };
  71
  72 /* Domain of Interpretation */
  73
  74 static const char *const doi_name[] = {
  75         "ISAKMP_DOI_ISAKMP",
  76         "ISAKMP_DOI_IPSEC",
  77 };
  78
  79 enum_names doi_names = { ISAKMP_DOI_ISAKMP, ISAKMP_DOI_IPSEC, doi_name, NULL };
  80
  81 /* debugging settings: a set selections for reporting
  82  * These would be more naturally situated in log.h,
  83  * but they are shared with whack.
  84  */
  85 #ifdef DEBUG
  86 const char *const debug_bit_names[] = {
  87         "debug-raw",
  88         "debug-crypt",
  89         "debug-parsing",
  90         "debug-emitting",
  91         "debug-control",
  92         "debug-lifecycle",
  93         "debug-klips",
  94         "debug-dns",
  95         "debug-private",
  96         NULL
  97     };
  98 #endif
  99
 100 /* State of exchanges */
 101
 102 static const char *const state_name[] = {
 103         "STATE_MAIN_R0",
 104         "STATE_MAIN_I1",
 105         "STATE_MAIN_R1",
 106         "STATE_MAIN_I2",
 107         "STATE_MAIN_R2",
 108         "STATE_MAIN_I3",
 109         "STATE_MAIN_R3",
 110         "STATE_MAIN_I4",
 111
 112         "STATE_AGGR_R0",
 113         "STATE_AGGR_I1",
 114         "STATE_AGGR_R1",
 115         "STATE_AGGR_I2",
 116         "STATE_AGGR_R2",
 117
 118         "STATE_QUICK_R0",
 119         "STATE_QUICK_I1",
 120         "STATE_QUICK_R1",
 121         "STATE_QUICK_I2",
 122         "STATE_QUICK_R2",
 123
 124         "STATE_INFO",
 125         "STATE_INFO_PROTECTED",
 126     };
 127
 128 enum_names state_names =
 129     { STATE_MAIN_R0, STATE_INFO_PROTECTED, state_name, NULL };
 130
 131 /* story for state */
 132
 133 const char *const state_story[] = {
 134         "expecting MI1",                        /* STATE_MAIN_R0 */
 135         "sent MI1, expecting MR1",              /* STATE_MAIN_I1 */
 136         "sent MR1, expecting MI2",              /* STATE_MAIN_R1 */
 137         "sent MI2, expecting MR2",              /* STATE_MAIN_I2 */
 138         "sent MR2, expecting MI3",              /* STATE_MAIN_R2 */
 139         "sent MI3, expecting MR3",              /* STATE_MAIN_I3 */
 140         "sent MR3, ISAKMP SA established",      /* STATE_MAIN_R3 */
 141         "ISAKMP SA established",                /* STATE_MAIN_I4 */
 142
 143         "expecting AI1",                        /* STATE_AGGR_R0 */
 144         "sent AI1, expecting AR1",              /* STATE_AGGR_I1 */
 145         "sent AR1, expecting AI2",              /* STATE_AGGR_R1 */
 146         "sent AI2, ISAKMP SA established",      /* STATE_AGGR_I2 */
 147         "ISAKMP SA established",                /* STATE_AGGR_R2 */
 148
 149         "expecting QI1",                        /* STATE_QUICK_R0 */
 150         "sent QI1, expecting QR1",              /* STATE_QUICK_I1 */
 151         "sent QR1, inbound IPsec SA installed, expecting QI2",  /* STATE_QUICK_R1 */
 152         "sent QI2, IPsec SA established",       /* STATE_QUICK_I2 */
 153         "IPsec SA established",                 /* STATE_QUICK_R2 */
 154
 155         "got Informational Message in clear",   /* STATE_INFO */
 156         "got encrypted Informational Message",  /* STATE_INFO_PROTECTED */
 157     };
 158
 159 /* kind of struct connection */
 160
 161 static const char *const connection_kind_name[] = {
 162     "CK_TEMPLATE",      /* abstract connection, with wildcard */
 163     "CK_PERMANENT",     /* normal connection */
 164     "CK_INSTANCE",      /* instance of template, created for a particular attempt */
 165     "CK_GOING_AWAY"     /* instance being deleted -- don't delete again */
 166 };
 167
 168 enum_names connection_kind_names =
 169     { CK_TEMPLATE, CK_GOING_AWAY, connection_kind_name, NULL };
 170
 171 /* routing status names */
 172
 173 static const char *const routing_story_strings[] = {
 174     "unrouted", /* RT_UNROUTED: unrouted */
 175     "unrouted HOLD",    /* RT_UNROUTED_HOLD: unrouted, but HOLD eroute installed */
 176     "trap erouted",     /* RT_ROUTED_PROSPECTIVE: routed, and TRAP eroute installed */
 177     "routed HOLD",      /* RT_ROUTED_HOLD: routed, and HOLD eroute installed */
 178     "fail erouted",     /* RT_ROUTED_FAILURE: routed, and failure-context shunt eroute installed */
 179     "erouted",  /* RT_ROUTED_TUNNEL: routed, and erouted to an IPSEC SA group */
 180     };
 181
 182 enum_names routing_story =
 183     { RT_UNROUTED, RT_ROUTED_TUNNEL, routing_story_strings, NULL};
 184
 185 /* Payload types (draft-ietf-ipsec-isakmp-09.txt section 3.1) */
 186
 187 const char *const payload_name[] = {
 188         "ISAKMP_NEXT_NONE",
 189         "ISAKMP_NEXT_SA",
 190         "ISAKMP_NEXT_P",
 191         "ISAKMP_NEXT_T",
 192         "ISAKMP_NEXT_KE",
 193         "ISAKMP_NEXT_ID",
 194         "ISAKMP_NEXT_CERT",
 195         "ISAKMP_NEXT_CR",
 196         "ISAKMP_NEXT_HASH",
 197         "ISAKMP_NEXT_SIG",
 198         "ISAKMP_NEXT_NONCE",
 199         "ISAKMP_NEXT_N",
 200         "ISAKMP_NEXT_D",
 201         "ISAKMP_NEXT_VID",
 202 #ifdef NAT_TRAVERSAL
 203         "ISAKMP_NEXT_14",
 204         "ISAKMP_NEXT_NAT-D",
 205         "ISAKMP_NEXT_NAT-OA",
 206 #endif
 207         NULL
 208     };
 209
 210 #ifdef NAT_TRAVERSAL
 211 const char *const payload_name_nat_d[] = { "ISAKMP_NEXT_NAT-D",
 212         "ISAKMP_NEXT_NAT-OA", NULL };
 213 static enum_names payload_names_nat_d =
 214         { ISAKMP_NEXT_NATD_DRAFTS, ISAKMP_NEXT_NATOA_DRAFTS, payload_name_nat_d, NULL };
 215 enum_names payload_names =
 216     { ISAKMP_NEXT_NONE, ISAKMP_NEXT_NATOA_RFC, payload_name, &payload_names_nat_d };
 217 #else
 218 enum_names payload_names =
 219     { ISAKMP_NEXT_NONE, ISAKMP_NEXT_VID, payload_name, NULL };
 220 #endif
 221
 222
 223 /* Exchange types (note: two discontinuous ranges) */
 224
 225 static const char *const exchange_name[] = {
 226         "ISAKMP_XCHG_NONE",
 227         "ISAKMP_XCHG_BASE",
 228         "ISAKMP_XCHG_IDPROT",
 229         "ISAKMP_XCHG_AO",
 230         "ISAKMP_XCHG_AGGR",
 231         "ISAKMP_XCHG_INFO",
 232     };
 233
 234 static const char *const exchange_name2[] = {
 235         "ISAKMP_XCHG_QUICK",
 236         "ISAKMP_XCHG_NGRP",
 237         "ISAKMP_XCHG_ACK_INFO",
 238     };
 239
 240 static enum_names exchange_desc2 =
 241     { ISAKMP_XCHG_QUICK, ISAKMP_XCHG_ACK_INFO, exchange_name2, NULL };
 242
 243 enum_names exchange_names =
 244     { ISAKMP_XCHG_NONE, ISAKMP_XCHG_INFO, exchange_name, &exchange_desc2 };
 245
 246 /* Flag BITS */
 247 const char *const flag_bit_names[] = {
 248         "ISAKMP_FLAG_ENCRYPTION",
 249         "ISAKMP_FLAG_COMMIT",
 250         NULL
 251     };
 252
 253 /* Situation BITS definition for IPsec DOI */
 254
 255 const char *const sit_bit_names[] = {
 256         "SIT_IDENTITY_ONLY",
 257         "SIT_SECRECY",
 258         "SIT_INTEGRITY",
 259         NULL
 260     };
 261
 262 /* Protocol IDs (draft-ietf-ipsec-ipsec-doi-08.txt 4.4.1) */
 263
 264 static const char *const protocol_name[] = {
 265         "PROTO_ISAKMP",
 266         "PROTO_IPSEC_AH",
 267         "PROTO_IPSEC_ESP",
 268         "PROTO_IPCOMP",
 269     };
 270
 271 enum_names protocol_names =
 272     { PROTO_ISAKMP, PROTO_IPCOMP, protocol_name, NULL };
 273
 274 /* IPsec ISAKMP transform values */
 275
 276 static const char *const isakmp_transform_name[] = {
 277         "KEY_IKE",
 278     };
 279
 280 enum_names isakmp_transformid_names =
 281     { KEY_IKE, KEY_IKE, isakmp_transform_name, NULL };
 282
 283 /* IPsec AH transform values */
 284
 285 static const char *const ah_transform_name[] = {
 286         "AH_MD5",
 287         "AH_SHA",
 288         "AH_DES",
 289         "AH_SHA2_256",
 290         "AH_SHA2_384",
 291         "AH_SHA2_512",
 292     };
 293
 294 enum_names ah_transformid_names =
 295     { AH_MD5, AH_SHA2_512, ah_transform_name, NULL };
 296
 297 /* IPsec ESP transform values */
 298
 299 static const char *const esp_transform_name[] = {
 300         "ESP_DES_IV64",
 301         "ESP_DES",
 302         "ESP_3DES",
 303         "ESP_RC5",
 304         "ESP_IDEA",
 305         "ESP_CAST",
 306         "ESP_BLOWFISH",
 307         "ESP_3IDEA",
 308         "ESP_DES_IV32",
 309         "ESP_RC4",
 310         "ESP_NULL",
 311         "ESP_AES"
 312 };
 313
 314 /*
 315  * ipsec drafts suggest "high" ESP ids values for testing,
 316  * assign generic ESP_ID<num> if not officially defined
 317  */
 318 static const char *const esp_transform_name_high[] = {
 319         /* id=248 */    "ESP_ID248","ESP_MARS","ESP_RC6","ESP_ID251",
 320         /* id=252 */    "ESP_SERPENT", "ESP_TWOFISH", "ESP_CAMELLIA", "ESP_ID255",
 321         /* id=256 */    "ESP_ID256"
 322     };
 323
 324 enum_names esp_transformid_names_high =
 325     { 248, 256, esp_transform_name_high, NULL };
 326
 327 enum_names esp_transformid_names =
 328     { ESP_DES_IV64, ESP_AES, esp_transform_name, &esp_transformid_names_high };
 329
 330 /* IPCOMP transform values */
 331
 332 static const char *const ipcomp_transform_name[] = {
 333         "IPCOMP_OUI",
 334         "IPCOMP_DEFLAT",
 335         "IPCOMP_LZS",
 336         "IPCOMP_V42BIS",
 337     };
 338
 339 enum_names ipcomp_transformid_names =
 340     { IPCOMP_OUI, IPCOMP_V42BIS, ipcomp_transform_name, NULL };
 341
 342 /* Identification type values */
 343
 344 static const char *const ident_name[] = {
 345         "ID_IPV4_ADDR",
 346         "ID_FQDN",
 347         "ID_USER_FQDN",
 348         "ID_IPV4_ADDR_SUBNET",
 349         "ID_IPV6_ADDR",
 350         "ID_IPV6_ADDR_SUBNET",
 351         "ID_IPV4_ADDR_RANGE",
 352         "ID_IPV6_ADDR_RANGE",
 353         "ID_DER_ASN1_DN",
 354         "ID_DER_ASN1_GN",
 355         "ID_KEY_ID",
 356     };
 357
 358 enum_names ident_names =
 359     { ID_IPV4_ADDR, ID_KEY_ID, ident_name, NULL };
 360
 361 /* Certificate type values */
 362
 363 static const char *const cert_type_name[] = {
 364         "CERT_NONE",
 365         "CERT_PKCS7_WRAPPED_X509",
 366         "CERT_PGP",
 367         "CERT_DNS_SIGNED_KEY",
 368         "CERT_X509_SIGNATURE",
 369         "CERT_X509_KEY_EXCHANGE",
 370         "CERT_KERBEROS_TOKENS",
 371         "CERT_CRL",
 372         "CERT_ARL",
 373         "CERT_SPKI",
 374         "CERT_X509_ATTRIBUTE",
 375     };
 376
 377 enum_names cert_type_names =
 378     { CERT_NONE, CERT_X509_ATTRIBUTE, cert_type_name, NULL };
 379
 380 /* Goal BITs for establishing an SA
 381  * Note: we drop the POLICY_ prefix so that logs are more concise.
 382  */
 383
 384 const char *const sa_policy_bit_names[] = {
 385         "AGGRESSIVE",
 386         "PSK",
 387         "RSASIG",
 388         "ENCRYPT",
 389         "AUTHENTICATE",
 390         "COMPRESS",
 391         "TUNNEL",
 392         "PFS",
 393         "DISABLEARRIVALCHECK",
 394         "PASS",
 395         "DROP",
 396         "DONTREKEY",
 397         "OPPORTUNISTIC",
 398         NULL
 399     };
 400
 401 /* Oakley transform attributes
 402  * oakley_attr_bit_names does double duty: it is used for enum names
 403  * and bit names.
 404  */
 405
 406 const char *const oakley_attr_bit_names[] = {
 407         "OAKLEY_ENCRYPTION_ALGORITHM",
 408         "OAKLEY_HASH_ALGORITHM",
 409         "OAKLEY_AUTHENTICATION_METHOD",
 410         "OAKLEY_GROUP_DESCRIPTION",
 411         "OAKLEY_GROUP_TYPE",
 412         "OAKLEY_GROUP_PRIME",
 413         "OAKLEY_GROUP_GENERATOR_ONE",
 414         "OAKLEY_GROUP_GENERATOR_TWO",
 415         "OAKLEY_GROUP_CURVE_A",
 416         "OAKLEY_GROUP_CURVE_B",
 417         "OAKLEY_LIFE_TYPE",
 418         "OAKLEY_LIFE_DURATION",
 419         "OAKLEY_PRF",
 420         "OAKLEY_KEY_LENGTH",
 421         "OAKLEY_FIELD_SIZE",
 422         "OAKLEY_GROUP_ORDER",
 423         "OAKLEY_BLOCK_SIZE",
 424         NULL
 425     };
 426
 427 static const char *const oakley_var_attr_name[] = {
 428         "OAKLEY_GROUP_PRIME (variable length)",
 429         "OAKLEY_GROUP_GENERATOR_ONE (variable length)",
 430         "OAKLEY_GROUP_GENERATOR_TWO (variable length)",
 431         "OAKLEY_GROUP_CURVE_A (variable length)",
 432         "OAKLEY_GROUP_CURVE_B (variable length)",
 433         NULL,
 434         "OAKLEY_LIFE_DURATION (variable length)",
 435         NULL,
 436         NULL,
 437         NULL,
 438         "OAKLEY_GROUP_ORDER (variable length)",
 439     };
 440
 441 static enum_names oakley_attr_desc_tv = {
 442     OAKLEY_ENCRYPTION_ALGORITHM + ISAKMP_ATTR_AF_TV,
 443     OAKLEY_GROUP_ORDER + ISAKMP_ATTR_AF_TV, oakley_attr_bit_names, NULL };
 444
 445 enum_names oakley_attr_names = {
 446     OAKLEY_GROUP_PRIME, OAKLEY_GROUP_ORDER,
 447     oakley_var_attr_name, &oakley_attr_desc_tv };
 448
 449 /* for each Oakley attribute, which enum_names describes its values? */
 450 enum_names *oakley_attr_val_descs[] = {
 451         NULL,                   /* (none) */
 452         &oakley_enc_names,      /* OAKLEY_ENCRYPTION_ALGORITHM */
 453         &oakley_hash_names,     /* OAKLEY_HASH_ALGORITHM */
 454         &oakley_auth_names,     /* OAKLEY_AUTHENTICATION_METHOD */
 455         &oakley_group_names,    /* OAKLEY_GROUP_DESCRIPTION */
 456         &oakley_group_type_names,/* OAKLEY_GROUP_TYPE */
 457         NULL,                   /* OAKLEY_GROUP_PRIME */
 458         NULL,                   /* OAKLEY_GROUP_GENERATOR_ONE */
 459         NULL,                   /* OAKLEY_GROUP_GENERATOR_TWO */
 460         NULL,                   /* OAKLEY_GROUP_CURVE_A */
 461         NULL,                   /* OAKLEY_GROUP_CURVE_B */
 462         &oakley_lifetime_names, /* OAKLEY_LIFE_TYPE */
 463         NULL,                   /* OAKLEY_LIFE_DURATION */
 464         &oakley_prf_names,      /* OAKLEY_PRF */
 465         NULL,                   /* OAKLEY_KEY_LENGTH */
 466         NULL,                   /* OAKLEY_FIELD_SIZE */
 467         NULL,                   /* OAKLEY_GROUP_ORDER */
 468     };
 469
 470 /* IPsec DOI attributes (draft-ietf-ipsec-ipsec-doi-08.txt 4.5) */
 471
 472 static const char *const ipsec_attr_name[] = {
 473         "SA_LIFE_TYPE",
 474         "SA_LIFE_DURATION",
 475         "GROUP_DESCRIPTION",
 476         "ENCAPSULATION_MODE",
 477         "AUTH_ALGORITHM",
 478         "KEY_LENGTH",
 479         "KEY_ROUNDS",
 480         "COMPRESS_DICT_SIZE",
 481         "COMPRESS_PRIVATE_ALG",
 482     };
 483
 484 static const char *const ipsec_var_attr_name[] = {
 485         "SA_LIFE_DURATION (variable length)",
 486         NULL,
 487         NULL,
 488         NULL,
 489         NULL,
 490         NULL,
 491         NULL,
 492         "COMPRESS_PRIVATE_ALG (variable length)",
 493     };
 494
 495 static enum_names ipsec_attr_desc_tv = {
 496     SA_LIFE_TYPE + ISAKMP_ATTR_AF_TV,
 497     COMPRESS_PRIVATE_ALG + ISAKMP_ATTR_AF_TV,
 498     ipsec_attr_name, NULL };
 499
 500 enum_names ipsec_attr_names = {
 501     SA_LIFE_DURATION, COMPRESS_PRIVATE_ALG,
 502     ipsec_var_attr_name, &ipsec_attr_desc_tv };
 503
 504 /* for each IPsec attribute, which enum_names describes its values? */
 505 enum_names *ipsec_attr_val_descs[] = {
 506         NULL,                   /* (none) */
 507         &sa_lifetime_names,     /* SA_LIFE_TYPE */
 508         NULL,                   /* SA_LIFE_DURATION */
 509         &oakley_group_names,    /* GROUP_DESCRIPTION */
 510         &enc_mode_names,                /* ENCAPSULATION_MODE */
 511         &auth_alg_names,                /* AUTH_ALGORITHM */
 512         NULL,                   /* KEY_LENGTH */
 513         NULL,                   /* KEY_ROUNDS */
 514         NULL,                   /* COMPRESS_DICT_SIZE */
 515         NULL,                   /* COMPRESS_PRIVATE_ALG */
 516     };
 517
 518 /* SA Lifetime Type attribute */
 519
 520 static const char *const sa_lifetime_name[] = {
 521         "SA_LIFE_TYPE_SECONDS",
 522         "SA_LIFE_TYPE_KBYTES",
 523     };
 524
 525 enum_names sa_lifetime_names =
 526     { SA_LIFE_TYPE_SECONDS, SA_LIFE_TYPE_KBYTES, sa_lifetime_name, NULL };
 527
 528 /* Encapsulation Mode attribute */
 529
 530 static const char *const enc_mode_name[] = {
 531         "ENCAPSULATION_MODE_TUNNEL",
 532         "ENCAPSULATION_MODE_TRANSPORT",
 533 #ifdef NAT_TRAVERSAL
 534         "ENCAPSULATION_MODE_UDP_TUNNEL",
 535         "ENCAPSULATION_MODE_UDP_TRANSPORT",
 536 #endif
 537     };
 538
 539 #ifdef NAT_TRAVERSAL
 540 static const char *const enc_udp_mode_name[] = {
 541         "ENCAPSULATION_MODE_UDP_TUNNEL",
 542         "ENCAPSULATION_MODE_UDP_TRANSPORT",
 543     };
 544 #endif
 545
 546 #ifdef NAT_TRAVERSAL
 547 static enum_names enc_udp_mode_names =
 548     { ENCAPSULATION_MODE_UDP_TUNNEL_DRAFTS, ENCAPSULATION_MODE_UDP_TRANSPORT_DRAFTS, enc_udp_mode_name, NULL };
 549 enum_names enc_mode_names =
 550     { ENCAPSULATION_MODE_TUNNEL, ENCAPSULATION_MODE_UDP_TRANSPORT_RFC, enc_mode_name, &enc_udp_mode_names };
 551 #else
 552 enum_names enc_mode_names =
 553     { ENCAPSULATION_MODE_TUNNEL, ENCAPSULATION_MODE_TRANSPORT, enc_mode_name, NULL };
 554 #endif
 555
 556 /* Auth Algorithm attribute */
 557
 558 static const char *const auth_alg_name[] = {
 559         "unspecified AUTH_ALGORITHM",
 560         "AUTH_ALGORITHM_HMAC_MD5",
 561         "AUTH_ALGORITHM_HMAC_SHA1",
 562         "AUTH_ALGORITHM_DES_MAC",
 563         "AUTH_ALGORITHM_KPDK",
 564         "AUTH_ALGORITHM_HMAC_SHA2_256",
 565         "AUTH_ALGORITHM_HMAC_SHA2_384",
 566         "AUTH_ALGORITHM_HMAC_SHA2_512",
 567         "AUTH_ALGORITHM_HMAC_RIPEMD",
 568         "AUTH_ALGORITHM_ID9",
 569         "AUTH_ALGORITHM_ID10",
 570         "AUTH_ALGORITHM_ID11",
 571         "AUTH_ALGORITHM_ID12",
 572         "AUTH_ALGORITHM_ID13",
 573         "AUTH_ALGORITHM_ID14",
 574         "AUTH_ALGORITHM_ID15",
 575     };
 576
 577 enum_names
 578     auth_alg_names =
 579         { AUTH_ALGORITHM_HMAC_MD5, 15 /* AUTH_ALGORITHM_HMAC_RIPEMD */, auth_alg_name + 1, NULL },
 580     extended_auth_alg_names =
 581         { AUTH_ALGORITHM_NONE, AUTH_ALGORITHM_KPDK, auth_alg_name, NULL };
 582
 583 /* Oakley Lifetime Type attribute */
 584
 585 static const char *const oakley_lifetime_name[] = {
 586         "OAKLEY_LIFE_SECONDS",
 587         "OAKLEY_LIFE_KILOBYTES",
 588     };
 589
 590 enum_names oakley_lifetime_names =
 591     { OAKLEY_LIFE_SECONDS, OAKLEY_LIFE_KILOBYTES, oakley_lifetime_name, NULL };
 592
 593 /* Oakley PRF attribute (none defined) */
 594
 595 enum_names oakley_prf_names =
 596     { 1, 0, NULL, NULL };
 597
 598 /* Oakley Encryption Algorithm attribute */
 599
 600 static const char *const oakley_enc_name[] = {
 601         "OAKLEY_DES_CBC",
 602         "OAKLEY_IDEA_CBC",
 603         "OAKLEY_BLOWFISH_CBC",
 604         "OAKLEY_RC5_R16_B64_CBC",
 605         "OAKLEY_3DES_CBC",
 606         "OAKLEY_CAST_CBC",
 607         "OAKLEY_AES_CBC",
 608     };
 609
 610 #ifdef NO_EXTRA_IKE
 611 enum_names oakley_enc_names =
 612     { OAKLEY_DES_CBC, OAKLEY_AES_CBC, oakley_enc_name, NULL };
 613 #else
 614 static const char *const oakley_enc_name_draft_aes_cbc_02[] = {
 615         "OAKLEY_MARS_CBC"       /*      65001   */,
 616         "OAKLEY_RC6_CBC"        /*      65002   */,
 617         "OAKLEY_ID_65003"       /*      65003   */,
 618         "OAKLEY_SERPENT_CBC"    /*      65004   */,
 619         "OAKLEY_TWOFISH_CBC"    /*      65005   */,
 620 };
 621 static const char *const oakley_enc_name_ssh[] = {
 622         "OAKLEY_SSH_PRIVATE_65289",
 623 };
 624 enum_names oakley_enc_names_ssh =
 625     { 65289, 65289, oakley_enc_name_ssh, NULL };
 626 enum_names oakley_enc_names_draft_aes_cbc_02 =
 627     { 65001, 65005, oakley_enc_name_draft_aes_cbc_02, &oakley_enc_names_ssh };
 628 enum_names oakley_enc_names =
 629     { OAKLEY_DES_CBC, OAKLEY_AES_CBC, oakley_enc_name, &oakley_enc_names_draft_aes_cbc_02 };
 630 #endif
 631
 632 /* Oakley Hash Algorithm attribute */
 633
 634 static const char *const oakley_hash_name[] = {
 635         "OAKLEY_MD5",
 636         "OAKLEY_SHA",
 637         "OAKLEY_TIGER",
 638         "OAKLEY_SHA2_256",
 639         "OAKLEY_SHA2_384",
 640         "OAKLEY_SHA2_512",
 641     };
 642
 643 enum_names oakley_hash_names =
 644     { OAKLEY_MD5, OAKLEY_SHA2_512, oakley_hash_name, NULL };
 645
 646 /* Oakley Authentication Method attribute */
 647
 648 static const char *const oakley_auth_name1[] = {
 649         "OAKLEY_PRESHARED_KEY",
 650         "OAKLEY_DSS_SIG",
 651         "OAKLEY_RSA_SIG",
 652         "OAKLEY_RSA_ENC",
 653         "OAKLEY_RSA_ENC_REV",
 654         "OAKLEY_ELGAMAL_ENC",
 655         "OAKLEY_ELGAMAL_ENC_REV",
 656     };
 657
 658 static const char *const oakley_auth_name2[] = {
 659         "HybridInitRSA",
 660         "HybridRespRSA",
 661         "HybridInitDSS",
 662         "HybridRespDSS",
 663     };
 664
 665 static const char *const oakley_auth_name3[] = {
 666         "XAUTHInitPreShared",
 667         "XAUTHRespPreShared",
 668         "XAUTHInitDSS",
 669         "XAUTHRespDSS",
 670         "XAUTHInitRSA",
 671         "XAUTHRespRSA",
 672         "XAUTHInitRSAEncryption",
 673         "XAUTHRespRSAEncryption",
 674         "XAUTHInitRSARevisedEncryption",
 675         "XAUTHRespRSARevisedEncryption",
 676     };
 677
 678 static enum_names oakley_auth_names1 =
 679     { OAKLEY_PRESHARED_KEY, OAKLEY_ELGAMAL_ENC_REV
 680         , oakley_auth_name1, NULL };
 681
 682 static enum_names oakley_auth_names2 =
 683     { HybridInitRSA, HybridRespDSS
 684         , oakley_auth_name2, &oakley_auth_names1 };
 685
 686 enum_names oakley_auth_names =
 687     { XAUTHInitPreShared, XAUTHRespRSARevisedEncryption
 688         , oakley_auth_name3, &oakley_auth_names2 };
 689
 690 /* Oakley Group Description attribute */
 691
 692 static const char *const oakley_group_name[] = {
 693         "OAKLEY_GROUP_MODP768",
 694         "OAKLEY_GROUP_MODP1024",
 695         "OAKLEY_GROUP_GP155",
 696         "OAKLEY_GROUP_GP185",
 697         "OAKLEY_GROUP_MODP1536 (extension)",
 698     };
 699
 700 static const char *const oakley_group_name_2048[] = {
 701         "OAKLEY_GROUP_MODP2048 (extension)",
 702 };
 703 static const char *const oakley_group_name_3072[] = {
 704         "OAKLEY_GROUP_MODP3072 (extension)",
 705 };
 706 static const char *const oakley_group_name_4096[] = {
 707         "OAKLEY_GROUP_MODP4096 (extension)",
 708 };
 709
 710 enum_names oakley_group_names_4096 =
 711     { OAKLEY_GROUP_MODP4096, OAKLEY_GROUP_MODP4096,
 712             oakley_group_name_4096, NULL };
 713
 714 enum_names oakley_group_names_3072 =
 715     { OAKLEY_GROUP_MODP3072, OAKLEY_GROUP_MODP3072,
 716             oakley_group_name_3072, &oakley_group_names_4096 };
 717
 718 enum_names oakley_group_names_2048 =
 719     { OAKLEY_GROUP_MODP2048, OAKLEY_GROUP_MODP2048,
 720             oakley_group_name_2048, &oakley_group_names_3072 };
 721
 722 enum_names oakley_group_names =
 723     { OAKLEY_GROUP_MODP768, OAKLEY_GROUP_MODP1536,
 724             oakley_group_name, &oakley_group_names_2048 };
 725
 726 /* Oakley Group Type attribute */
 727
 728 static const char *const oakley_group_type_name[] = {
 729         "OAKLEY_GROUP_TYPE_MODP",
 730         "OAKLEY_GROUP_TYPE_ECP",
 731         "OAKLEY_GROUP_TYPE_EC2N",
 732     };
 733
 734 enum_names oakley_group_type_names =
 735     { OAKLEY_GROUP_TYPE_MODP, OAKLEY_GROUP_TYPE_EC2N, oakley_group_type_name, NULL };
 736
 737 /* Notify messages -- error types */
 738
 739 static const char *const notification_name[] = {
 740         "INVALID_PAYLOAD_TYPE",
 741
 742         "DOI_NOT_SUPPORTED",
 743         "SITUATION_NOT_SUPPORTED",
 744         "INVALID_COOKIE",
 745         "INVALID_MAJOR_VERSION",
 746         "INVALID_MINOR_VERSION",
 747         "INVALID_EXCHANGE_TYPE",
 748         "INVALID_FLAGS",
 749         "INVALID_MESSAGE_ID",
 750         "INVALID_PROTOCOL_ID",
 751         "INVALID_SPI",
 752         "INVALID_TRANSFORM_ID",
 753         "ATTRIBUTES_NOT_SUPPORTED",
 754         "NO_PROPOSAL_CHOSEN",
 755         "BAD_PROPOSAL_SYNTAX",
 756         "PAYLOAD_MALFORMED",
 757         "INVALID_KEY_INFORMATION",
 758         "INVALID_ID_INFORMATION",
 759         "INVALID_CERT_ENCODING",
 760         "INVALID_CERTIFICATE",
 761         "CERT_TYPE_UNSUPPORTED",
 762         "INVALID_CERT_AUTHORITY",
 763         "INVALID_HASH_INFORMATION",
 764         "AUTHENTICATION_FAILED",
 765         "INVALID_SIGNATURE",
 766         "ADDRESS_NOTIFICATION",
 767         "NOTIFY_SA_LIFETIME",
 768         "CERTIFICATE_UNAVAILABLE",
 769         "UNSUPPORTED_EXCHANGE_TYPE",
 770         "UNEQUAL_PAYLOAD_LENGTHS",
 771     };
 772
 773 static const char *const notification_status_name[] = {
 774         "CONNECTED",
 775     };
 776
 777 static const char *const ipsec_notification_name[] = {
 778         "IPSEC_RESPONDER_LIFETIME",
 779         "IPSEC_REPLAY_STATUS",
 780         "IPSEC_INITIAL_CONTACT",
 781     };
 782
 783 enum_names notification_names =
 784     { INVALID_PAYLOAD_TYPE, UNEQUAL_PAYLOAD_LENGTHS,
 785         notification_name, NULL };
 786
 787 enum_names notification_status_names =
 788     { CONNECTED, CONNECTED,
 789         notification_status_name, &notification_names };
 790
 791 enum_names ipsec_notification_names =
 792     { IPSEC_RESPONDER_LIFETIME, IPSEC_INITIAL_CONTACT,
 793         ipsec_notification_name, &notification_status_names };
 794
 795
 796 /* socket address family info */
 797
 798 static const char *const af_inet_name[] = {
 799         "AF_INET",
 800     };
 801
 802 static const char *const af_inet6_name[] = {
 803         "AF_INET6",
 804     };
 805
 806 static enum_names af_names6 = { AF_INET6, AF_INET6, af_inet6_name, NULL };
 807
 808 enum_names af_names = { AF_INET, AF_INET, af_inet_name, &af_names6 };
 809
 810 static ip_address ipv4_any, ipv6_any;
 811 static ip_subnet ipv4_wildcard, ipv6_wildcard;
 812 static ip_subnet ipv4_all, ipv6_all;
 813
 814 const struct af_info af_inet4_info = {
 815         AF_INET,
 816         "AF_INET",
 817         sizeof(struct in_addr),
 818         sizeof(struct sockaddr_in),
 819         32,
 820         ID_IPV4_ADDR, ID_IPV4_ADDR_SUBNET, ID_IPV4_ADDR_RANGE,
 821         &ipv4_any, &ipv4_wildcard, &ipv4_all,
 822     };
 823
 824 const struct af_info af_inet6_info = {
 825         AF_INET6,
 826         "AF_INET6",
 827         sizeof(struct in6_addr),
 828         sizeof(struct sockaddr_in6),
 829         128,
 830         ID_IPV6_ADDR, ID_IPV6_ADDR_SUBNET, ID_IPV6_ADDR_RANGE,
 831         &ipv6_any, &ipv6_wildcard, &ipv6_all,
 832     };
 833
 834 const struct af_info *
 835 aftoinfo(int af)
 836 {
 837     switch (af)
 838     {
 839         case AF_INET:
 840             return &af_inet4_info;
 841         case AF_INET6:
 842             return &af_inet6_info;
 843         default:
 844             return NULL;
 845     }
 846 }
 847
 848 /* BIND enumerated types */
 849
 850 #include <arpa/nameser.h>
 851
 852 static const char *const rr_type_name[] = {
 853         "T_A",  /* 1 host address */
 854         "T_NS", /* 2 authoritative server */
 855         "T_MD", /* 3 mail destination */
 856         "T_MF", /* 4 mail forwarder */
 857         "T_CNAME",      /* 5 canonical name */
 858         "T_SOA",        /* 6 start of authority zone */
 859         "T_MB", /* 7 mailbox domain name */
 860         "T_MG", /* 8 mail group member */
 861         "T_MR", /* 9 mail rename name */
 862         "T_NULL",       /* 10 null resource record */
 863         "T_WKS",        /* 11 well known service */
 864         "T_PTR",        /* 12 domain name pointer */
 865         "T_HINFO",      /* 13 host information */
 866         "T_MINFO",      /* 14 mailbox information */
 867         "T_MX", /* 15 mail routing information */
 868         "T_TXT",        /* 16 text strings */
 869         "T_RP", /* 17 responsible person */
 870         "T_AFSDB",      /* 18 AFS cell database */
 871         "T_X25",        /* 19 X_25 calling address */
 872         "T_ISDN",       /* 20 ISDN calling address */
 873         "T_RT", /* 21 router */
 874         "T_NSAP",       /* 22 NSAP address */
 875         "T_NSAP_PTR",   /* 23 reverse NSAP lookup (deprecated) */
 876         "T_SIG",        /* 24 security signature */
 877         "T_KEY",        /* 25 security key */
 878         "T_PX", /* 26 X.400 mail mapping */
 879         "T_GPOS",       /* 27 geographical position (withdrawn) */
 880         "T_AAAA",       /* 28 IP6 Address */
 881         "T_LOC",        /* 29 Location Information */
 882         "T_NXT",        /* 30 Next Valid Name in Zone */
 883         "T_EID",        /* 31 Endpoint identifier */
 884         "T_NIMLOC",     /* 32 Nimrod locator */
 885         "T_SRV",        /* 33 Server selection */
 886         "T_ATMA",       /* 34 ATM Address */
 887         "T_NAPTR",      /* 35 Naming Authority PoinTeR */
 888         NULL
 889     };
 890
 891 enum_names rr_type_names = { T_A, T_NAPTR, rr_type_name, NULL };
 892
 893 /* Query type values which do not appear in resource records */
 894 static const char *const rr_qtype_name[] = {
 895         "T_IXFR",       /* 251 incremental zone transfer */
 896         "T_AXFR",       /* 252 transfer zone of authority */
 897         "T_MAILB",      /* 253 transfer mailbox records */
 898         "T_MAILA",      /* 254 transfer mail agent records */
 899         "T_ANY",        /* 255 wildcard match */
 900         NULL
 901     };
 902
 903 enum_names rr_qtype_names = { T_IXFR, T_ANY, rr_qtype_name, &rr_type_names };
 904
 905 static const char *const rr_class_name[] = {
 906         "C_IN", /* 1 the arpa internet */
 907         NULL
 908     };
 909
 910 enum_names rr_class_names = { C_IN, C_IN, rr_class_name, NULL };
 911
 912
 913 /* look up enum names in an enum_names */
 914
 915 const char *
 916 enum_name(enum_names *ed, unsigned long val)
 917 {
 918     enum_names  *p;
 919
 920     for (p = ed; p != NULL; p = p->en_next_range)
 921         if (p->en_first <= val && val <= p->en_last)
 922             return p->en_names[val - p->en_first];
 923     return NULL;
 924 }
 925
 926 /* find or construct a string to describe an enum value
 927  * Result may be in STATIC buffer!
 928  */
 929 const char *
 930 enum_show(enum_names *ed, unsigned long val)
 931 {
 932     const char *p = enum_name(ed, val);
 933
 934     if (p == NULL)
 935     {
 936         static char buf[12];    /* only one!  I hope that it is big enough */
 937
 938         snprintf(buf, sizeof(buf), "%lu??", val);
 939         p = buf;
 940     }
 941     return p;
 942 }
 943
 944 int
 945 enum_search(enum_names *ed, const char *str)
 946 {
 947     enum_names  *p;
 948     const char *ptr;
 949     unsigned en;
 950     char buf[100];
 951
 952     for (p = ed; p != NULL; p = p->en_next_range)
 953         for (en=p->en_first;en<=p->en_last;en++) {
 954             ptr=p->en_names[en - p->en_first];
 955             if (ptr==0) continue;
 956             strncpy(buf, ptr, strlen(ptr));
 957             buf[strlen(ptr)]='\0';
 958             if (strncmp(ptr, str, strlen(ptr))==0)
 959                     return en;
 960         }
 961     return -1;
 962 }
 963 /* construct a string to name the bits on in a set
 964  * Result may be in STATIC buffer!
 965  */
 966 const char *
 967 bitnamesof(const char *const table[], lset_t val)
 968 {
 969     static char buf[100];   /* only one!  I hope that it is big enough! */
 970     char *p = buf;
 971     lset_t bit;
 972     const char *const *tp;
 973
 974     if (val == 0)
 975         return "none";
 976
 977     for (tp = table, bit = 01; val != 0; bit <<= 1) {
 978         if (val & bit) {
 979             const char *n = *tp;
 980             size_t nl;
 981
 982             if (n == NULL || *n == '\0')
 983             {
 984                 /* no name for this bit, so use hex */
 985                 /* 64bits lset_t */
 986                 static char flagbuf[sizeof("0x80000000" "00000000")];
 987
 988                 snprintf(flagbuf, sizeof(flagbuf), "0x%llx", bit);
 989                 n = flagbuf;
 990             }
 991
 992             nl = strlen(n);
 993
 994             if (p != buf && p < buf+sizeof(buf) - 1)
 995                 *p++ = '+';
 996
 997             if (buf+sizeof(buf) - p > (ptrdiff_t)nl) {
 998                 strcpy(p, n);
 999                 p += nl;
1000             }
1001             val -= bit;
1002         }
1003         if (*tp != NULL)
1004             tp++;   /* move on, but not past end */
1005     }
1006     *p = '\0';
1007     return buf;
1008 }
1009
1010 /* test a set by seeing if all bits have names */
1011
1012 bool
1013 testset(const char *const table[], lset_t val)
1014 {
1015     lset_t bit;
1016     const char *const *tp;
1017
1018     for (tp = table, bit = 01; val != 0; bit <<= 1, tp++) {
1019         const char *n = *tp;
1020
1021         if (n == NULL || ((val & bit) && *n == '\0'))
1022             return FALSE;
1023         val &= ~bit;
1024     }
1025     return TRUE;
1026 }
1027
1028
1029 const char sparse_end[] = "end of sparse names";
1030
1031 /* look up enum names in a sparse_names */
1032 const char *sparse_name(sparse_names sd, unsigned long val)
1033 {
1034     const struct sparse_name *p;
1035
1036     for (p = sd; p->name != sparse_end; p++)
1037         if (p->val == val)
1038             return p->name;
1039     return NULL;
1040 }
1041
1042 /* find or construct a string to describe an sparse value
1043  * Result may be in STATIC buffer!
1044  */
1045 const char *
1046 sparse_val_show(sparse_names sd, unsigned long val)
1047 {
1048     const char *p = sparse_name(sd, val);
1049
1050     if (p == NULL)
1051     {
1052         static char buf[12];    /* only one!  I hope that it is big enough */
1053
1054         snprintf(buf, sizeof(buf), "%lu??", val);
1055         p = buf;
1056     }
1057     return p;
1058 }
1059
1060 void init_constants(void)
1061 {
1062     happy(anyaddr(AF_INET, &ipv4_any));
1063     happy(anyaddr(AF_INET, &ipv6_any));
1064
1065     happy(addrtosubnet(&ipv4_any, &ipv4_wildcard));
1066     happy(addrtosubnet(&ipv6_any, &ipv6_wildcard));
1067
1068     happy(initsubnet(&ipv4_any, 0, '0', &ipv4_all));
1069     happy(initsubnet(&ipv6_any, 0, '0', &ipv6_all));
1070 }