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