ipsec-tools/racoon/strnames.c

   1 /*      $NetBSD: strnames.c,v 1.7.6.1 2007/08/01 11:52:22 vanhu Exp $   */
   2
   3 /*      $KAME: strnames.c,v 1.25 2003/11/13 10:53:26 itojun Exp $       */
   4
   5 /*
   6  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the project nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "config.h"
  35
  36 #include <sys/types.h>
  37 #include <sys/param.h>
  38 #include <sys/socket.h>
  39
  40 #include <netinet/in.h>
  41 #ifdef HAVE_NETINET6_IPSEC
  42 #  include <netinet6/ipsec.h>
  43 #else
  44 #  include <netinet/ipsec.h>
  45 #endif
  46 #include <netinet/in.h>
  47
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #ifdef ENABLE_HYBRID
  51 #include <resolv.h>
  52 #endif
  53
  54 #include "var.h"
  55 #include "misc.h"
  56 #include "vmbuf.h"
  57 #include "plog.h"
  58 #include "fsm.h"
  59
  60 #include "isakmp_var.h"
  61 #include "isakmp.h"
  62 #ifdef ENABLE_HYBRID
  63 #  include "isakmp_xauth.h"
  64 #  include "isakmp_unity.h"
  65 #  include "isakmp_cfg.h"
  66 #endif
  67 #include "ipsec_doi.h"
  68 #include "oakley.h"
  69 #include "handler.h"
  70 #include "pfkey.h"
  71 #include "strnames.h"
  72 #include "algorithm.h"
  73 #include "ikev2_rfc.h"
  74
  75 struct ksmap {
  76         int key;
  77         char *str;
  78         char *(*f) (int);
  79 };
  80
  81 char *
  82 num2str(n)
  83         int n;
  84 {
  85         static char buf[20];
  86
  87         snprintf(buf, sizeof(buf), "%d", n);
  88
  89         return buf;
  90 }
  91
  92 /* isakmp.h */
  93 char *
  94 s_isakmp_state(t, d, s)
  95         int t, d, s;
  96 {
  97         switch (s) {
  98         case IKEV1_STATE_PHASE1_ESTABLISHED:
  99             return "Phase 1 Established";
 100         case IKEV1_STATE_PHASE2_ESTABLISHED:
 101             return "Phase 2 established";
 102         case IKEV1_STATE_PHASE1_EXPIRED:
 103             return "Phase 1 expired";
 104         case IKEV1_STATE_PHASE2_EXPIRED:
 105             return "Phase 2 expired";
 106         case IKEV1_STATE_INFO:
 107             return "IKEv1 info";
 108         case IKEV1_STATE_IDENT_I_START:
 109             return "IKEv1 ident I start";
 110         case IKEV1_STATE_IDENT_I_MSG1SENT:
 111             return "IKEv1 ident I msg1 sent";
 112         case IKEV1_STATE_IDENT_I_MSG2RCVD:
 113             return "IKEv1 ident I msg2 rcvd";
 114         case IKEV1_STATE_IDENT_I_MSG3SENT:
 115             return "IKEv1 ident I msg3 sent";
 116         case IKEV1_STATE_IDENT_I_MSG4RCVD:
 117             return "IKEv1 ident I msg4 rcvd";
 118         case IKEV1_STATE_IDENT_I_MSG5SENT:
 119             return "IKEv1 ident I msg5 sent";
 120         case IKEV1_STATE_IDENT_I_MSG6RCVD:
 121             return "IKEv1 ident I msg6 rcvd";
 122
 123         case IKEV1_STATE_IDENT_R_START:
 124             return "IKEv1 ident R start";
 125         case IKEV1_STATE_IDENT_R_MSG1RCVD:
 126             return "IKEv1 ident R msg1 rcvd";
 127         case IKEV1_STATE_IDENT_R_MSG2SENT:
 128             return "IKEv1 ident R msg2 sent";
 129         case IKEV1_STATE_IDENT_R_MSG3RCVD:
 130             return "IKEv1 ident R msg3 rcvd";
 131         case IKEV1_STATE_IDENT_R_MSG4SENT:
 132             return "IKEv1 ident R msg4 sent";
 133         case IKEV1_STATE_IDENT_R_MSG5RCVD:
 134             return "IKEv1 ident R msg5 rcvd";
 135
 136         case IKEV1_STATE_AGG_I_START:
 137             return "IKEv1 agg I start";
 138         case IKEV1_STATE_AGG_I_MSG1SENT:
 139             return "IKEv1 agg I msg1 sent";
 140         case IKEV1_STATE_AGG_I_MSG2RCVD:
 141             return "IKEv1 agg I msg2 rcvd";
 142         case IKEV1_STATE_AGG_I_MSG3SENT:
 143             return "IKEv1 agg I msg3 sent";
 144         case IKEV1_STATE_AGG_R_START:
 145             return "IKEv1 agg R start";
 146         case IKEV1_STATE_AGG_R_MSG1RCVD:
 147             return "IKEv1 agg R msg1 rcvd";
 148         case IKEV1_STATE_AGG_R_MSG2SENT:
 149             return "IKEv1 agg R msg2 sent";
 150         case IKEV1_STATE_AGG_R_MSG3RCVD:
 151             return "IKEv1 agg R msg3 rcvd";
 152
 153         case IKEV1_STATE_QUICK_I_START:
 154             return "IKEv1 quick I start";
 155         case IKEV1_STATE_QUICK_I_GETSPISENT:
 156             return "IKEv1 quick I getspi sent";
 157         case IKEV1_STATE_QUICK_I_GETSPIDONE:
 158             return "IKEv1 quick I getspi done";
 159         case IKEV1_STATE_QUICK_I_MSG1SENT:
 160             return "IKEv1 quick I msg1 sent";
 161         case IKEV1_STATE_QUICK_I_MSG2RCVD:
 162             return "IKEv1 quick I msg2 rcvd";
 163         case IKEV1_STATE_QUICK_I_MSG3SENT:
 164             return "IKEv1 quick I msg3 sent";
 165         case IKEV1_STATE_QUICK_I_ADDSA:
 166             return "IKEv1 quick I addsa";
 167         case IKEV1_STATE_QUICK_R_START:
 168             return "IKEv1 quick R start";
 169         case IKEV1_STATE_QUICK_R_MSG1RCVD:
 170             return "IKEv1 quick R msg1 rcvd";
 171         case IKEV1_STATE_QUICK_R_GETSPISENT:
 172             return "IKEv1 quick R getspi sent";
 173         case IKEV1_STATE_QUICK_R_GETSPIDONE:
 174             return "IKEv1 quick R getspi done";
 175         case IKEV1_STATE_QUICK_R_MSG2SENT:
 176             return "IKEv1 quick R msg2 sent";
 177         case IKEV1_STATE_QUICK_R_MSG3RCVD:
 178             return "IKEv1 quick R msg3 rcvd";
 179         case IKEV1_STATE_QUICK_R_COMMIT:
 180             return "IKEv1 quick R commit";
 181         case IKEV1_STATE_QUICK_R_ADDSA:
 182             return "IKEv1 quick R addsa";
 183
 184     }
 185         return "???";
 186 }
 187
 188 static struct ksmap name_isakmp_certtype[] = {
 189 { ISAKMP_CERT_NONE,     "NONE",                                 NULL },
 190 { ISAKMP_CERT_PKCS7,    "PKCS #7 wrapped X.509 certificate",    NULL },
 191 { ISAKMP_CERT_PGP,      "PGP Certificate",                      NULL },
 192 { ISAKMP_CERT_DNS,      "DNS Signed Key",                       NULL },
 193 { ISAKMP_CERT_X509SIGN, "X.509 Certificate Signature",          NULL },
 194 { ISAKMP_CERT_X509KE,   "X.509 Certificate Key Exchange",       NULL },
 195 { ISAKMP_CERT_KERBEROS, "Kerberos Tokens",                      NULL },
 196 { ISAKMP_CERT_CRL,      "Certificate Revocation List (CRL)",    NULL },
 197 { ISAKMP_CERT_ARL,      "Authority Revocation List (ARL)",      NULL },
 198 { ISAKMP_CERT_SPKI,     "SPKI Certificate",                     NULL },
 199 { ISAKMP_CERT_X509ATTR, "X.509 Certificate Attribute",          NULL },
 200 };
 201
 202 char *
 203 s_isakmp_certtype(k)
 204         int k;
 205 {
 206         int i;
 207         for (i = 0; i < ARRAYLEN(name_isakmp_certtype); i++)
 208                 if (name_isakmp_certtype[i].key == k)
 209                         return name_isakmp_certtype[i].str;
 210         return num2str(k);
 211 }
 212
 213 static struct ksmap name_isakmp_etype[] = {
 214 { ISAKMP_ETYPE_NONE,    "None",                 NULL },
 215 { ISAKMP_ETYPE_BASE,    "Base",                 NULL },
 216 { ISAKMP_ETYPE_IDENT,   "Identity Protection",  NULL },
 217 { ISAKMP_ETYPE_AUTH,    "Authentication Only",  NULL },
 218 { ISAKMP_ETYPE_AGG,     "Aggressive",           NULL },
 219 { ISAKMP_ETYPE_INFO,    "Informational",        NULL },
 220 { ISAKMP_ETYPE_CFG,     "Mode config",          NULL },
 221 { ISAKMP_ETYPE_QUICK,   "Quick",                NULL },
 222 { ISAKMP_ETYPE_NEWGRP,  "New Group",            NULL },
 223 { ISAKMP_ETYPE_ACKINFO, "Acknowledged Informational",   NULL },
 224 };
 225
 226 char *
 227 s_isakmp_etype(k)
 228         int k;
 229 {
 230         int i;
 231         for (i = 0; i < ARRAYLEN(name_isakmp_etype); i++)
 232                 if (name_isakmp_etype[i].key == k)
 233                         return name_isakmp_etype[i].str;
 234         return num2str(k);
 235 }
 236
 237 static struct ksmap name_isakmp_notify_msg[] = {
 238 { ISAKMP_NTYPE_INVALID_PAYLOAD_TYPE,    "INVALID-PAYLOAD-TYPE",         NULL },
 239 { ISAKMP_NTYPE_DOI_NOT_SUPPORTED,       "DOI-NOT-SUPPORTED",            NULL },
 240 { ISAKMP_NTYPE_SITUATION_NOT_SUPPORTED, "SITUATION-NOT-SUPPORTED",      NULL },
 241 { ISAKMP_NTYPE_INVALID_COOKIE,          "INVALID-COOKIE",               NULL },
 242 { ISAKMP_NTYPE_INVALID_MAJOR_VERSION,   "INVALID-MAJOR-VERSION",        NULL },
 243 { ISAKMP_NTYPE_INVALID_MINOR_VERSION,   "INVALID-MINOR-VERSION",        NULL },
 244 { ISAKMP_NTYPE_INVALID_EXCHANGE_TYPE,   "INVALID-EXCHANGE-TYPE",        NULL },
 245 { ISAKMP_NTYPE_INVALID_FLAGS,           "INVALID-FLAGS",                NULL },
 246 { ISAKMP_NTYPE_INVALID_MESSAGE_ID,      "INVALID-MESSAGE-ID",           NULL },
 247 { ISAKMP_NTYPE_INVALID_PROTOCOL_ID,     "INVALID-PROTOCOL-ID",          NULL },
 248 { ISAKMP_NTYPE_INVALID_SPI,             "INVALID-SPI",                  NULL },
 249 { ISAKMP_NTYPE_INVALID_TRANSFORM_ID,    "INVALID-TRANSFORM-ID",         NULL },
 250 { ISAKMP_NTYPE_ATTRIBUTES_NOT_SUPPORTED, "ATTRIBUTES-NOT-SUPPORTED",    NULL },
 251 { ISAKMP_NTYPE_NO_PROPOSAL_CHOSEN,      "NO-PROPOSAL-CHOSEN",           NULL },
 252 { ISAKMP_NTYPE_BAD_PROPOSAL_SYNTAX,     "BAD-PROPOSAL-SYNTAX",          NULL },
 253 { ISAKMP_NTYPE_PAYLOAD_MALFORMED,       "PAYLOAD-MALFORMED",            NULL },
 254 { ISAKMP_NTYPE_INVALID_KEY_INFORMATION, "INVALID-KEY-INFORMATION",      NULL },
 255 { ISAKMP_NTYPE_INVALID_ID_INFORMATION,  "INVALID-ID-INFORMATION",       NULL },
 256 { ISAKMP_NTYPE_INVALID_CERT_ENCODING,   "INVALID-CERT-ENCODING",        NULL },
 257 { ISAKMP_NTYPE_INVALID_CERTIFICATE,     "INVALID-CERTIFICATE",          NULL },
 258 { ISAKMP_NTYPE_BAD_CERT_REQUEST_SYNTAX, "BAD-CERT-REQUEST-SYNTAX",      NULL },
 259 { ISAKMP_NTYPE_INVALID_CERT_AUTHORITY,  "INVALID-CERT-AUTHORITY",       NULL },
 260 { ISAKMP_NTYPE_INVALID_HASH_INFORMATION, "INVALID-HASH-INFORMATION",    NULL },
 261 { ISAKMP_NTYPE_AUTHENTICATION_FAILED,   "AUTHENTICATION-FAILED",        NULL },
 262 { ISAKMP_NTYPE_INVALID_SIGNATURE,       "INVALID-SIGNATURE",            NULL },
 263 { ISAKMP_NTYPE_ADDRESS_NOTIFICATION,    "ADDRESS-NOTIFICATION",         NULL },
 264 { ISAKMP_NTYPE_NOTIFY_SA_LIFETIME,      "NOTIFY-SA-LIFETIME",           NULL },
 265 { ISAKMP_NTYPE_CERTIFICATE_UNAVAILABLE, "CERTIFICATE-UNAVAILABLE",      NULL },
 266 { ISAKMP_NTYPE_UNSUPPORTED_EXCHANGE_TYPE, "UNSUPPORTED-EXCHANGE-TYPE",  NULL },
 267 { ISAKMP_NTYPE_UNEQUAL_PAYLOAD_LENGTHS, "UNEQUAL-PAYLOAD-LENGTHS",      NULL },
 268 { ISAKMP_NTYPE_CONNECTED,               "CONNECTED",                    NULL },
 269 { ISAKMP_NTYPE_RESPONDER_LIFETIME,      "RESPONDER-LIFETIME",           NULL },
 270 { ISAKMP_NTYPE_REPLAY_STATUS,           "REPLAY-STATUS",                NULL },
 271 { ISAKMP_NTYPE_INITIAL_CONTACT,         "INITIAL-CONTACT",              NULL },
 272 #ifdef ENABLE_HYBRID
 273 { ISAKMP_NTYPE_UNITY_HEARTBEAT,         "HEARTBEAT (Unity)",            NULL },
 274 #endif
 275 { ISAKMP_LOG_RETRY_LIMIT_REACHED,       "RETRY-LIMIT-REACHED",          NULL },
 276 };
 277
 278 char *
 279 s_isakmp_notify_msg(k)
 280         int k;
 281 {
 282         int i;
 283         for (i = 0; i < ARRAYLEN(name_isakmp_notify_msg); i++)
 284                 if (name_isakmp_notify_msg[i].key == k)
 285                         return name_isakmp_notify_msg[i].str;
 286
 287         return num2str(k);
 288 }
 289
 290 static struct ksmap name_isakmp_nptype[] = {
 291 { ISAKMP_NPTYPE_NONE,           "none",         NULL },
 292 { ISAKMP_NPTYPE_SA,             "sa",           NULL },
 293 { ISAKMP_NPTYPE_P,              "prop",         NULL },
 294 { ISAKMP_NPTYPE_T,              "trns",         NULL },
 295 { ISAKMP_NPTYPE_KE,             "ke",           NULL },
 296 { ISAKMP_NPTYPE_ID,             "id",           NULL },
 297 { ISAKMP_NPTYPE_CERT,           "cert",         NULL },
 298 { ISAKMP_NPTYPE_CR,             "cr",           NULL },
 299 { ISAKMP_NPTYPE_HASH,           "hash",         NULL },
 300 { ISAKMP_NPTYPE_SIG,            "sig",          NULL },
 301 { ISAKMP_NPTYPE_NONCE,          "nonce",        NULL },
 302 { ISAKMP_NPTYPE_N,              "notify",       NULL },
 303 { ISAKMP_NPTYPE_D,              "delete",       NULL },
 304 { ISAKMP_NPTYPE_VID,            "vid",          NULL },
 305 { ISAKMP_NPTYPE_ATTR,           "attr",         NULL },
 306 { ISAKMP_NPTYPE_GSS,            "gss id",       NULL },
 307 { ISAKMP_NPTYPE_NATD_RFC,       "nat-d",        NULL },
 308 { ISAKMP_NPTYPE_NATOA_RFC,      "nat-oa",       NULL },
 309 { ISAKMP_NPTYPE_NATD_DRAFT,     "nat-d",        NULL },
 310 { ISAKMP_NPTYPE_NATOA_DRAFT,    "nat-oa",       NULL },
 311 { ISAKMP_NPTYPE_FRAG,           "ike frag",     NULL },
 312 };
 313
 314 char *
 315 s_isakmp_nptype(k)
 316         int k;
 317 {
 318         int i;
 319         for (i = 0; i < ARRAYLEN(name_isakmp_nptype); i++)
 320                 if (name_isakmp_nptype[i].key == k)
 321                         return name_isakmp_nptype[i].str;
 322         return num2str(k);
 323 }
 324
 325 #ifdef ENABLE_HYBRID
 326 /* isakmp_cfg.h / isakmp_unity.h / isakmp_xauth.h */
 327 static struct ksmap name_isakmp_cfg_type[] = {
 328 { INTERNAL_IP4_ADDRESS,         "INTERNAL_IP4_ADDRESS",         NULL },
 329 { INTERNAL_IP4_NETMASK,         "INTERNAL_IP4_NETMASK",         NULL },
 330 { INTERNAL_IP4_DNS,             "INTERNAL_IP4_DNS",             NULL },
 331 { INTERNAL_IP4_NBNS,            "INTERNAL_IP4_NBNS",            NULL },
 332 { INTERNAL_ADDRESS_EXPIRY,      "INTERNAL_ADDRESS_EXPIRY",      NULL },
 333 { INTERNAL_IP4_DHCP,            "INTERNAL_IP4_DHCP",            NULL },
 334 { APPLICATION_VERSION,          "APPLICATION_VERSION",          NULL },
 335 { INTERNAL_IP6_ADDRESS,         "INTERNAL_IP6_ADDRESS",         NULL },
 336 { INTERNAL_IP6_NETMASK,         "INTERNAL_IP6_NETMASK",         NULL },
 337 { INTERNAL_IP6_DNS,             "INTERNAL_IP6_DNS",             NULL },
 338 { INTERNAL_IP6_NBNS,            "INTERNAL_IP6_NBNS",            NULL },
 339 { INTERNAL_IP6_DHCP,            "INTERNAL_IP6_DHCP",            NULL },
 340 { INTERNAL_IP4_SUBNET,          "INTERNAL_IP4_SUBNET",          NULL },
 341 { SUPPORTED_ATTRIBUTES,         "SUPPORTED_ATTRIBUTES",         NULL },
 342 { INTERNAL_IP6_SUBNET,          "INTERNAL_IP6_SUBNET",          NULL },
 343 { XAUTH_TYPE,                   "XAUTH_TYPE",                   NULL },
 344 { XAUTH_USER_NAME,              "XAUTH_USER_NAME",              NULL },
 345 { XAUTH_USER_PASSWORD,          "XAUTH_USER_PASSWORD",          NULL },
 346 { XAUTH_PASSCODE,               "XAUTH_PASSCODE",               NULL },
 347 { XAUTH_MESSAGE,                "XAUTH_MESSAGE",                NULL },
 348 { XAUTH_CHALLENGE,              "XAUTH_CHALLENGE",              NULL },
 349 { XAUTH_DOMAIN,                 "XAUTH_DOMAIN",                 NULL },
 350 { XAUTH_STATUS,                 "XAUTH_STATUS",                 NULL },
 351 { XAUTH_NEXT_PIN,               "XAUTH_NEXT_PIN",               NULL },
 352 { XAUTH_ANSWER,                 "XAUTH_ANSWER",                 NULL },
 353 { UNITY_BANNER,                 "UNITY_BANNER",                 NULL },
 354 { UNITY_SAVE_PASSWD,            "UNITY_SAVE_PASSWD",            NULL },
 355 { UNITY_DEF_DOMAIN,             "UNITY_DEF_DOMAIN",             NULL },
 356 { UNITY_SPLITDNS_NAME,          "UNITY_SPLITDNS_NAME",          NULL },
 357 { UNITY_SPLIT_INCLUDE,          "UNITY_SPLIT_INCLUDE",          NULL },
 358 { UNITY_NATT_PORT,              "UNITY_NATT_PORT",              NULL },
 359 { UNITY_LOCAL_LAN,              "UNITY_LOCAL_LAN",              NULL },
 360 { UNITY_PFS,                    "UNITY_PFS",                    NULL },
 361 { UNITY_FW_TYPE,                "UNITY_FW_TYPE",                NULL },
 362 { UNITY_BACKUP_SERVERS,         "UNITY_BACKUP_SERVERS",         NULL },
 363 { UNITY_DDNS_HOSTNAME,          "UNITY_DDNS_HOSTNAME",          NULL },
 364 };
 365
 366 char *
 367 s_isakmp_cfg_type(k)
 368         int k;
 369 {
 370         int i;
 371         for (i = 0; i < ARRAYLEN(name_isakmp_cfg_type); i++)
 372                 if (name_isakmp_cfg_type[i].key == k)
 373                         return name_isakmp_cfg_type[i].str;
 374         return num2str(k);
 375 }
 376
 377 /* isakmp_cfg.h / isakmp_unity.h / isakmp_xauth.h */
 378 static struct ksmap name_isakmp_cfg_ptype[] = {
 379 { ISAKMP_CFG_ACK,               "mode config ACK",              NULL },
 380 { ISAKMP_CFG_SET,               "mode config SET",              NULL },
 381 { ISAKMP_CFG_REQUEST,           "mode config REQUEST",          NULL },
 382 { ISAKMP_CFG_REPLY,             "mode config REPLY",            NULL },
 383 };
 384
 385 char *
 386 s_isakmp_cfg_ptype(k)
 387         int k;
 388 {
 389         int i;
 390         for (i = 0; i < ARRAYLEN(name_isakmp_cfg_ptype); i++)
 391                 if (name_isakmp_cfg_ptype[i].key == k)
 392                         return name_isakmp_cfg_ptype[i].str;
 393         return num2str(k);
 394 }
 395
 396 #endif
 397
 398 /* ipsec_doi.h */
 399 static struct ksmap name_ipsecdoi_proto[] = {
 400 { IPSECDOI_PROTO_ISAKMP,        "ISAKMP",       s_ipsecdoi_trns_isakmp },
 401 { IPSECDOI_PROTO_IPSEC_AH,      "AH",           s_ipsecdoi_trns_ah },
 402 { IPSECDOI_PROTO_IPSEC_ESP,     "ESP",          s_ipsecdoi_trns_esp },
 403 { IPSECDOI_PROTO_IPCOMP,        "IPCOMP",       s_ipsecdoi_trns_ipcomp },
 404 };
 405
 406 char *
 407 s_ipsecdoi_proto(k)
 408         int k;
 409 {
 410         int i;
 411         for (i = 0; i < ARRAYLEN(name_ipsecdoi_proto); i++)
 412                 if (name_ipsecdoi_proto[i].key == k)
 413                         return name_ipsecdoi_proto[i].str;
 414         return num2str(k);
 415 }
 416
 417 static struct ksmap name_ipsecdoi_trns_isakmp[] = {
 418 { IPSECDOI_KEY_IKE,     "IKE", NULL },
 419 };
 420
 421 char *
 422 s_ipsecdoi_trns_isakmp(k)
 423         int k;
 424 {
 425         int i;
 426         for (i = 0; i < ARRAYLEN(name_ipsecdoi_trns_isakmp); i++)
 427                 if (name_ipsecdoi_trns_isakmp[i].key == k)
 428                         return name_ipsecdoi_trns_isakmp[i].str;
 429         return num2str(k);
 430 }
 431
 432 static struct ksmap name_ipsecdoi_trns_ah[] = {
 433 { IPSECDOI_AH_MD5,      "MD5", NULL },
 434 { IPSECDOI_AH_SHA,      "SHA", NULL },
 435 { IPSECDOI_AH_DES,      "DES", NULL },
 436 { IPSECDOI_AH_SHA256,   "SHA256", NULL },
 437 { IPSECDOI_AH_SHA384,   "SHA384", NULL },
 438 { IPSECDOI_AH_SHA512,   "SHA512", NULL },
 439 };
 440
 441 char *
 442 s_ipsecdoi_trns_ah(k)
 443         int k;
 444 {
 445         int i;
 446         for (i = 0; i < ARRAYLEN(name_ipsecdoi_trns_ah); i++)
 447                 if (name_ipsecdoi_trns_ah[i].key == k)
 448                         return name_ipsecdoi_trns_ah[i].str;
 449         return num2str(k);
 450 }
 451
 452 static struct ksmap name_ipsecdoi_trns_esp[] = {
 453 { IPSECDOI_ESP_DES_IV64,        "DES_IV64",     NULL },
 454 { IPSECDOI_ESP_DES,             "DES",          NULL },
 455 { IPSECDOI_ESP_3DES,            "3DES",         NULL },
 456 { IPSECDOI_ESP_RC5,             "RC5",          NULL },
 457 { IPSECDOI_ESP_IDEA,            "IDEA",         NULL },
 458 { IPSECDOI_ESP_CAST,            "CAST",         NULL },
 459 { IPSECDOI_ESP_BLOWFISH,        "BLOWFISH",     NULL },
 460 { IPSECDOI_ESP_3IDEA,           "3IDEA",        NULL },
 461 { IPSECDOI_ESP_DES_IV32,        "DES_IV32",     NULL },
 462 { IPSECDOI_ESP_RC4,             "RC4",          NULL },
 463 { IPSECDOI_ESP_NULL,            "NULL",         NULL },
 464 { IPSECDOI_ESP_AES,             "AES",          NULL },
 465 { IPSECDOI_ESP_TWOFISH,         "TWOFISH",      NULL },
 466 };
 467
 468 char *
 469 s_ipsecdoi_trns_esp(k)
 470         int k;
 471 {
 472         int i;
 473         for (i = 0; i < ARRAYLEN(name_ipsecdoi_trns_esp); i++)
 474                 if (name_ipsecdoi_trns_esp[i].key == k)
 475                         return name_ipsecdoi_trns_esp[i].str;
 476         return num2str(k);
 477 }
 478
 479 static struct ksmap name_ipsecdoi_trns_ipcomp[] = {
 480 { IPSECDOI_IPCOMP_OUI,          "OUI",          NULL},
 481 { IPSECDOI_IPCOMP_DEFLATE,      "DEFLATE",      NULL},
 482 { IPSECDOI_IPCOMP_LZS,          "LZS",          NULL},
 483 };
 484
 485 char *
 486 s_ipsecdoi_trns_ipcomp(k)
 487         int k;
 488 {
 489         int i;
 490         for (i = 0; i < ARRAYLEN(name_ipsecdoi_trns_ipcomp); i++)
 491                 if (name_ipsecdoi_trns_ipcomp[i].key == k)
 492                         return name_ipsecdoi_trns_ipcomp[i].str;
 493         return num2str(k);
 494 }
 495
 496 char *
 497 s_ipsecdoi_trns(proto, trns)
 498         int proto, trns;
 499 {
 500         int i;
 501         for (i = 0; i < ARRAYLEN(name_ipsecdoi_proto); i++)
 502                 if (name_ipsecdoi_proto[i].key == proto
 503                  && name_ipsecdoi_proto[i].f)
 504                         return (name_ipsecdoi_proto[i].f)(trns);
 505         return num2str(trns);
 506 }
 507
 508 static struct ksmap name_attr_ipsec[] = {
 509 { IPSECDOI_ATTR_SA_LD_TYPE,     "SA Life Type",         s_ipsecdoi_ltype },
 510 { IPSECDOI_ATTR_SA_LD,          "SA Life Duration",     NULL },
 511 { IPSECDOI_ATTR_GRP_DESC,       "Group Description",    NULL },
 512 { IPSECDOI_ATTR_ENC_MODE,       "Encryption Mode",      s_ipsecdoi_encmode },
 513 { IPSECDOI_ATTR_AUTH,           "Authentication Algorithm", s_ipsecdoi_auth },
 514 { IPSECDOI_ATTR_KEY_LENGTH,     "Key Length",           NULL },
 515 { IPSECDOI_ATTR_KEY_ROUNDS,     "Key Rounds",           NULL },
 516 { IPSECDOI_ATTR_COMP_DICT_SIZE, "Compression Dictionary Size",  NULL },
 517 { IPSECDOI_ATTR_COMP_PRIVALG,   "Compression Private Algorithm", NULL },
 518 };
 519
 520 char *
 521 s_ipsecdoi_attr(k)
 522         int k;
 523 {
 524         int i;
 525         for (i = 0; i < ARRAYLEN(name_attr_ipsec); i++)
 526                 if (name_attr_ipsec[i].key == k)
 527                         return name_attr_ipsec[i].str;
 528         return num2str(k);
 529 }
 530
 531 static struct ksmap name_attr_ipsec_ltype[] = {
 532 { IPSECDOI_ATTR_SA_LD_TYPE_SEC, "seconds",      NULL },
 533 { IPSECDOI_ATTR_SA_LD_TYPE_KB,  "kilobytes",    NULL },
 534 };
 535
 536 char *
 537 s_ipsecdoi_ltype(k)
 538         int k;
 539 {
 540         int i;
 541         for (i = 0; i < ARRAYLEN(name_attr_ipsec_ltype); i++)
 542                 if (name_attr_ipsec_ltype[i].key == k)
 543                         return name_attr_ipsec_ltype[i].str;
 544         return num2str(k);
 545 }
 546
 547 static struct ksmap name_attr_ipsec_encmode[] = {
 548 { IPSECDOI_ATTR_ENC_MODE_ANY,           "Any",          NULL },
 549 { IPSECDOI_ATTR_ENC_MODE_TUNNEL,        "Tunnel",       NULL },
 550 { IPSECDOI_ATTR_ENC_MODE_TRNS,          "Transport",    NULL },
 551 { IPSECDOI_ATTR_ENC_MODE_UDPTUNNEL_RFC, "UDP-Tunnel",   NULL },
 552 { IPSECDOI_ATTR_ENC_MODE_UDPTRNS_RFC,   "UDP-Transport",        NULL },
 553 { IPSECDOI_ATTR_ENC_MODE_UDPTUNNEL_DRAFT,       "UDP-Tunnel",   NULL },
 554 { IPSECDOI_ATTR_ENC_MODE_UDPTRNS_DRAFT, "UDP-Transport",        NULL },
 555 };
 556
 557 char *
 558 s_ipsecdoi_encmode(k)
 559         int k;
 560 {
 561         int i;
 562         for (i = 0; i < ARRAYLEN(name_attr_ipsec_encmode); i++)
 563                 if (name_attr_ipsec_encmode[i].key == k)
 564                         return name_attr_ipsec_encmode[i].str;
 565         return num2str(k);
 566 }
 567
 568 static struct ksmap name_attr_ipsec_auth[] = {
 569 { IPSECDOI_ATTR_AUTH_HMAC_MD5,          "hmac-md5",     NULL },
 570 { IPSECDOI_ATTR_AUTH_HMAC_SHA1,         "hmac-sha",     NULL },
 571 { IPSECDOI_ATTR_AUTH_HMAC_SHA2_256,     "hmac-sha256",  NULL },
 572 { IPSECDOI_ATTR_AUTH_HMAC_SHA2_384,     "hmac-sha384",  NULL },
 573 { IPSECDOI_ATTR_AUTH_HMAC_SHA2_512,     "hmac-sha512",  NULL },
 574 { IPSECDOI_ATTR_AUTH_DES_MAC,           "des-mac",      NULL },
 575 { IPSECDOI_ATTR_AUTH_KPDK,              "kpdk",         NULL },
 576 };
 577
 578 char *
 579 s_ipsecdoi_auth(k)
 580         int k;
 581 {
 582         int i;
 583         for (i = 0; i < ARRAYLEN(name_attr_ipsec_auth); i++)
 584                 if (name_attr_ipsec_auth[i].key == k)
 585                         return name_attr_ipsec_auth[i].str;
 586         return num2str(k);
 587 }
 588
 589 char *
 590 s_ipsecdoi_attr_v(type, val)
 591         int type, val;
 592 {
 593         int i;
 594         for (i = 0; i < ARRAYLEN(name_attr_ipsec); i++)
 595                 if (name_attr_ipsec[i].key == type
 596                  && name_attr_ipsec[i].f)
 597                         return (name_attr_ipsec[i].f)(val);
 598         return num2str(val);
 599 }
 600
 601 static struct ksmap name_ipsecdoi_ident[] = {
 602 { IPSECDOI_ID_IPV4_ADDR,        "IPv4_address", NULL },
 603 { IPSECDOI_ID_FQDN,             "FQDN",         NULL },
 604 { IPSECDOI_ID_USER_FQDN,        "User_FQDN",    NULL },
 605 { IPSECDOI_ID_IPV4_ADDR_SUBNET, "IPv4_subnet",  NULL },
 606 { IPSECDOI_ID_IPV6_ADDR,        "IPv6_address", NULL },
 607 { IPSECDOI_ID_IPV6_ADDR_SUBNET, "IPv6_subnet",  NULL },
 608 { IPSECDOI_ID_IPV4_ADDR_RANGE,  "IPv4_address_range",   NULL },
 609 { IPSECDOI_ID_IPV6_ADDR_RANGE,  "IPv6_address_range",   NULL },
 610 { IPSECDOI_ID_DER_ASN1_DN,      "DER_ASN1_DN",  NULL },
 611 { IPSECDOI_ID_DER_ASN1_GN,      "DER_ASN1_GN",  NULL },
 612 { IPSECDOI_ID_KEY_ID,           "KEY_ID",       NULL },
 613 };
 614
 615 char *
 616 s_ipsecdoi_ident(k)
 617         int k;
 618 {
 619         int i;
 620         for (i = 0; i < ARRAYLEN(name_ipsecdoi_ident); i++)
 621                 if (name_ipsecdoi_ident[i].key == k)
 622                         return name_ipsecdoi_ident[i].str;
 623         return num2str(k);
 624 }
 625
 626 /* oakley.h */
 627 static struct ksmap name_oakley_attr[] = {
 628 { OAKLEY_ATTR_ENC_ALG,          "Encryption Algorithm", s_attr_isakmp_enc },
 629 { OAKLEY_ATTR_HASH_ALG,         "Hash Algorithm",       s_attr_isakmp_hash },
 630 { OAKLEY_ATTR_AUTH_METHOD,      "Authentication Method", s_oakley_attr_method },
 631 { OAKLEY_ATTR_GRP_DESC,         "Group Description",    s_attr_isakmp_desc },
 632 { OAKLEY_ATTR_GRP_TYPE,         "Group Type",           s_attr_isakmp_group },
 633 { OAKLEY_ATTR_GRP_PI,           "Group Prime/Irreducible Polynomial",   NULL },
 634 { OAKLEY_ATTR_GRP_GEN_ONE,      "Group Generator One",  NULL },
 635 { OAKLEY_ATTR_GRP_GEN_TWO,      "Group Generator Two",  NULL },
 636 { OAKLEY_ATTR_GRP_CURVE_A,      "Group Curve A",        NULL },
 637 { OAKLEY_ATTR_GRP_CURVE_B,      "Group Curve B",        NULL },
 638 { OAKLEY_ATTR_SA_LD_TYPE,       "Life Type",            s_attr_isakmp_ltype },
 639 { OAKLEY_ATTR_SA_LD,            "Life Duration",        NULL },
 640 { OAKLEY_ATTR_PRF,              "PRF",                  NULL },
 641 { OAKLEY_ATTR_KEY_LEN,          "Key Length",           NULL },
 642 { OAKLEY_ATTR_FIELD_SIZE,       "Field Size",           NULL },
 643 { OAKLEY_ATTR_GRP_ORDER,        "Group Order",          NULL },
 644 { OAKLEY_ATTR_BLOCK_SIZE,       "Block Size",           NULL },
 645 { OAKLEY_ATTR_GSS_ID,           "GSS-API endpoint name",NULL },
 646 };
 647
 648 char *
 649 s_oakley_attr(k)
 650         int k;
 651 {
 652         int i;
 653         for (i = 0; i < ARRAYLEN(name_oakley_attr); i++)
 654                 if (name_oakley_attr[i].key == k)
 655                         return name_oakley_attr[i].str;
 656         return num2str(k);
 657 }
 658
 659 static struct ksmap name_attr_isakmp_enc[] = {
 660 { OAKLEY_ATTR_ENC_ALG_DES,      "DES-CBC",              NULL },
 661 { OAKLEY_ATTR_ENC_ALG_IDEA,     "IDEA-CBC",             NULL },
 662 { OAKLEY_ATTR_ENC_ALG_BLOWFISH, "Blowfish-CBC",         NULL },
 663 { OAKLEY_ATTR_ENC_ALG_RC5,      "RC5-R16-B64-CBC",      NULL },
 664 { OAKLEY_ATTR_ENC_ALG_3DES,     "3DES-CBC",             NULL },
 665 { OAKLEY_ATTR_ENC_ALG_CAST,     "CAST-CBC",             NULL },
 666 { OAKLEY_ATTR_ENC_ALG_AES,      "AES-CBC",              NULL },
 667 };
 668
 669 char *
 670 s_attr_isakmp_enc(k)
 671         int k;
 672 {
 673         int i;
 674         for (i = 0; i < ARRAYLEN(name_attr_isakmp_enc); i++)
 675                 if (name_attr_isakmp_enc[i].key == k)
 676                         return name_attr_isakmp_enc[i].str;
 677         return num2str(k);
 678 }
 679
 680 static struct ksmap name_attr_isakmp_hash[] = {
 681 { OAKLEY_ATTR_HASH_ALG_MD5,     "MD5",          NULL },
 682 { OAKLEY_ATTR_HASH_ALG_SHA,     "SHA",          NULL },
 683 { OAKLEY_ATTR_HASH_ALG_TIGER,   "Tiger",        NULL },
 684 { OAKLEY_ATTR_HASH_ALG_SHA2_256,"SHA256",       NULL },
 685 { OAKLEY_ATTR_HASH_ALG_SHA2_384,"SHA384",       NULL },
 686 { OAKLEY_ATTR_HASH_ALG_SHA2_512,"SHA512",       NULL },
 687 };
 688
 689 char *
 690 s_attr_isakmp_hash(k)
 691         int k;
 692 {
 693         int i;
 694         for (i = 0; i < ARRAYLEN(name_attr_isakmp_hash); i++)
 695                 if (name_attr_isakmp_hash[i].key == k)
 696                         return name_attr_isakmp_hash[i].str;
 697         return num2str(k);
 698 }
 699
 700 static struct ksmap name_attr_isakmp_method[] = {
 701 { OAKLEY_ATTR_AUTH_METHOD_PSKEY,                "pre-shared key",       NULL },
 702 { OAKLEY_ATTR_AUTH_METHOD_DSSSIG,               "DSS signatures",       NULL },
 703 { OAKLEY_ATTR_AUTH_METHOD_RSASIG,               "RSA signatures",       NULL },
 704 { OAKLEY_ATTR_AUTH_METHOD_RSAENC,               "Encryption with RSA",  NULL },
 705 { OAKLEY_ATTR_AUTH_METHOD_RSAREV,               "Revised encryption with RSA",  NULL },
 706 { OAKLEY_ATTR_AUTH_METHOD_EGENC,                "Encryption with El-Gamal",     NULL },
 707 { OAKLEY_ATTR_AUTH_METHOD_EGREV,                "Revised encryption with El-Gamal",     NULL },
 708 #ifdef ENABLE_HYBRID
 709 { OAKLEY_ATTR_AUTH_METHOD_HYBRID_DSS_R,         "Hybrid DSS server",    NULL },
 710 { OAKLEY_ATTR_AUTH_METHOD_HYBRID_RSA_R,         "Hybrid RSA server",    NULL },
 711 { OAKLEY_ATTR_AUTH_METHOD_HYBRID_DSS_I,         "Hybrid DSS client",    NULL },
 712 { OAKLEY_ATTR_AUTH_METHOD_HYBRID_RSA_I,         "Hybrid RSA client",    NULL },
 713 { OAKLEY_ATTR_AUTH_METHOD_XAUTH_PSKEY_I,        "XAuth pskey client",   NULL },
 714 { OAKLEY_ATTR_AUTH_METHOD_XAUTH_PSKEY_R,        "XAuth pskey server",   NULL },
 715 { OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSASIG_I,       "XAuth RSASIG client",  NULL },
 716 { OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSASIG_R,       "XAuth RSASIG server",  NULL },
 717 #endif
 718 };
 719
 720 char *
 721 s_oakley_attr_method(k)
 722         int k;
 723 {
 724         int i;
 725         for (i = 0; i < ARRAYLEN(name_attr_isakmp_method); i++)
 726                 if (name_attr_isakmp_method[i].key == k)
 727                         return name_attr_isakmp_method[i].str;
 728         return num2str(k);
 729 }
 730
 731 static struct ksmap name_attr_isakmp_desc[] = {
 732 { OAKLEY_ATTR_GRP_DESC_MODP768,         "768-bit MODP group",   NULL },
 733 { OAKLEY_ATTR_GRP_DESC_MODP1024,        "1024-bit MODP group",  NULL },
 734 { OAKLEY_ATTR_GRP_DESC_EC2N155,         "EC2N group on GP[2^155]",      NULL },
 735 { OAKLEY_ATTR_GRP_DESC_EC2N185,         "EC2N group on GP[2^185]",      NULL },
 736 { OAKLEY_ATTR_GRP_DESC_MODP1536,        "1536-bit MODP group",  NULL },
 737 { OAKLEY_ATTR_GRP_DESC_MODP2048,        "2048-bit MODP group",  NULL },
 738 { OAKLEY_ATTR_GRP_DESC_MODP3072,        "3072-bit MODP group",  NULL },
 739 { OAKLEY_ATTR_GRP_DESC_MODP4096,        "4096-bit MODP group",  NULL },
 740 { OAKLEY_ATTR_GRP_DESC_MODP6144,        "6144-bit MODP group",  NULL },
 741 { OAKLEY_ATTR_GRP_DESC_MODP8192,        "8192-bit MODP group",  NULL },
 742 };
 743
 744 char *
 745 s_attr_isakmp_desc(k)
 746         int k;
 747 {
 748         int i;
 749         for (i = 0; i < ARRAYLEN(name_attr_isakmp_desc); i++)
 750                 if (name_attr_isakmp_desc[i].key == k)
 751                         return name_attr_isakmp_desc[i].str;
 752         return num2str(k);
 753 }
 754
 755 static struct ksmap name_attr_isakmp_group[] = {
 756 { OAKLEY_ATTR_GRP_TYPE_MODP,    "MODP", NULL },
 757 { OAKLEY_ATTR_GRP_TYPE_ECP,     "ECP",  NULL },
 758 { OAKLEY_ATTR_GRP_TYPE_EC2N,    "EC2N", NULL },
 759 };
 760
 761 char *
 762 s_attr_isakmp_group(k)
 763         int k;
 764 {
 765         int i;
 766         for (i = 0; i < ARRAYLEN(name_attr_isakmp_group); i++)
 767                 if (name_attr_isakmp_group[i].key == k)
 768                         return name_attr_isakmp_group[i].str;
 769         return num2str(k);
 770 }
 771
 772 static struct ksmap name_attr_isakmp_ltype[] = {
 773 { OAKLEY_ATTR_SA_LD_TYPE_SEC,   "seconds",      NULL },
 774 { OAKLEY_ATTR_SA_LD_TYPE_KB,    "kilobytes",    NULL },
 775 };
 776
 777 char *
 778 s_attr_isakmp_ltype(k)
 779         int k;
 780 {
 781         int i;
 782         for (i = 0; i < ARRAYLEN(name_attr_isakmp_ltype); i++)
 783                 if (name_attr_isakmp_ltype[i].key == k)
 784                         return name_attr_isakmp_ltype[i].str;
 785         return num2str(k);
 786 }
 787
 788 char *
 789 s_oakley_attr_v(type, val)
 790         int type, val;
 791 {
 792         int i;
 793         for (i = 0; i < ARRAYLEN(name_oakley_attr); i++)
 794                 if (name_oakley_attr[i].key == type
 795                  && name_oakley_attr[i].f)
 796                         return (name_oakley_attr[i].f)(val);
 797         return num2str(val);
 798 }
 799
 800 /* netinet6/ipsec.h */
 801 static struct ksmap name_ipsec_level[] = {
 802 { IPSEC_LEVEL_USE,      "use",          NULL },
 803 { IPSEC_LEVEL_REQUIRE,  "require",      NULL },
 804 { IPSEC_LEVEL_UNIQUE,   "unique",       NULL },
 805 };
 806
 807 char *
 808 s_ipsec_level(k)
 809         int k;
 810 {
 811         int i;
 812         for (i = 0; i < ARRAYLEN(name_ipsec_level); i++)
 813                 if (name_ipsec_level[i].key == k)
 814                         return name_ipsec_level[i].str;
 815         return num2str(k);
 816 }
 817
 818 static struct ksmap name_algclass[] = {
 819 { algclass_ipsec_enc,   "ipsec enc",    s_ipsecdoi_trns_esp },
 820 { algclass_ipsec_auth,  "ipsec auth",   s_ipsecdoi_trns_ah },
 821 { algclass_ipsec_comp,  "ipsec comp",   s_ipsecdoi_trns_ipcomp },
 822 { algclass_isakmp_enc,  "isakmp enc",   s_attr_isakmp_enc },
 823 { algclass_isakmp_hash, "isakmp hash",  s_attr_isakmp_hash },
 824 { algclass_isakmp_dh,   "isakmp dh",    s_attr_isakmp_desc },
 825 { algclass_isakmp_ameth, "isakmp auth method",  s_oakley_attr_method },
 826 };
 827
 828 char *
 829 s_algclass(k)
 830         int k;
 831 {
 832         int i;
 833         for (i = 0; i < ARRAYLEN(name_algclass); i++)
 834                 if (name_algclass[i].key == k)
 835                         return name_algclass[i].str;
 836         return num2str(k);
 837 }
 838
 839 char *
 840 s_algtype(class, n)
 841         int class, n;
 842 {
 843         int i;
 844         for (i = 0; i < ARRAYLEN(name_algclass); i++)
 845                 if (name_algclass[i].key == class
 846                  && name_algclass[i].f)
 847                         return (name_algclass[i].f)(n);
 848         return num2str(n);
 849 }
 850
 851 /* pfkey.h */
 852 static struct ksmap name_pfkey_type[] = {
 853 { SADB_GETSPI,          "GETSPI",       NULL },
 854 { SADB_UPDATE,          "UPDATE",       NULL },
 855 { SADB_ADD,             "ADD",          NULL },
 856 { SADB_DELETE,          "DELETE",       NULL },
 857 { SADB_GET,             "GET",          NULL },
 858 { SADB_ACQUIRE,         "ACQUIRE",      NULL },
 859 { SADB_REGISTER,        "REGISTER",     NULL },
 860 { SADB_EXPIRE,          "EXPIRE",       NULL },
 861 { SADB_FLUSH,           "FLUSH",        NULL },
 862 { SADB_DUMP,            "DUMP",         NULL },
 863 { SADB_X_PROMISC,       "X_PROMISC",    NULL },
 864 { SADB_X_PCHANGE,       "X_PCHANGE",    NULL },
 865 { SADB_X_SPDUPDATE,     "X_SPDUPDATE",  NULL },
 866 { SADB_X_SPDADD,        "X_SPDADD",     NULL },
 867 { SADB_X_SPDDELETE,     "X_SPDDELETE",  NULL },
 868 { SADB_X_SPDGET,        "X_SPDGET",     NULL },
 869 { SADB_X_SPDACQUIRE,    "X_SPDACQUIRE", NULL },
 870 { SADB_X_SPDDUMP,       "X_SPDDUMP",    NULL },
 871 { SADB_X_SPDFLUSH,      "X_SPDFLUSH",   NULL },
 872 { SADB_X_SPDSETIDX,     "X_SPDSETIDX",  NULL },
 873 { SADB_X_SPDEXPIRE,     "X_SPDEXPIRE",  NULL },
 874 { SADB_X_SPDDELETE2,    "X_SPDDELETE2", NULL },
 875 { SADB_GETSASTAT, "X_GETSASTAT", NULL },
 876 #ifdef SADB_X_NAT_T_NEW_MAPPING
 877 { SADB_X_NAT_T_NEW_MAPPING, "X_NAT_T_NEW_MAPPING", NULL },
 878 #endif
 879 #ifdef SADB_X_MIGRATE
 880 { SADB_X_MIGRATE,       "X_MIGRATE",    NULL },
 881 #endif
 882 };
 883
 884 char *
 885 s_pfkey_type(k)
 886         int k;
 887 {
 888         int i;
 889         for (i = 0; i < ARRAYLEN(name_pfkey_type); i++)
 890                 if (name_pfkey_type[i].key == k)
 891                         return name_pfkey_type[i].str;
 892         return num2str(k);
 893 }
 894
 895 static struct ksmap name_pfkey_satype[] = {
 896 { SADB_SATYPE_UNSPEC,   "UNSPEC",       NULL },
 897 { SADB_SATYPE_AH,       "AH",           NULL },
 898 { SADB_SATYPE_ESP,      "ESP",          NULL },
 899 { SADB_SATYPE_RSVP,     "RSVP",         NULL },
 900 { SADB_SATYPE_OSPFV2,   "OSPFV2",       NULL },
 901 { SADB_SATYPE_RIPV2,    "RIPV2",        NULL },
 902 { SADB_SATYPE_MIP,      "MIP",          NULL },
 903 { SADB_X_SATYPE_IPCOMP, "IPCOMP",       NULL },
 904 };
 905
 906 char *
 907 s_pfkey_satype(k)
 908         int k;
 909 {
 910         int i;
 911         for (i = 0; i < ARRAYLEN(name_pfkey_satype); i++)
 912                 if (name_pfkey_satype[i].key == k)
 913                         return name_pfkey_satype[i].str;
 914         return num2str(k);
 915 }
 916
 917 static struct ksmap name_direction[] = {
 918 { IPSEC_DIR_INBOUND,    "in",   NULL },
 919 { IPSEC_DIR_OUTBOUND,   "out",  NULL },
 920 #ifdef HAVE_POLICY_FWD
 921 { IPSEC_DIR_FWD,        "fwd",  NULL },
 922 #endif
 923 };
 924
 925 char *
 926 s_direction(k)
 927         int k;
 928 {
 929         int i;
 930         for (i = 0; i < ARRAYLEN(name_direction); i++)
 931                 if (name_direction[i].key == k)
 932                         return name_direction[i].str;
 933         return num2str(k);
 934 }
 935
 936 char *
 937 s_proto(k)
 938         int k;
 939 {
 940         switch (k) {
 941         case IPPROTO_ICMP:
 942                 return "icmp";
 943         case IPPROTO_TCP:
 944                 return "tcp";
 945         case IPPROTO_UDP:
 946                 return "udp";
 947         case IPPROTO_ICMPV6:
 948                 return "icmpv6";
 949         case IPSEC_ULPROTO_ANY:
 950                 return "any";
 951         }
 952
 953         return num2str(k);
 954 }
 955
 956 char *
 957 s_doi(int k)
 958 {
 959   switch (k) {
 960     case IPSEC_DOI:
 961       return "ipsec_doi";
 962     default:
 963       return num2str(k);
 964   }
 965 }
 966
 967 char *
 968 s_etype (int k)
 969 {
 970   switch (k) {
 971     case ISAKMP_ETYPE_NONE:
 972       return "_none";
 973     case ISAKMP_ETYPE_BASE:
 974       return "base";
 975     case ISAKMP_ETYPE_IDENT:
 976       return "main";
 977     case ISAKMP_ETYPE_AUTH:
 978       return "_auth";
 979     case ISAKMP_ETYPE_AGG:
 980       return "aggressive";
 981     case ISAKMP_ETYPE_INFO:
 982       return "_info";
 983     case ISAKMP_ETYPE_QUICK:
 984       return "_quick";
 985     case ISAKMP_ETYPE_NEWGRP:
 986       return "_newgrp";
 987     case ISAKMP_ETYPE_ACKINFO:
 988       return "_ackinfo";
 989     default:
 990       return num2str(k);
 991   }
 992 }
 993
 994 char *
 995 s_idtype (int k)
 996 {
 997   switch (k) {
 998     case IDTYPE_FQDN:
 999       return "fqdn";
1000     case IDTYPE_USERFQDN:
1001       return "user_fqdn";
1002     case IDTYPE_KEYID:
1003       return "keyid";
1004     case IDTYPE_ADDRESS:
1005       return "address";
1006     case IDTYPE_ASN1DN:
1007       return "asn1dn";
1008     default:
1009       return num2str(k);
1010   }
1011 }
1012
1013 char *
1014 s_switch (int k)
1015 {
1016   switch (k) {
1017     case FALSE:
1018       return "off";
1019     case TRUE:
1020       return "on";
1021     default:
1022       return num2str(k);
1023   }
1024 }