key_debug.c revision 171133
1/* $FreeBSD: head/sys/netipsec/key_debug.c 171133 2007-07-01 11:41:27Z gnn $ */ 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/route.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 56#ifndef _KERNEL 57#include <ctype.h> 58#include <stdio.h> 59#include <stdlib.h> 60#endif /* !_KERNEL */ 61 62static void kdebug_sadb_prop __P((struct sadb_ext *)); 63static void kdebug_sadb_identity __P((struct sadb_ext *)); 64static void kdebug_sadb_supported __P((struct sadb_ext *)); 65static void kdebug_sadb_lifetime __P((struct sadb_ext *)); 66static void kdebug_sadb_sa __P((struct sadb_ext *)); 67static void kdebug_sadb_address __P((struct sadb_ext *)); 68static void kdebug_sadb_key __P((struct sadb_ext *)); 69static void kdebug_sadb_x_sa2 __P((struct sadb_ext *)); 70 71#ifdef _KERNEL 72static void kdebug_secreplay __P((struct secreplay *)); 73#endif 74 75#ifndef _KERNEL 76#define panic(fmt, ...) { printf(fmt, ## __VA_ARGS__); exit(-1); } 77#endif 78 79/* NOTE: host byte order */ 80 81/* %%%: about struct sadb_msg */ 82void 83kdebug_sadb(base) 84 struct sadb_msg *base; 85{ 86 struct sadb_ext *ext; 87 int tlen, extlen; 88 89 /* sanity check */ 90 if (base == NULL) 91 panic("%s: NULL pointer was passed.\n", __func__); 92 93 printf("sadb_msg{ version=%u type=%u errno=%u satype=%u\n", 94 base->sadb_msg_version, base->sadb_msg_type, 95 base->sadb_msg_errno, base->sadb_msg_satype); 96 printf(" len=%u reserved=%u seq=%u pid=%u\n", 97 base->sadb_msg_len, base->sadb_msg_reserved, 98 base->sadb_msg_seq, base->sadb_msg_pid); 99 100 tlen = PFKEY_UNUNIT64(base->sadb_msg_len) - sizeof(struct sadb_msg); 101 ext = (struct sadb_ext *)((caddr_t)base + sizeof(struct sadb_msg)); 102 103 while (tlen > 0) { 104 printf("sadb_ext{ len=%u type=%u }\n", 105 ext->sadb_ext_len, ext->sadb_ext_type); 106 107 if (ext->sadb_ext_len == 0) { 108 printf("%s: invalid ext_len=0 was passed.\n", __func__); 109 return; 110 } 111 if (ext->sadb_ext_len > tlen) { 112 printf("%s: ext_len too big (%u > %u).\n", 113 __func__, ext->sadb_ext_len, tlen); 114 return; 115 } 116 117 switch (ext->sadb_ext_type) { 118 case SADB_EXT_SA: 119 kdebug_sadb_sa(ext); 120 break; 121 case SADB_EXT_LIFETIME_CURRENT: 122 case SADB_EXT_LIFETIME_HARD: 123 case SADB_EXT_LIFETIME_SOFT: 124 kdebug_sadb_lifetime(ext); 125 break; 126 case SADB_EXT_ADDRESS_SRC: 127 case SADB_EXT_ADDRESS_DST: 128 case SADB_EXT_ADDRESS_PROXY: 129 kdebug_sadb_address(ext); 130 break; 131 case SADB_EXT_KEY_AUTH: 132 case SADB_EXT_KEY_ENCRYPT: 133 kdebug_sadb_key(ext); 134 break; 135 case SADB_EXT_IDENTITY_SRC: 136 case SADB_EXT_IDENTITY_DST: 137 kdebug_sadb_identity(ext); 138 break; 139 case SADB_EXT_SENSITIVITY: 140 break; 141 case SADB_EXT_PROPOSAL: 142 kdebug_sadb_prop(ext); 143 break; 144 case SADB_EXT_SUPPORTED_AUTH: 145 case SADB_EXT_SUPPORTED_ENCRYPT: 146 kdebug_sadb_supported(ext); 147 break; 148 case SADB_EXT_SPIRANGE: 149 case SADB_X_EXT_KMPRIVATE: 150 break; 151 case SADB_X_EXT_POLICY: 152 kdebug_sadb_x_policy(ext); 153 break; 154 case SADB_X_EXT_SA2: 155 kdebug_sadb_x_sa2(ext); 156 break; 157 default: 158 printf("%s: invalid ext_type %u\n", __func__, 159 ext->sadb_ext_type); 160 return; 161 } 162 163 extlen = PFKEY_UNUNIT64(ext->sadb_ext_len); 164 tlen -= extlen; 165 ext = (struct sadb_ext *)((caddr_t)ext + extlen); 166 } 167 168 return; 169} 170 171static void 172kdebug_sadb_prop(ext) 173 struct sadb_ext *ext; 174{ 175 struct sadb_prop *prop = (struct sadb_prop *)ext; 176 struct sadb_comb *comb; 177 int len; 178 179 /* sanity check */ 180 if (ext == NULL) 181 panic("%s: NULL pointer was passed.\n", __func__); 182 183 len = (PFKEY_UNUNIT64(prop->sadb_prop_len) - sizeof(*prop)) 184 / sizeof(*comb); 185 comb = (struct sadb_comb *)(prop + 1); 186 printf("sadb_prop{ replay=%u\n", prop->sadb_prop_replay); 187 188 while (len--) { 189 printf("sadb_comb{ auth=%u encrypt=%u " 190 "flags=0x%04x reserved=0x%08x\n", 191 comb->sadb_comb_auth, comb->sadb_comb_encrypt, 192 comb->sadb_comb_flags, comb->sadb_comb_reserved); 193 194 printf(" auth_minbits=%u auth_maxbits=%u " 195 "encrypt_minbits=%u encrypt_maxbits=%u\n", 196 comb->sadb_comb_auth_minbits, 197 comb->sadb_comb_auth_maxbits, 198 comb->sadb_comb_encrypt_minbits, 199 comb->sadb_comb_encrypt_maxbits); 200 201 printf(" soft_alloc=%u hard_alloc=%u " 202 "soft_bytes=%lu hard_bytes=%lu\n", 203 comb->sadb_comb_soft_allocations, 204 comb->sadb_comb_hard_allocations, 205 (unsigned long)comb->sadb_comb_soft_bytes, 206 (unsigned long)comb->sadb_comb_hard_bytes); 207 208 printf(" soft_alloc=%lu hard_alloc=%lu " 209 "soft_bytes=%lu hard_bytes=%lu }\n", 210 (unsigned long)comb->sadb_comb_soft_addtime, 211 (unsigned long)comb->sadb_comb_hard_addtime, 212 (unsigned long)comb->sadb_comb_soft_usetime, 213 (unsigned long)comb->sadb_comb_hard_usetime); 214 comb++; 215 } 216 printf("}\n"); 217 218 return; 219} 220 221static void 222kdebug_sadb_identity(ext) 223 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 264static void 265kdebug_sadb_supported(ext) 266 struct sadb_ext *ext; 267{ 268 struct sadb_supported *sup = (struct sadb_supported *)ext; 269 struct sadb_alg *alg; 270 int len; 271 272 /* sanity check */ 273 if (ext == NULL) 274 panic("%s: NULL pointer was passed.\n", __func__); 275 276 len = (PFKEY_UNUNIT64(sup->sadb_supported_len) - sizeof(*sup)) 277 / sizeof(*alg); 278 alg = (struct sadb_alg *)(sup + 1); 279 printf("sadb_sup{\n"); 280 while (len--) { 281 printf(" { id=%d ivlen=%d min=%d max=%d }\n", 282 alg->sadb_alg_id, alg->sadb_alg_ivlen, 283 alg->sadb_alg_minbits, alg->sadb_alg_maxbits); 284 alg++; 285 } 286 printf("}\n"); 287 288 return; 289} 290 291static void 292kdebug_sadb_lifetime(ext) 293 struct sadb_ext *ext; 294{ 295 struct sadb_lifetime *lft = (struct sadb_lifetime *)ext; 296 297 /* sanity check */ 298 if (ext == NULL) 299 printf("%s: NULL pointer was passed.\n", __func__); 300 301 printf("sadb_lifetime{ alloc=%u, bytes=%u\n", 302 lft->sadb_lifetime_allocations, 303 (u_int32_t)lft->sadb_lifetime_bytes); 304 printf(" addtime=%u, usetime=%u }\n", 305 (u_int32_t)lft->sadb_lifetime_addtime, 306 (u_int32_t)lft->sadb_lifetime_usetime); 307 308 return; 309} 310 311static void 312kdebug_sadb_sa(ext) 313 struct sadb_ext *ext; 314{ 315 struct sadb_sa *sa = (struct sadb_sa *)ext; 316 317 /* sanity check */ 318 if (ext == NULL) 319 panic("%s: NULL pointer was passed.\n", __func__); 320 321 printf("sadb_sa{ spi=%u replay=%u state=%u\n", 322 (u_int32_t)ntohl(sa->sadb_sa_spi), sa->sadb_sa_replay, 323 sa->sadb_sa_state); 324 printf(" auth=%u encrypt=%u flags=0x%08x }\n", 325 sa->sadb_sa_auth, sa->sadb_sa_encrypt, sa->sadb_sa_flags); 326 327 return; 328} 329 330static void 331kdebug_sadb_address(ext) 332 struct sadb_ext *ext; 333{ 334 struct sadb_address *addr = (struct sadb_address *)ext; 335 336 /* sanity check */ 337 if (ext == NULL) 338 panic("%s: NULL pointer was passed.\n", __func__); 339 340 printf("sadb_address{ proto=%u prefixlen=%u reserved=0x%02x%02x }\n", 341 addr->sadb_address_proto, addr->sadb_address_prefixlen, 342 ((u_char *)&addr->sadb_address_reserved)[0], 343 ((u_char *)&addr->sadb_address_reserved)[1]); 344 345 kdebug_sockaddr((struct sockaddr *)((caddr_t)ext + sizeof(*addr))); 346 347 return; 348} 349 350static void 351kdebug_sadb_key(ext) 352 struct sadb_ext *ext; 353{ 354 struct sadb_key *key = (struct sadb_key *)ext; 355 356 /* sanity check */ 357 if (ext == NULL) 358 panic("%s: NULL pointer was passed.\n", __func__); 359 360 printf("sadb_key{ bits=%u reserved=%u\n", 361 key->sadb_key_bits, key->sadb_key_reserved); 362 printf(" key="); 363 364 /* sanity check 2 */ 365 if ((key->sadb_key_bits >> 3) > 366 (PFKEY_UNUNIT64(key->sadb_key_len) - sizeof(struct sadb_key))) { 367 printf("%s: key length mismatch, bit:%d len:%ld.\n", 368 __func__, 369 key->sadb_key_bits >> 3, 370 (long)PFKEY_UNUNIT64(key->sadb_key_len) - sizeof(struct sadb_key)); 371 } 372 373 ipsec_hexdump((caddr_t)key + sizeof(struct sadb_key), 374 key->sadb_key_bits >> 3); 375 printf(" }\n"); 376 return; 377} 378 379static void 380kdebug_sadb_x_sa2(ext) 381 struct sadb_ext *ext; 382{ 383 struct sadb_x_sa2 *sa2 = (struct sadb_x_sa2 *)ext; 384 385 /* sanity check */ 386 if (ext == NULL) 387 panic("%s: NULL pointer was passed.\n", __func__); 388 389 printf("sadb_x_sa2{ mode=%u reqid=%u\n", 390 sa2->sadb_x_sa2_mode, sa2->sadb_x_sa2_reqid); 391 printf(" reserved1=%u reserved2=%u sequence=%u }\n", 392 sa2->sadb_x_sa2_reserved1, sa2->sadb_x_sa2_reserved2, 393 sa2->sadb_x_sa2_sequence); 394 395 return; 396} 397 398void 399kdebug_sadb_x_policy(ext) 400 struct sadb_ext *ext; 401{ 402 struct sadb_x_policy *xpl = (struct sadb_x_policy *)ext; 403 struct sockaddr *addr; 404 405 /* sanity check */ 406 if (ext == NULL) 407 panic("%s: NULL pointer was passed.\n", __func__); 408 409 printf("sadb_x_policy{ type=%u dir=%u id=%x }\n", 410 xpl->sadb_x_policy_type, xpl->sadb_x_policy_dir, 411 xpl->sadb_x_policy_id); 412 413 if (xpl->sadb_x_policy_type == IPSEC_POLICY_IPSEC) { 414 int tlen; 415 struct sadb_x_ipsecrequest *xisr; 416 417 tlen = PFKEY_UNUNIT64(xpl->sadb_x_policy_len) - sizeof(*xpl); 418 xisr = (struct sadb_x_ipsecrequest *)(xpl + 1); 419 420 while (tlen > 0) { 421 printf(" { len=%u proto=%u mode=%u level=%u reqid=%u\n", 422 xisr->sadb_x_ipsecrequest_len, 423 xisr->sadb_x_ipsecrequest_proto, 424 xisr->sadb_x_ipsecrequest_mode, 425 xisr->sadb_x_ipsecrequest_level, 426 xisr->sadb_x_ipsecrequest_reqid); 427 428 if (xisr->sadb_x_ipsecrequest_len > sizeof(*xisr)) { 429 addr = (struct sockaddr *)(xisr + 1); 430 kdebug_sockaddr(addr); 431 addr = (struct sockaddr *)((caddr_t)addr 432 + addr->sa_len); 433 kdebug_sockaddr(addr); 434 } 435 436 printf(" }\n"); 437 438 /* prevent infinite loop */ 439 if (xisr->sadb_x_ipsecrequest_len <= 0) { 440 printf("%s: wrong policy struct.\n", __func__); 441 return; 442 } 443 /* prevent overflow */ 444 if (xisr->sadb_x_ipsecrequest_len > tlen) { 445 printf("%s: invalid ipsec policy length " 446 "(%u > %u)\n", __func__, 447 xisr->sadb_x_ipsecrequest_len, tlen); 448 return; 449 } 450 451 tlen -= xisr->sadb_x_ipsecrequest_len; 452 453 xisr = (struct sadb_x_ipsecrequest *)((caddr_t)xisr 454 + xisr->sadb_x_ipsecrequest_len); 455 } 456 457 if (tlen != 0) 458 panic("%s: wrong policy struct.\n", __func__); 459 } 460 461 return; 462} 463 464#ifdef _KERNEL 465/* %%%: about SPD and SAD */ 466void 467kdebug_secpolicy(sp) 468 struct secpolicy *sp; 469{ 470 /* sanity check */ 471 if (sp == NULL) 472 panic("%s: NULL pointer was passed.\n", __func__); 473 474 printf("secpolicy{ refcnt=%u state=%u policy=%u\n", 475 sp->refcnt, sp->state, sp->policy); 476 477 kdebug_secpolicyindex(&sp->spidx); 478 479 switch (sp->policy) { 480 case IPSEC_POLICY_DISCARD: 481 printf(" type=discard }\n"); 482 break; 483 case IPSEC_POLICY_NONE: 484 printf(" type=none }\n"); 485 break; 486 case IPSEC_POLICY_IPSEC: 487 { 488 struct ipsecrequest *isr; 489 for (isr = sp->req; isr != NULL; isr = isr->next) { 490 491 printf(" level=%u\n", isr->level); 492 kdebug_secasindex(&isr->saidx); 493 494 if (isr->sav != NULL) 495 kdebug_secasv(isr->sav); 496 } 497 printf(" }\n"); 498 } 499 break; 500 case IPSEC_POLICY_BYPASS: 501 printf(" type=bypass }\n"); 502 break; 503 case IPSEC_POLICY_ENTRUST: 504 printf(" type=entrust }\n"); 505 break; 506 default: 507 printf("%s: Invalid policy found. %d\n", __func__, sp->policy); 508 break; 509 } 510 511 return; 512} 513 514void 515kdebug_secpolicyindex(spidx) 516 struct secpolicyindex *spidx; 517{ 518 /* sanity check */ 519 if (spidx == NULL) 520 panic("%s: NULL pointer was passed.\n", __func__); 521 522 printf("secpolicyindex{ dir=%u prefs=%u prefd=%u ul_proto=%u\n", 523 spidx->dir, spidx->prefs, spidx->prefd, spidx->ul_proto); 524 525 ipsec_hexdump((caddr_t)&spidx->src, 526 ((struct sockaddr *)&spidx->src)->sa_len); 527 printf("\n"); 528 ipsec_hexdump((caddr_t)&spidx->dst, 529 ((struct sockaddr *)&spidx->dst)->sa_len); 530 printf("}\n"); 531 532 return; 533} 534 535void 536kdebug_secasindex(saidx) 537 struct secasindex *saidx; 538{ 539 /* sanity check */ 540 if (saidx == NULL) 541 panic("%s: NULL pointer was passed.\n", __func__); 542 543 printf("secasindex{ mode=%u proto=%u\n", 544 saidx->mode, saidx->proto); 545 546 ipsec_hexdump((caddr_t)&saidx->src, 547 ((struct sockaddr *)&saidx->src)->sa_len); 548 printf("\n"); 549 ipsec_hexdump((caddr_t)&saidx->dst, 550 ((struct sockaddr *)&saidx->dst)->sa_len); 551 printf("\n"); 552 553 return; 554} 555 556void 557kdebug_secasv(sav) 558 struct secasvar *sav; 559{ 560 /* sanity check */ 561 if (sav == NULL) 562 panic("%s: NULL pointer was passed.\n", __func__); 563 564 printf("secas{"); 565 kdebug_secasindex(&sav->sah->saidx); 566 567 printf(" refcnt=%u state=%u auth=%u enc=%u\n", 568 sav->refcnt, sav->state, sav->alg_auth, sav->alg_enc); 569 printf(" spi=%u flags=%u\n", 570 (u_int32_t)ntohl(sav->spi), sav->flags); 571 572 if (sav->key_auth != NULL) 573 kdebug_sadb_key((struct sadb_ext *)sav->key_auth); 574 if (sav->key_enc != NULL) 575 kdebug_sadb_key((struct sadb_ext *)sav->key_enc); 576 if (sav->iv != NULL) { 577 printf(" iv="); 578 ipsec_hexdump(sav->iv, sav->ivlen ? sav->ivlen : 8); 579 printf("\n"); 580 } 581 582 if (sav->replay != NULL) 583 kdebug_secreplay(sav->replay); 584 if (sav->lft_c != NULL) 585 kdebug_sadb_lifetime((struct sadb_ext *)sav->lft_c); 586 if (sav->lft_h != NULL) 587 kdebug_sadb_lifetime((struct sadb_ext *)sav->lft_h); 588 if (sav->lft_s != NULL) 589 kdebug_sadb_lifetime((struct sadb_ext *)sav->lft_s); 590 591#ifdef notyet 592 /* XXX: misc[123] ? */ 593#endif 594 595 return; 596} 597 598static void 599kdebug_secreplay(rpl) 600 struct secreplay *rpl; 601{ 602 int len, l; 603 604 /* sanity check */ 605 if (rpl == NULL) 606 panic("%s: NULL pointer was passed.\n", __func__); 607 608 printf(" secreplay{ count=%u wsize=%u seq=%u lastseq=%u", 609 rpl->count, rpl->wsize, rpl->seq, rpl->lastseq); 610 611 if (rpl->bitmap == NULL) { 612 printf(" }\n"); 613 return; 614 } 615 616 printf("\n bitmap { "); 617 618 for (len = 0; len < rpl->wsize; len++) { 619 for (l = 7; l >= 0; l--) 620 printf("%u", (((rpl->bitmap)[len] >> l) & 1) ? 1 : 0); 621 } 622 printf(" }\n"); 623 624 return; 625} 626 627void 628kdebug_mbufhdr(m) 629 struct mbuf *m; 630{ 631 /* sanity check */ 632 if (m == NULL) 633 return; 634 635 printf("mbuf(%p){ m_next:%p m_nextpkt:%p m_data:%p " 636 "m_len:%d m_type:0x%02x m_flags:0x%02x }\n", 637 m, m->m_next, m->m_nextpkt, m->m_data, 638 m->m_len, m->m_type, m->m_flags); 639 640 if (m->m_flags & M_PKTHDR) { 641 printf(" m_pkthdr{ len:%d rcvif:%p }\n", 642 m->m_pkthdr.len, m->m_pkthdr.rcvif); 643 } 644 645 if (m->m_flags & M_EXT) { 646 printf(" m_ext{ ext_buf:%p ext_free:%p " 647 "ext_size:%u ref_cnt:%p }\n", 648 m->m_ext.ext_buf, m->m_ext.ext_free, 649 m->m_ext.ext_size, m->m_ext.ref_cnt); 650 } 651 652 return; 653} 654 655void 656kdebug_mbuf(m0) 657 struct mbuf *m0; 658{ 659 struct mbuf *m = m0; 660 int i, j; 661 662 for (j = 0; m; m = m->m_next) { 663 kdebug_mbufhdr(m); 664 printf(" m_data:\n"); 665 for (i = 0; i < m->m_len; i++) { 666 if (i && i % 32 == 0) 667 printf("\n"); 668 if (i % 4 == 0) 669 printf(" "); 670 printf("%02x", mtod(m, u_char *)[i]); 671 j++; 672 } 673 printf("\n"); 674 } 675 676 return; 677} 678#endif /* _KERNEL */ 679 680void 681kdebug_sockaddr(addr) 682 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 719void 720ipsec_bindump(buf, len) 721 caddr_t buf; 722 int len; 723{ 724 int i; 725 726 for (i = 0; i < len; i++) 727 printf("%c", (unsigned char)buf[i]); 728 729 return; 730} 731 732 733void 734ipsec_hexdump(buf, len) 735 caddr_t buf; 736 int len; 737{ 738 int i; 739 740 for (i = 0; i < len; i++) { 741 if (i != 0 && i % 32 == 0) printf("\n"); 742 if (i % 4 == 0) printf(" "); 743 printf("%02x", (unsigned char)buf[i]); 744 } 745#if 0 746 if (i % 32 != 0) printf("\n"); 747#endif 748 749 return; 750} 751