print-atalk.c revision 26183
1/* 2 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that: (1) source code distributions 7 * retain the above copyright notice and this paragraph in its entirety, (2) 8 * distributions including binary code include the above copyright notice and 9 * this paragraph in its entirety in the documentation or other materials 10 * provided with the distribution, and (3) all advertising materials mentioning 11 * features or use of this software display the following acknowledgement: 12 * ``This product includes software developed by the University of California, 13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of 14 * the University nor the names of its contributors may be used to endorse 15 * or promote products derived from this software without specific prior 16 * written permission. 17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 20 * 21 * Format and print AppleTalk packets. 22 */ 23 24#ifndef lint 25static const char rcsid[] = 26 "@(#) $Header: print-atalk.c,v 1.45 96/12/10 23:24:07 leres Exp $ (LBL)"; 27#endif 28 29#include <sys/param.h> 30#include <sys/time.h> 31#include <sys/socket.h> 32 33#if __STDC__ 34struct mbuf; 35struct rtentry; 36#endif 37#include <net/if.h> 38 39#include <netinet/in.h> 40#include <netinet/in_systm.h> 41#include <netinet/ip.h> 42#include <netinet/ip_var.h> 43#include <net/ethernet.h> 44#include <netinet/udp.h> 45#include <netinet/udp_var.h> 46#include <netinet/tcp.h> 47#include <netinet/tcpip.h> 48 49#include <stdio.h> 50#include <stdlib.h> 51#include <string.h> 52 53#include "interface.h" 54#include "addrtoname.h" 55#include "ethertype.h" 56#include "extract.h" /* must come after interface.h */ 57#include "appletalk.h" 58 59static struct tok type2str[] = { 60 { ddpRTMP, "rtmp" }, 61 { ddpRTMPrequest, "rtmpReq" }, 62 { ddpECHO, "echo" }, 63 { ddpIP, "IP" }, 64 { ddpARP, "ARP" }, 65 { ddpKLAP, "KLAP" }, 66 { 0, NULL } 67}; 68 69struct aarp { 70 u_short htype, ptype; 71 u_char halen, palen; 72 u_short op; 73 u_char hsaddr[6]; 74 u_char psaddr[4]; 75 u_char hdaddr[6]; 76 u_char pdaddr[4]; 77}; 78 79static char tstr[] = "[|atalk]"; 80 81static void atp_print(const struct atATP *, u_int); 82static void atp_bitmap_print(u_char); 83static void nbp_print(const struct atNBP *, u_int, u_short, u_char, u_char); 84static const char *print_cstring(const char *, const u_char *); 85static const struct atNBPtuple *nbp_tuple_print(const struct atNBPtuple *, 86 const u_char *, 87 u_short, u_char, u_char); 88static const struct atNBPtuple *nbp_name_print(const struct atNBPtuple *, 89 const u_char *); 90static const char *ataddr_string(u_short, u_char); 91static void ddp_print(const u_char *, u_int, int, u_short, u_char, u_char); 92static const char *ddpskt_string(int); 93 94/* 95 * Print AppleTalk Datagram Delivery Protocol packets. 96 */ 97void 98atalk_print(register const u_char *bp, u_int length) 99{ 100 register const struct LAP *lp; 101 register const struct atDDP *dp; 102 register const struct atShortDDP *sdp; 103 u_short snet; 104 105#if 0 106 lp = (struct LAP *)bp; 107 bp += sizeof(*lp); 108 length -= sizeof(*lp); 109#else 110 { 111 static struct LAP lp_ = {0, 0, lapDDP}; 112 lp = &lp_; 113 } 114#endif 115 switch (lp->type) { 116 117 case lapShortDDP: 118 if (length < ddpSSize) { 119 (void)printf(" [|sddp %d]", length); 120 return; 121 } 122 sdp = (const struct atShortDDP *)bp; 123 printf("%s.%s", 124 ataddr_string(0, lp->src), ddpskt_string(sdp->srcSkt)); 125 printf(" > %s.%s:", 126 ataddr_string(0, lp->dst), ddpskt_string(sdp->dstSkt)); 127 bp += ddpSSize; 128 length -= ddpSSize; 129 ddp_print(bp, length, sdp->type, 0, lp->src, sdp->srcSkt); 130 break; 131 132 case lapDDP: 133 if (length < ddpSize) { 134 (void)printf(" [|ddp %d]", length); 135 return; 136 } 137 dp = (const struct atDDP *)bp; 138 snet = EXTRACT_16BITS(&dp->srcNet); 139 printf("%s.%s", ataddr_string(snet, dp->srcNode), 140 ddpskt_string(dp->srcSkt)); 141 printf(" > %s.%s:", 142 ataddr_string(EXTRACT_16BITS(&dp->dstNet), dp->dstNode), 143 ddpskt_string(dp->dstSkt)); 144 bp += ddpSize; 145 length -= ddpSize; 146 ddp_print(bp, length, dp->type, snet, dp->srcNode, dp->srcSkt); 147 break; 148 149#ifdef notdef 150 case lapKLAP: 151 klap_print(bp, length); 152 break; 153#endif 154 155 default: 156 printf("%d > %d at-lap#%d %d", 157 lp->src, lp->dst, lp->type, length); 158 break; 159 } 160} 161 162/* XXX should probably pass in the snap header and do checks like arp_print() */ 163void 164aarp_print(register const u_char *bp, u_int length) 165{ 166 register const struct aarp *ap; 167 168#define AT(member) ataddr_string((ap->member[1]<<8)|ap->member[2],ap->member[3]) 169 170 printf("aarp "); 171 ap = (const struct aarp *)bp; 172 if (ntohs(ap->htype) == 1 && ntohs(ap->ptype) == ETHERTYPE_ATALK && 173 ap->halen == 6 && ap->palen == 4 ) 174 switch (ntohs(ap->op)) { 175 176 case 1: /* request */ 177 (void)printf("who-has %s tell %s", 178 AT(pdaddr), AT(psaddr)); 179 return; 180 181 case 2: /* response */ 182 (void)printf("reply %s is-at %s", 183 AT(psaddr), etheraddr_string(ap->hsaddr)); 184 return; 185 186 case 3: /* probe (oy!) */ 187 (void)printf("probe %s tell %s", 188 AT(pdaddr), AT(psaddr)); 189 return; 190 } 191 (void)printf("len %d op %d htype %d ptype %#x halen %d palen %d", 192 length, ap->op, ap->htype, ap->ptype, ap->halen, ap->palen ); 193} 194 195static void 196ddp_print(register const u_char *bp, register u_int length, register int t, 197 register u_short snet, register u_char snode, u_char skt) 198{ 199 200 switch (t) { 201 202 case ddpNBP: 203 nbp_print((const struct atNBP *)bp, length, snet, snode, skt); 204 break; 205 206 case ddpATP: 207 atp_print((const struct atATP *)bp, length); 208 break; 209 210 default: 211 (void)printf(" at-%s %d", tok2str(type2str, NULL, t), length); 212 break; 213 } 214} 215 216static void 217atp_print(register const struct atATP *ap, u_int length) 218{ 219 char c; 220 u_int32_t data; 221 222 if ((const u_char *)(ap + 1) > snapend) { 223 /* Just bail if we don't have the whole chunk. */ 224 fputs(tstr, stdout); 225 return; 226 } 227 length -= sizeof(*ap); 228 switch (ap->control & 0xc0) { 229 230 case atpReqCode: 231 (void)printf(" atp-req%s %d", 232 ap->control & atpXO? " " : "*", 233 EXTRACT_16BITS(&ap->transID)); 234 235 atp_bitmap_print(ap->bitmap); 236 237 if (length != 0) 238 (void)printf(" [len=%d]", length); 239 240 switch (ap->control & (atpEOM|atpSTS)) { 241 case atpEOM: 242 (void)printf(" [EOM]"); 243 break; 244 case atpSTS: 245 (void)printf(" [STS]"); 246 break; 247 case atpEOM|atpSTS: 248 (void)printf(" [EOM,STS]"); 249 break; 250 } 251 break; 252 253 case atpRspCode: 254 (void)printf(" atp-resp%s%d:%d (%d)", 255 ap->control & atpEOM? "*" : " ", 256 EXTRACT_16BITS(&ap->transID), ap->bitmap, length); 257 switch (ap->control & (atpXO|atpSTS)) { 258 case atpXO: 259 (void)printf(" [XO]"); 260 break; 261 case atpSTS: 262 (void)printf(" [STS]"); 263 break; 264 case atpXO|atpSTS: 265 (void)printf(" [XO,STS]"); 266 break; 267 } 268 break; 269 270 case atpRelCode: 271 (void)printf(" atp-rel %d", EXTRACT_16BITS(&ap->transID)); 272 273 atp_bitmap_print(ap->bitmap); 274 275 /* length should be zero */ 276 if (length) 277 (void)printf(" [len=%d]", length); 278 279 /* there shouldn't be any control flags */ 280 if (ap->control & (atpXO|atpEOM|atpSTS)) { 281 c = '['; 282 if (ap->control & atpXO) { 283 (void)printf("%cXO", c); 284 c = ','; 285 } 286 if (ap->control & atpEOM) { 287 (void)printf("%cEOM", c); 288 c = ','; 289 } 290 if (ap->control & atpSTS) { 291 (void)printf("%cSTS", c); 292 c = ','; 293 } 294 (void)printf("]"); 295 } 296 break; 297 298 default: 299 (void)printf(" atp-0x%x %d (%d)", ap->control, 300 EXTRACT_16BITS(&ap->transID), length); 301 break; 302 } 303 data = EXTRACT_32BITS(&ap->userData); 304 if (data != 0) 305 (void)printf(" 0x%x", data); 306} 307 308static void 309atp_bitmap_print(register u_char bm) 310{ 311 register char c; 312 register int i; 313 314 /* 315 * The '& 0xff' below is needed for compilers that want to sign 316 * extend a u_char, which is the case with the Ultrix compiler. 317 * (gcc is smart enough to eliminate it, at least on the Sparc). 318 */ 319 if ((bm + 1) & (bm & 0xff)) { 320 c = '<'; 321 for (i = 0; bm; ++i) { 322 if (bm & 1) { 323 (void)printf("%c%d", c, i); 324 c = ','; 325 } 326 bm >>= 1; 327 } 328 (void)printf(">"); 329 } else { 330 for (i = 0; bm; ++i) 331 bm >>= 1; 332 if (i > 1) 333 (void)printf("<0-%d>", i - 1); 334 else 335 (void)printf("<0>"); 336 } 337} 338 339static void 340nbp_print(register const struct atNBP *np, u_int length, register u_short snet, 341 register u_char snode, register u_char skt) 342{ 343 register const struct atNBPtuple *tp = 344 (struct atNBPtuple *)((u_char *)np + nbpHeaderSize); 345 int i; 346 const u_char *ep; 347 348 length -= nbpHeaderSize; 349 if (length < 8) { 350 /* must be room for at least one tuple */ 351 (void)printf(" truncated-nbp %d", length + nbpHeaderSize); 352 return; 353 } 354 /* ep points to end of available data */ 355 ep = snapend; 356 if ((const u_char *)tp > ep) { 357 fputs(tstr, stdout); 358 return; 359 } 360 switch (i = np->control & 0xf0) { 361 362 case nbpBrRq: 363 case nbpLkUp: 364 (void)printf(i == nbpLkUp? " nbp-lkup %d:":" nbp-brRq %d:", 365 np->id); 366 if ((const u_char *)(tp + 1) > ep) { 367 fputs(tstr, stdout); 368 return; 369 } 370 (void)nbp_name_print(tp, ep); 371 /* 372 * look for anomalies: the spec says there can only 373 * be one tuple, the address must match the source 374 * address and the enumerator should be zero. 375 */ 376 if ((np->control & 0xf) != 1) 377 (void)printf(" [ntup=%d]", np->control & 0xf); 378 if (tp->enumerator) 379 (void)printf(" [enum=%d]", tp->enumerator); 380 if (EXTRACT_16BITS(&tp->net) != snet || 381 tp->node != snode || tp->skt != skt) 382 (void)printf(" [addr=%s.%d]", 383 ataddr_string(EXTRACT_16BITS(&tp->net), 384 tp->node), tp->skt); 385 break; 386 387 case nbpLkUpReply: 388 (void)printf(" nbp-reply %d:", np->id); 389 390 /* print each of the tuples in the reply */ 391 for (i = np->control & 0xf; --i >= 0 && tp; ) 392 tp = nbp_tuple_print(tp, ep, snet, snode, skt); 393 break; 394 395 default: 396 (void)printf(" nbp-0x%x %d (%d)", np->control, np->id, 397 length); 398 break; 399 } 400} 401 402/* print a counted string */ 403static const char * 404print_cstring(register const char *cp, register const u_char *ep) 405{ 406 register u_int length; 407 408 if (cp >= (const char *)ep) { 409 fputs(tstr, stdout); 410 return (0); 411 } 412 length = *cp++; 413 414 /* Spec says string can be at most 32 bytes long */ 415 if (length < 0 || length > 32) { 416 (void)printf("[len=%d]", length); 417 return (0); 418 } 419 while (--length >= 0) { 420 if (cp >= (char *)ep) { 421 fputs(tstr, stdout); 422 return (0); 423 } 424 putchar(*cp++); 425 } 426 return (cp); 427} 428 429static const struct atNBPtuple * 430nbp_tuple_print(register const struct atNBPtuple *tp, 431 register const u_char *ep, 432 register u_short snet, register u_char snode, 433 register u_char skt) 434{ 435 register const struct atNBPtuple *tpn; 436 437 if ((const u_char *)(tp + 1) > ep) { 438 fputs(tstr, stdout); 439 return 0; 440 } 441 tpn = nbp_name_print(tp, ep); 442 443 /* if the enumerator isn't 1, print it */ 444 if (tp->enumerator != 1) 445 (void)printf("(%d)", tp->enumerator); 446 447 /* if the socket doesn't match the src socket, print it */ 448 if (tp->skt != skt) 449 (void)printf(" %d", tp->skt); 450 451 /* if the address doesn't match the src address, it's an anomaly */ 452 if (EXTRACT_16BITS(&tp->net) != snet || tp->node != snode) 453 (void)printf(" [addr=%s]", 454 ataddr_string(EXTRACT_16BITS(&tp->net), tp->node)); 455 456 return (tpn); 457} 458 459static const struct atNBPtuple * 460nbp_name_print(const struct atNBPtuple *tp, register const u_char *ep) 461{ 462 register const char *cp = (const char *)tp + nbpTupleSize; 463 464 putchar(' '); 465 466 /* Object */ 467 putchar('"'); 468 if ((cp = print_cstring(cp, ep)) != NULL) { 469 /* Type */ 470 putchar(':'); 471 if ((cp = print_cstring(cp, ep)) != NULL) { 472 /* Zone */ 473 putchar('@'); 474 if ((cp = print_cstring(cp, ep)) != NULL) 475 putchar('"'); 476 } 477 } 478 return ((const struct atNBPtuple *)cp); 479} 480 481 482#define HASHNAMESIZE 4096 483 484struct hnamemem { 485 int addr; 486 char *name; 487 struct hnamemem *nxt; 488}; 489 490static struct hnamemem hnametable[HASHNAMESIZE]; 491 492static const char * 493ataddr_string(u_short atnet, u_char athost) 494{ 495 register struct hnamemem *tp, *tp2; 496 register int i = (atnet << 8) | athost; 497 char nambuf[256]; 498 static int first = 1; 499 FILE *fp; 500 501 /* 502 * if this is the first call, see if there's an AppleTalk 503 * number to name map file. 504 */ 505 if (first && (first = 0, !nflag) 506 && (fp = fopen("/etc/atalk.names", "r"))) { 507 char line[256]; 508 int i1, i2; 509 510 while (fgets(line, sizeof(line), fp)) { 511 if (line[0] == '\n' || line[0] == 0 || line[0] == '#') 512 continue; 513 if (sscanf(line, "%d.%d %s", &i1, &i2, nambuf) == 3) 514 /* got a hostname. */ 515 i2 |= (i1 << 8); 516 else if (sscanf(line, "%d %s", &i1, nambuf) == 2) 517 /* got a net name */ 518 i2 = (i1 << 8) | 255; 519 else 520 continue; 521 522 for (tp = &hnametable[i2 & (HASHNAMESIZE-1)]; 523 tp->nxt; tp = tp->nxt) 524 ; 525 tp->addr = i2; 526 tp->nxt = newhnamemem(); 527 tp->name = savestr(nambuf); 528 } 529 fclose(fp); 530 } 531 532 for (tp = &hnametable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt) 533 if (tp->addr == i) 534 return (tp->name); 535 536 /* didn't have the node name -- see if we've got the net name */ 537 i |= 255; 538 for (tp2 = &hnametable[i & (HASHNAMESIZE-1)]; tp2->nxt; tp2 = tp2->nxt) 539 if (tp2->addr == i) { 540 tp->addr = (atnet << 8) | athost; 541 tp->nxt = newhnamemem(); 542 (void)sprintf(nambuf, "%s.%d", tp2->name, athost); 543 tp->name = savestr(nambuf); 544 return (tp->name); 545 } 546 547 tp->addr = (atnet << 8) | athost; 548 tp->nxt = newhnamemem(); 549 if (athost != 255) 550 (void)sprintf(nambuf, "%d.%d", atnet, athost); 551 else 552 (void)sprintf(nambuf, "%d", atnet); 553 tp->name = savestr(nambuf); 554 555 return (tp->name); 556} 557 558static struct tok skt2str[] = { 559 { rtmpSkt, "rtmp" }, /* routing table maintenance */ 560 { nbpSkt, "nis" }, /* name info socket */ 561 { echoSkt, "echo" }, /* AppleTalk echo protocol */ 562 { zipSkt, "zip" }, /* zone info protocol */ 563 { 0, NULL } 564}; 565 566static const char * 567ddpskt_string(register int skt) 568{ 569 static char buf[8]; 570 571 if (nflag) { 572 (void)sprintf(buf, "%d", skt); 573 return (buf); 574 } 575 return (tok2str(skt2str, "%d", skt)); 576} 577