key_debug.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $FreeBSD$       */
    2 /*      $KAME: key_debug.c,v 1.26 2001/06/27 10:46:50 sakane Exp $      */
    3 
    4 /*-
    5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the project nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  */
   32 
   33 #ifdef _KERNEL
   34 #include "opt_inet.h"
   35 #include "opt_inet6.h"
   36 #include "opt_ipsec.h"
   37 #endif
   38 
   39 #include <sys/types.h>
   40 #include <sys/param.h>
   41 #ifdef _KERNEL
   42 #include <sys/systm.h>
   43 #include <sys/mbuf.h>
   44 #include <sys/queue.h>
   45 #endif
   46 #include <sys/socket.h>
   47 
   48 #include <net/vnet.h>
   49 
   50 #include <netipsec/key_var.h>
   51 #include <netipsec/key_debug.h>
   52 
   53 #include <netinet/in.h>
   54 #include <netipsec/ipsec.h>
   55 #ifdef _KERNEL
   56 #include <netipsec/keydb.h>
   57 #endif
   58 
   59 #ifndef _KERNEL
   60 #include <ctype.h>
   61 #include <stdio.h>
   62 #include <stdlib.h>
   63 #endif /* !_KERNEL */
   64 
   65 static void kdebug_sadb_prop(struct sadb_ext *);
   66 static void kdebug_sadb_identity(struct sadb_ext *);
   67 static void kdebug_sadb_supported(struct sadb_ext *);
   68 static void kdebug_sadb_lifetime(struct sadb_ext *);
   69 static void kdebug_sadb_sa(struct sadb_ext *);
   70 static void kdebug_sadb_address(struct sadb_ext *);
   71 static void kdebug_sadb_key(struct sadb_ext *);
   72 static void kdebug_sadb_x_sa2(struct sadb_ext *);
   73 
   74 #ifdef _KERNEL
   75 static void kdebug_secreplay(struct secreplay *);
   76 #endif
   77 
   78 #ifndef _KERNEL
   79 #define panic(fmt, ...) { printf(fmt, ## __VA_ARGS__); exit(-1); }
   80 #endif
   81 
   82 /* NOTE: host byte order */
   83 
   84 /* %%%: about struct sadb_msg */
   85 void
   86 kdebug_sadb(struct sadb_msg *base)
   87 {
   88         struct sadb_ext *ext;
   89         int tlen, extlen;
   90 
   91         /* sanity check */
   92         if (base == NULL)
   93                 panic("%s: NULL pointer was passed.\n", __func__);
   94 
   95         printf("sadb_msg{ version=%u type=%u errno=%u satype=%u\n",
   96             base->sadb_msg_version, base->sadb_msg_type,
   97             base->sadb_msg_errno, base->sadb_msg_satype);
   98         printf("  len=%u reserved=%u seq=%u pid=%u\n",
   99             base->sadb_msg_len, base->sadb_msg_reserved,
  100             base->sadb_msg_seq, base->sadb_msg_pid);
  101 
  102         tlen = PFKEY_UNUNIT64(base->sadb_msg_len) - sizeof(struct sadb_msg);
  103         ext = (struct sadb_ext *)((caddr_t)base + sizeof(struct sadb_msg));
  104 
  105         while (tlen > 0) {
  106                 printf("sadb_ext{ len=%u type=%u }\n",
  107                     ext->sadb_ext_len, ext->sadb_ext_type);
  108 
  109                 if (ext->sadb_ext_len == 0) {
  110                         printf("%s: invalid ext_len=0 was passed.\n", __func__);
  111                         return;
  112                 }
  113                 if (ext->sadb_ext_len > tlen) {
  114                         printf("%s: ext_len too big (%u > %u).\n",
  115                                 __func__, ext->sadb_ext_len, tlen);
  116                         return;
  117                 }
  118 
  119                 switch (ext->sadb_ext_type) {
  120                 case SADB_EXT_SA:
  121                         kdebug_sadb_sa(ext);
  122                         break;
  123                 case SADB_EXT_LIFETIME_CURRENT:
  124                 case SADB_EXT_LIFETIME_HARD:
  125                 case SADB_EXT_LIFETIME_SOFT:
  126                         kdebug_sadb_lifetime(ext);
  127                         break;
  128                 case SADB_EXT_ADDRESS_SRC:
  129                 case SADB_EXT_ADDRESS_DST:
  130                 case SADB_EXT_ADDRESS_PROXY:
  131                         kdebug_sadb_address(ext);
  132                         break;
  133                 case SADB_EXT_KEY_AUTH:
  134                 case SADB_EXT_KEY_ENCRYPT:
  135                         kdebug_sadb_key(ext);
  136                         break;
  137                 case SADB_EXT_IDENTITY_SRC:
  138                 case SADB_EXT_IDENTITY_DST:
  139                         kdebug_sadb_identity(ext);
  140                         break;
  141                 case SADB_EXT_SENSITIVITY:
  142                         break;
  143                 case SADB_EXT_PROPOSAL:
  144                         kdebug_sadb_prop(ext);
  145                         break;
  146                 case SADB_EXT_SUPPORTED_AUTH:
  147                 case SADB_EXT_SUPPORTED_ENCRYPT:
  148                         kdebug_sadb_supported(ext);
  149                         break;
  150                 case SADB_EXT_SPIRANGE:
  151                 case SADB_X_EXT_KMPRIVATE:
  152                         break;
  153                 case SADB_X_EXT_POLICY:
  154                         kdebug_sadb_x_policy(ext);
  155                         break;
  156                 case SADB_X_EXT_SA2:
  157                         kdebug_sadb_x_sa2(ext);
  158                         break;
  159                 default:
  160                         printf("%s: invalid ext_type %u\n", __func__,
  161                             ext->sadb_ext_type);
  162                         return;
  163                 }
  164 
  165                 extlen = PFKEY_UNUNIT64(ext->sadb_ext_len);
  166                 tlen -= extlen;
  167                 ext = (struct sadb_ext *)((caddr_t)ext + extlen);
  168         }
  169 
  170         return;
  171 }
  172 
  173 static void
  174 kdebug_sadb_prop(struct sadb_ext *ext)
  175 {
  176         struct sadb_prop *prop = (struct sadb_prop *)ext;
  177         struct sadb_comb *comb;
  178         int len;
  179 
  180         /* sanity check */
  181         if (ext == NULL)
  182                 panic("%s: NULL pointer was passed.\n", __func__);
  183 
  184         len = (PFKEY_UNUNIT64(prop->sadb_prop_len) - sizeof(*prop))
  185                 / sizeof(*comb);
  186         comb = (struct sadb_comb *)(prop + 1);
  187         printf("sadb_prop{ replay=%u\n", prop->sadb_prop_replay);
  188 
  189         while (len--) {
  190                 printf("sadb_comb{ auth=%u encrypt=%u "
  191                         "flags=0x%04x reserved=0x%08x\n",
  192                         comb->sadb_comb_auth, comb->sadb_comb_encrypt,
  193                         comb->sadb_comb_flags, comb->sadb_comb_reserved);
  194 
  195                 printf("  auth_minbits=%u auth_maxbits=%u "
  196                         "encrypt_minbits=%u encrypt_maxbits=%u\n",
  197                         comb->sadb_comb_auth_minbits,
  198                         comb->sadb_comb_auth_maxbits,
  199                         comb->sadb_comb_encrypt_minbits,
  200                         comb->sadb_comb_encrypt_maxbits);
  201 
  202                 printf("  soft_alloc=%u hard_alloc=%u "
  203                         "soft_bytes=%lu hard_bytes=%lu\n",
  204                         comb->sadb_comb_soft_allocations,
  205                         comb->sadb_comb_hard_allocations,
  206                         (unsigned long)comb->sadb_comb_soft_bytes,
  207                         (unsigned long)comb->sadb_comb_hard_bytes);
  208 
  209                 printf("  soft_alloc=%lu hard_alloc=%lu "
  210                         "soft_bytes=%lu hard_bytes=%lu }\n",
  211                         (unsigned long)comb->sadb_comb_soft_addtime,
  212                         (unsigned long)comb->sadb_comb_hard_addtime,
  213                         (unsigned long)comb->sadb_comb_soft_usetime,
  214                         (unsigned long)comb->sadb_comb_hard_usetime);
  215                 comb++;
  216         }
  217         printf("}\n");
  218 
  219         return;
  220 }
  221 
  222 static void
  223 kdebug_sadb_identity(struct sadb_ext *ext)
  224 {
  225         struct sadb_ident *id = (struct sadb_ident *)ext;
  226         int len;
  227 
  228         /* sanity check */
  229         if (ext == NULL)
  230                 panic("%s: NULL pointer was passed.\n", __func__);
  231 
  232         len = PFKEY_UNUNIT64(id->sadb_ident_len) - sizeof(*id);
  233         printf("sadb_ident_%s{",
  234             id->sadb_ident_exttype == SADB_EXT_IDENTITY_SRC ? "src" : "dst");
  235         switch (id->sadb_ident_type) {
  236         default:
  237                 printf(" type=%d id=%lu",
  238                         id->sadb_ident_type, (u_long)id->sadb_ident_id);
  239                 if (len) {
  240 #ifdef _KERNEL
  241                         ipsec_hexdump((caddr_t)(id + 1), len); /*XXX cast ?*/
  242 #else
  243                         char *p, *ep;
  244                         printf("\n  str=\"");
  245                         p = (char *)(id + 1);
  246                         ep = p + len;
  247                         for (/*nothing*/; *p && p < ep; p++) {
  248                                 if (isprint(*p))
  249                                         printf("%c", *p & 0xff);
  250                                 else
  251                                         printf("\\%03o", *p & 0xff);
  252                         }
  253 #endif
  254                         printf("\"");
  255                 }
  256                 break;
  257         }
  258 
  259         printf(" }\n");
  260 
  261         return;
  262 }
  263 
  264 static void
  265 kdebug_sadb_supported(struct sadb_ext *ext)
  266 {
  267         struct sadb_supported *sup = (struct sadb_supported *)ext;
  268         struct sadb_alg *alg;
  269         int len;
  270 
  271         /* sanity check */
  272         if (ext == NULL)
  273                 panic("%s: NULL pointer was passed.\n", __func__);
  274 
  275         len = (PFKEY_UNUNIT64(sup->sadb_supported_len) - sizeof(*sup))
  276                 / sizeof(*alg);
  277         alg = (struct sadb_alg *)(sup + 1);
  278         printf("sadb_sup{\n");
  279         while (len--) {
  280                 printf("  { id=%d ivlen=%d min=%d max=%d }\n",
  281                         alg->sadb_alg_id, alg->sadb_alg_ivlen,
  282                         alg->sadb_alg_minbits, alg->sadb_alg_maxbits);
  283                 alg++;
  284         }
  285         printf("}\n");
  286 
  287         return;
  288 }
  289 
  290 static void
  291 kdebug_sadb_lifetime(struct sadb_ext *ext)
  292 {
  293         struct sadb_lifetime *lft = (struct sadb_lifetime *)ext;
  294 
  295         /* sanity check */
  296         if (ext == NULL)
  297                 panic("%s: NULL pointer was passed.\n", __func__);
  298 
  299         printf("sadb_lifetime{ alloc=%u, bytes=%u\n",
  300                 lft->sadb_lifetime_allocations,
  301                 (u_int32_t)lft->sadb_lifetime_bytes);
  302         printf("  addtime=%u, usetime=%u }\n",
  303                 (u_int32_t)lft->sadb_lifetime_addtime,
  304                 (u_int32_t)lft->sadb_lifetime_usetime);
  305 
  306         return;
  307 }
  308 
  309 static void
  310 kdebug_sadb_sa(struct sadb_ext *ext)
  311 {
  312         struct sadb_sa *sa = (struct sadb_sa *)ext;
  313 
  314         /* sanity check */
  315         if (ext == NULL)
  316                 panic("%s: NULL pointer was passed.\n", __func__);
  317 
  318         printf("sadb_sa{ spi=%u replay=%u state=%u\n",
  319             (u_int32_t)ntohl(sa->sadb_sa_spi), sa->sadb_sa_replay,
  320             sa->sadb_sa_state);
  321         printf("  auth=%u encrypt=%u flags=0x%08x }\n",
  322             sa->sadb_sa_auth, sa->sadb_sa_encrypt, sa->sadb_sa_flags);
  323 
  324         return;
  325 }
  326 
  327 static void
  328 kdebug_sadb_address(struct sadb_ext *ext)
  329 {
  330         struct sadb_address *addr = (struct sadb_address *)ext;
  331 
  332         /* sanity check */
  333         if (ext == NULL)
  334                 panic("%s: NULL pointer was passed.\n", __func__);
  335 
  336         printf("sadb_address{ proto=%u prefixlen=%u reserved=0x%02x%02x }\n",
  337             addr->sadb_address_proto, addr->sadb_address_prefixlen,
  338             ((u_char *)&addr->sadb_address_reserved)[0],
  339             ((u_char *)&addr->sadb_address_reserved)[1]);
  340 
  341         kdebug_sockaddr((struct sockaddr *)((caddr_t)ext + sizeof(*addr)));
  342 
  343         return;
  344 }
  345 
  346 static void
  347 kdebug_sadb_key(struct sadb_ext *ext)
  348 {
  349         struct sadb_key *key = (struct sadb_key *)ext;
  350 
  351         /* sanity check */
  352         if (ext == NULL)
  353                 panic("%s: NULL pointer was passed.\n", __func__);
  354 
  355         printf("sadb_key{ bits=%u reserved=%u\n",
  356             key->sadb_key_bits, key->sadb_key_reserved);
  357         printf("  key=");
  358 
  359         /* sanity check 2 */
  360         if ((key->sadb_key_bits >> 3) >
  361                 (PFKEY_UNUNIT64(key->sadb_key_len) - sizeof(struct sadb_key))) {
  362                 printf("%s: key length mismatch, bit:%d len:%ld.\n",
  363                         __func__,
  364                         key->sadb_key_bits >> 3,
  365                         (long)PFKEY_UNUNIT64(key->sadb_key_len) - sizeof(struct sadb_key));
  366         }
  367 
  368         ipsec_hexdump((caddr_t)key + sizeof(struct sadb_key),
  369                       key->sadb_key_bits >> 3);
  370         printf(" }\n");
  371         return;
  372 }
  373 
  374 static void
  375 kdebug_sadb_x_sa2(struct sadb_ext *ext)
  376 {
  377         struct sadb_x_sa2 *sa2 = (struct sadb_x_sa2 *)ext;
  378 
  379         /* sanity check */
  380         if (ext == NULL)
  381                 panic("%s: NULL pointer was passed.\n", __func__);
  382 
  383         printf("sadb_x_sa2{ mode=%u reqid=%u\n",
  384             sa2->sadb_x_sa2_mode, sa2->sadb_x_sa2_reqid);
  385         printf("  reserved1=%u reserved2=%u sequence=%u }\n",
  386             sa2->sadb_x_sa2_reserved1, sa2->sadb_x_sa2_reserved2,
  387             sa2->sadb_x_sa2_sequence);
  388 
  389         return;
  390 }
  391 
  392 void
  393 kdebug_sadb_x_policy(struct sadb_ext *ext)
  394 {
  395         struct sadb_x_policy *xpl = (struct sadb_x_policy *)ext;
  396         struct sockaddr *addr;
  397 
  398         /* sanity check */
  399         if (ext == NULL)
  400                 panic("%s: NULL pointer was passed.\n", __func__);
  401 
  402         printf("sadb_x_policy{ type=%u dir=%u id=%x }\n",
  403                 xpl->sadb_x_policy_type, xpl->sadb_x_policy_dir,
  404                 xpl->sadb_x_policy_id);
  405 
  406         if (xpl->sadb_x_policy_type == IPSEC_POLICY_IPSEC) {
  407                 int tlen;
  408                 struct sadb_x_ipsecrequest *xisr;
  409 
  410                 tlen = PFKEY_UNUNIT64(xpl->sadb_x_policy_len) - sizeof(*xpl);
  411                 xisr = (struct sadb_x_ipsecrequest *)(xpl + 1);
  412 
  413                 while (tlen > 0) {
  414                         printf(" { len=%u proto=%u mode=%u level=%u reqid=%u\n",
  415                                 xisr->sadb_x_ipsecrequest_len,
  416                                 xisr->sadb_x_ipsecrequest_proto,
  417                                 xisr->sadb_x_ipsecrequest_mode,
  418                                 xisr->sadb_x_ipsecrequest_level,
  419                                 xisr->sadb_x_ipsecrequest_reqid);
  420 
  421                         if (xisr->sadb_x_ipsecrequest_len > sizeof(*xisr)) {
  422                                 addr = (struct sockaddr *)(xisr + 1);
  423                                 kdebug_sockaddr(addr);
  424                                 addr = (struct sockaddr *)((caddr_t)addr
  425                                                         + addr->sa_len);
  426                                 kdebug_sockaddr(addr);
  427                         }
  428 
  429                         printf(" }\n");
  430 
  431                         /* prevent infinite loop */
  432                         if (xisr->sadb_x_ipsecrequest_len <= 0) {
  433                                 printf("%s: wrong policy struct.\n", __func__);
  434                                 return;
  435                         }
  436                         /* prevent overflow */
  437                         if (xisr->sadb_x_ipsecrequest_len > tlen) {
  438                                 printf("%s: invalid ipsec policy length "
  439                                         "(%u > %u)\n", __func__,
  440                                         xisr->sadb_x_ipsecrequest_len, tlen);
  441                                 return;
  442                         }
  443 
  444                         tlen -= xisr->sadb_x_ipsecrequest_len;
  445 
  446                         xisr = (struct sadb_x_ipsecrequest *)((caddr_t)xisr
  447                                         + xisr->sadb_x_ipsecrequest_len);
  448                 }
  449 
  450                 if (tlen != 0)
  451                         panic("%s: wrong policy struct.\n", __func__);
  452         }
  453 
  454         return;
  455 }
  456 
  457 #ifdef _KERNEL
  458 /* %%%: about SPD and SAD */
  459 void
  460 kdebug_secpolicy(struct secpolicy *sp)
  461 {
  462         /* sanity check */
  463         if (sp == NULL)
  464                 panic("%s: NULL pointer was passed.\n", __func__);
  465 
  466         printf("secpolicy{ refcnt=%u state=%u policy=%u\n",
  467                 sp->refcnt, sp->state, sp->policy);
  468 
  469         kdebug_secpolicyindex(&sp->spidx);
  470 
  471         switch (sp->policy) {
  472         case IPSEC_POLICY_DISCARD:
  473                 printf("  type=discard }\n");
  474                 break;
  475         case IPSEC_POLICY_NONE:
  476                 printf("  type=none }\n");
  477                 break;
  478         case IPSEC_POLICY_IPSEC:
  479             {
  480                 struct ipsecrequest *isr;
  481                 for (isr = sp->req; isr != NULL; isr = isr->next) {
  482 
  483                         printf("  level=%u\n", isr->level);
  484                         kdebug_secasindex(&isr->saidx);
  485 
  486                         if (isr->sav != NULL)
  487                                 kdebug_secasv(isr->sav);
  488                 }
  489                 printf("  }\n");
  490             }
  491                 break;
  492         case IPSEC_POLICY_BYPASS:
  493                 printf("  type=bypass }\n");
  494                 break;
  495         case IPSEC_POLICY_ENTRUST:
  496                 printf("  type=entrust }\n");
  497                 break;
  498         default:
  499                 printf("%s: Invalid policy found. %d\n", __func__, sp->policy);
  500                 break;
  501         }
  502 
  503         return;
  504 }
  505 
  506 void
  507 kdebug_secpolicyindex(struct secpolicyindex *spidx)
  508 {
  509         /* sanity check */
  510         if (spidx == NULL)
  511                 panic("%s: NULL pointer was passed.\n", __func__);
  512 
  513         printf("secpolicyindex{ dir=%u prefs=%u prefd=%u ul_proto=%u\n",
  514                 spidx->dir, spidx->prefs, spidx->prefd, spidx->ul_proto);
  515 
  516         ipsec_hexdump((caddr_t)&spidx->src,
  517                 ((struct sockaddr *)&spidx->src)->sa_len);
  518         printf("\n");
  519         ipsec_hexdump((caddr_t)&spidx->dst,
  520                 ((struct sockaddr *)&spidx->dst)->sa_len);
  521         printf("}\n");
  522 
  523         return;
  524 }
  525 
  526 void
  527 kdebug_secasindex(struct secasindex *saidx)
  528 {
  529         /* sanity check */
  530         if (saidx == NULL)
  531                 panic("%s: NULL pointer was passed.\n", __func__);
  532 
  533         printf("secasindex{ mode=%u proto=%u\n",
  534                 saidx->mode, saidx->proto);
  535 
  536         ipsec_hexdump((caddr_t)&saidx->src,
  537                 ((struct sockaddr *)&saidx->src)->sa_len);
  538         printf("\n");
  539         ipsec_hexdump((caddr_t)&saidx->dst,
  540                 ((struct sockaddr *)&saidx->dst)->sa_len);
  541         printf("\n");
  542 
  543         return;
  544 }
  545 
  546 static void
  547 kdebug_sec_lifetime(struct seclifetime *lft)
  548 {
  549         /* sanity check */
  550         if (lft == NULL)
  551                 panic("%s: NULL pointer was passed.\n", __func__);
  552 
  553         printf("sec_lifetime{ alloc=%u, bytes=%u\n",
  554                 lft->allocations, (u_int32_t)lft->bytes);
  555         printf("  addtime=%u, usetime=%u }\n",
  556                 (u_int32_t)lft->addtime, (u_int32_t)lft->usetime);
  557 
  558         return;
  559 }
  560 
  561 void
  562 kdebug_secasv(struct secasvar *sav)
  563 {
  564         /* sanity check */
  565         if (sav == NULL)
  566                 panic("%s: NULL pointer was passed.\n", __func__);
  567 
  568         printf("secas{");
  569         kdebug_secasindex(&sav->sah->saidx);
  570 
  571         printf("  refcnt=%u state=%u auth=%u enc=%u\n",
  572             sav->refcnt, sav->state, sav->alg_auth, sav->alg_enc);
  573         printf("  spi=%u flags=%u\n",
  574             (u_int32_t)ntohl(sav->spi), sav->flags);
  575 
  576         if (sav->key_auth != NULL)
  577                 kdebug_sadb_key((struct sadb_ext *)sav->key_auth);
  578         if (sav->key_enc != NULL)
  579                 kdebug_sadb_key((struct sadb_ext *)sav->key_enc);
  580         if (sav->iv != NULL) {
  581                 printf("  iv=");
  582                 ipsec_hexdump(sav->iv, sav->ivlen ? sav->ivlen : 8);
  583                 printf("\n");
  584         }
  585 
  586         if (sav->replay != NULL)
  587                 kdebug_secreplay(sav->replay);
  588         if (sav->lft_c != NULL)
  589                 kdebug_sec_lifetime(sav->lft_c);
  590         if (sav->lft_h != NULL)
  591                 kdebug_sec_lifetime(sav->lft_h);
  592         if (sav->lft_s != NULL)
  593                 kdebug_sec_lifetime(sav->lft_s);
  594 
  595 #ifdef notyet
  596         /* XXX: misc[123] ? */
  597 #endif
  598 
  599         return;
  600 }
  601 
  602 static void
  603 kdebug_secreplay(struct secreplay *rpl)
  604 {
  605         int len, l;
  606 
  607         /* sanity check */
  608         if (rpl == NULL)
  609                 panic("%s: NULL pointer was passed.\n", __func__);
  610 
  611         printf(" secreplay{ count=%u wsize=%u seq=%u lastseq=%u",
  612             rpl->count, rpl->wsize, rpl->seq, rpl->lastseq);
  613 
  614         if (rpl->bitmap == NULL) {
  615                 printf(" }\n");
  616                 return;
  617         }
  618 
  619         printf("\n   bitmap { ");
  620 
  621         for (len = 0; len < rpl->wsize; len++) {
  622                 for (l = 7; l >= 0; l--)
  623                         printf("%u", (((rpl->bitmap)[len] >> l) & 1) ? 1 : 0);
  624         }
  625         printf(" }\n");
  626 
  627         return;
  628 }
  629 
  630 void
  631 kdebug_mbufhdr(struct mbuf *m)
  632 {
  633         /* sanity check */
  634         if (m == NULL)
  635                 return;
  636 
  637         printf("mbuf(%p){ m_next:%p m_nextpkt:%p m_data:%p "
  638                "m_len:%d m_type:0x%02x m_flags:0x%02x }\n",
  639                 m, m->m_next, m->m_nextpkt, m->m_data,
  640                 m->m_len, m->m_type, m->m_flags);
  641 
  642         if (m->m_flags & M_PKTHDR) {
  643                 printf("  m_pkthdr{ len:%d rcvif:%p }\n",
  644                     m->m_pkthdr.len, m->m_pkthdr.rcvif);
  645         }
  646 
  647         if (m->m_flags & M_EXT) {
  648                 printf("  m_ext{ ext_buf:%p ext_free:%p "
  649                        "ext_size:%u ref_cnt:%p }\n",
  650                         m->m_ext.ext_buf, m->m_ext.ext_free,
  651                         m->m_ext.ext_size, m->m_ext.ref_cnt);
  652         }
  653 
  654         return;
  655 }
  656 
  657 void
  658 kdebug_mbuf(struct mbuf *m0)
  659 {
  660         struct mbuf *m = m0;
  661         int i, j;
  662 
  663         for (j = 0; m; m = m->m_next) {
  664                 kdebug_mbufhdr(m);
  665                 printf("  m_data:\n");
  666                 for (i = 0; i < m->m_len; i++) {
  667                         if (i && i % 32 == 0)
  668                                 printf("\n");
  669                         if (i % 4 == 0)
  670                                 printf(" ");
  671                         printf("%02x", mtod(m, u_char *)[i]);
  672                         j++;
  673                 }
  674                 printf("\n");
  675         }
  676 
  677         return;
  678 }
  679 #endif /* _KERNEL */
  680 
  681 void
  682 kdebug_sockaddr(struct sockaddr *addr)
  683 {
  684         struct sockaddr_in *sin4;
  685 #ifdef INET6
  686         struct sockaddr_in6 *sin6;
  687 #endif
  688 
  689         /* sanity check */
  690         if (addr == NULL)
  691                 panic("%s: NULL pointer was passed.\n", __func__);
  692 
  693         /* NOTE: We deal with port number as host byte order. */
  694         printf("sockaddr{ len=%u family=%u", addr->sa_len, addr->sa_family);
  695 
  696         switch (addr->sa_family) {
  697         case AF_INET:
  698                 sin4 = (struct sockaddr_in *)addr;
  699                 printf(" port=%u\n", ntohs(sin4->sin_port));
  700                 ipsec_hexdump((caddr_t)&sin4->sin_addr, sizeof(sin4->sin_addr));
  701                 break;
  702 #ifdef INET6
  703         case AF_INET6:
  704                 sin6 = (struct sockaddr_in6 *)addr;
  705                 printf(" port=%u\n", ntohs(sin6->sin6_port));
  706                 printf("  flowinfo=0x%08x, scope_id=0x%08x\n",
  707                     sin6->sin6_flowinfo, sin6->sin6_scope_id);
  708                 ipsec_hexdump((caddr_t)&sin6->sin6_addr,
  709                     sizeof(sin6->sin6_addr));
  710                 break;
  711 #endif
  712         }
  713 
  714         printf("  }\n");
  715 
  716         return;
  717 }
  718 
  719 void
  720 ipsec_bindump(caddr_t buf, int len)
  721 {
  722         int i;
  723 
  724         for (i = 0; i < len; i++)
  725                 printf("%c", (unsigned char)buf[i]);
  726 
  727         return;
  728 }
  729 
  730 
  731 void
  732 ipsec_hexdump(caddr_t buf, int len)
  733 {
  734         int i;
  735 
  736         for (i = 0; i < len; i++) {
  737                 if (i != 0 && i % 32 == 0) printf("\n");
  738                 if (i % 4 == 0) printf(" ");
  739                 printf("%02x", (unsigned char)buf[i]);
  740         }
  741 #if 0
  742         if (i % 32 != 0) printf("\n");
  743 #endif
  744 
  745         return;
  746 }
Cache object: b8addc21c621cf669681ef7b81a95fad
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/netipsec/key_debug.c

FreeBSD/Linux Kernel Cross Reference
sys/netipsec/key_debug.c
