contrib/tcpdump/print-decnet.c

   1 /*
   2  * Copyright (c) 1992, 1993, 1994, 1995, 1996, 1997
   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
  22 #ifndef lint
  23 static const char rcsid[] =
  24     "@(#) $Header: /tcpdump/master/tcpdump/print-decnet.c,v 1.30 2000/09/28 06:42:57 guy Exp $ (LBL)";
  25 #endif
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <sys/param.h>
  32 #include <sys/time.h>
  33 #include <sys/socket.h>
  34
  35 struct mbuf;
  36 struct rtentry;
  37
  38 #ifdef  HAVE_LIBDNET
  39 #include <netdnet/dnetdb.h>
  40 #endif
  41
  42 #include <ctype.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47
  48 #include "decnet.h"
  49 #include "extract.h"
  50 #include "interface.h"
  51 #include "addrtoname.h"
  52
  53 /* Forwards */
  54 static void print_decnet_ctlmsg(const union routehdr *, u_int);
  55 static void print_t_info(int);
  56 static void print_l1_routes(const char *, u_int);
  57 static void print_l2_routes(const char *, u_int);
  58 static void print_i_info(int);
  59 static void print_elist(const char *, u_int);
  60 static void print_nsp(const u_char *, u_int);
  61 static void print_reason(int);
  62 #ifdef  PRINT_NSPDATA
  63 static void pdata(u_char *, int);
  64 #endif
  65
  66 #ifdef  HAVE_LIBDNET
  67 extern char *dnet_htoa(struct dn_naddr *);
  68 #endif
  69
  70 void
  71 decnet_print(register const u_char *ap, register u_int length,
  72              register u_int caplen)
  73 {
  74         static union routehdr rhcopy;
  75         register union routehdr *rhp = &rhcopy;
  76         register int mflags;
  77         int dst, src, hops;
  78         u_int rhlen, nsplen, pktlen;
  79         const u_char *nspp;
  80
  81         if (length < sizeof(struct shorthdr)) {
  82                 (void)printf("[|decnet]");
  83                 return;
  84         }
  85
  86         pktlen = EXTRACT_LE_16BITS(ap);
  87
  88         rhlen = min(length, caplen);
  89         rhlen = min(rhlen, sizeof(*rhp));
  90         memcpy((char *)rhp, (char *)&(ap[sizeof(short)]), rhlen);
  91
  92         mflags = EXTRACT_LE_8BITS(rhp->rh_short.sh_flags);
  93
  94         if (mflags & RMF_PAD) {
  95             /* pad bytes of some sort in front of message */
  96             u_int padlen = mflags & RMF_PADMASK;
  97             if (vflag)
  98                 (void) printf("[pad:%d] ", padlen);
  99             ap += padlen;
 100             length -= padlen;
 101             caplen -= padlen;
 102             rhlen = min(length, caplen);
 103             rhlen = min(rhlen, sizeof(*rhp));
 104             memcpy((char *)rhp, (char *)&(ap[sizeof(short)]), rhlen);
 105             mflags = EXTRACT_LE_8BITS(rhp->rh_short.sh_flags);
 106         }
 107
 108         if (mflags & RMF_FVER) {
 109                 (void) printf("future-version-decnet");
 110                 default_print(ap, length);
 111                 return;
 112         }
 113
 114         /* is it a control message? */
 115         if (mflags & RMF_CTLMSG) {
 116                 print_decnet_ctlmsg(rhp, min(length, caplen));
 117                 return;
 118         }
 119
 120         switch (mflags & RMF_MASK) {
 121         case RMF_LONG:
 122             dst =
 123                 EXTRACT_LE_16BITS(rhp->rh_long.lg_dst.dne_remote.dne_nodeaddr);
 124             src =
 125                 EXTRACT_LE_16BITS(rhp->rh_long.lg_src.dne_remote.dne_nodeaddr);
 126             hops = EXTRACT_LE_8BITS(rhp->rh_long.lg_visits);
 127             nspp = &(ap[sizeof(short) + sizeof(struct longhdr)]);
 128             nsplen = min((length - sizeof(struct longhdr)),
 129                          (caplen - sizeof(struct longhdr)));
 130             break;
 131         case RMF_SHORT:
 132             dst = EXTRACT_LE_16BITS(rhp->rh_short.sh_dst);
 133             src = EXTRACT_LE_16BITS(rhp->rh_short.sh_src);
 134             hops = (EXTRACT_LE_8BITS(rhp->rh_short.sh_visits) & VIS_MASK)+1;
 135             nspp = &(ap[sizeof(short) + sizeof(struct shorthdr)]);
 136             nsplen = min((length - sizeof(struct shorthdr)),
 137                          (caplen - sizeof(struct shorthdr)));
 138             break;
 139         default:
 140             (void) printf("unknown message flags under mask");
 141             default_print((u_char *)ap, length);
 142             return;
 143         }
 144
 145         (void)printf("%s > %s %d ",
 146                         dnaddr_string(src), dnaddr_string(dst), pktlen);
 147         if (vflag) {
 148             if (mflags & RMF_RQR)
 149                 (void)printf("RQR ");
 150             if (mflags & RMF_RTS)
 151                 (void)printf("RTS ");
 152             if (mflags & RMF_IE)
 153                 (void)printf("IE ");
 154             (void)printf("%d hops ", hops);
 155         }
 156
 157         print_nsp(nspp, nsplen);
 158 }
 159
 160 static void
 161 print_decnet_ctlmsg(register const union routehdr *rhp, u_int length)
 162 {
 163         int mflags = EXTRACT_LE_8BITS(rhp->rh_short.sh_flags);
 164         register union controlmsg *cmp = (union controlmsg *)rhp;
 165         int src, dst, info, blksize, eco, ueco, hello, other, vers;
 166         etheraddr srcea, rtea;
 167         int priority;
 168         char *rhpx = (char *)rhp;
 169
 170         switch (mflags & RMF_CTLMASK) {
 171         case RMF_INIT:
 172             (void)printf("init ");
 173             src = EXTRACT_LE_16BITS(cmp->cm_init.in_src);
 174             info = EXTRACT_LE_8BITS(cmp->cm_init.in_info);
 175             blksize = EXTRACT_LE_16BITS(cmp->cm_init.in_blksize);
 176             vers = EXTRACT_LE_8BITS(cmp->cm_init.in_vers);
 177             eco = EXTRACT_LE_8BITS(cmp->cm_init.in_eco);
 178             ueco = EXTRACT_LE_8BITS(cmp->cm_init.in_ueco);
 179             hello = EXTRACT_LE_16BITS(cmp->cm_init.in_hello);
 180             print_t_info(info);
 181             (void)printf(
 182                 "src %sblksize %d vers %d eco %d ueco %d hello %d",
 183                         dnaddr_string(src), blksize, vers, eco, ueco,
 184                         hello);
 185             break;
 186         case RMF_VER:
 187             (void)printf("verification ");
 188             src = EXTRACT_LE_16BITS(cmp->cm_ver.ve_src);
 189             other = EXTRACT_LE_8BITS(cmp->cm_ver.ve_fcnval);
 190             (void)printf("src %s fcnval %o", dnaddr_string(src), other);
 191             break;
 192         case RMF_TEST:
 193             (void)printf("test ");
 194             src = EXTRACT_LE_16BITS(cmp->cm_test.te_src);
 195             other = EXTRACT_LE_8BITS(cmp->cm_test.te_data);
 196             (void)printf("src %s data %o", dnaddr_string(src), other);
 197             break;
 198         case RMF_L1ROUT:
 199             (void)printf("lev-1-routing ");
 200             src = EXTRACT_LE_16BITS(cmp->cm_l1rou.r1_src);
 201             (void)printf("src %s ", dnaddr_string(src));
 202             print_l1_routes(&(rhpx[sizeof(struct l1rout)]),
 203                                 length - sizeof(struct l1rout));
 204             break;
 205         case RMF_L2ROUT:
 206             (void)printf("lev-2-routing ");
 207             src = EXTRACT_LE_16BITS(cmp->cm_l2rout.r2_src);
 208             (void)printf("src %s ", dnaddr_string(src));
 209             print_l2_routes(&(rhpx[sizeof(struct l2rout)]),
 210                                 length - sizeof(struct l2rout));
 211             break;
 212         case RMF_RHELLO:
 213             (void)printf("router-hello ");
 214             vers = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_vers);
 215             eco = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_eco);
 216             ueco = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_ueco);
 217             memcpy((char *)&srcea, (char *)&(cmp->cm_rhello.rh_src),
 218                 sizeof(srcea));
 219             src = EXTRACT_LE_16BITS(srcea.dne_remote.dne_nodeaddr);
 220             info = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_info);
 221             blksize = EXTRACT_LE_16BITS(cmp->cm_rhello.rh_blksize);
 222             priority = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_priority);
 223             hello = EXTRACT_LE_16BITS(cmp->cm_rhello.rh_hello);
 224             print_i_info(info);
 225             (void)printf(
 226             "vers %d eco %d ueco %d src %s blksize %d pri %d hello %d",
 227                         vers, eco, ueco, dnaddr_string(src),
 228                         blksize, priority, hello);
 229             print_elist(&(rhpx[sizeof(struct rhellomsg)]),
 230                                 length - sizeof(struct rhellomsg));
 231             break;
 232         case RMF_EHELLO:
 233             (void)printf("endnode-hello ");
 234             vers = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_vers);
 235             eco = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_eco);
 236             ueco = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_ueco);
 237             memcpy((char *)&srcea, (char *)&(cmp->cm_ehello.eh_src),
 238                 sizeof(srcea));
 239             src = EXTRACT_LE_16BITS(srcea.dne_remote.dne_nodeaddr);
 240             info = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_info);
 241             blksize = EXTRACT_LE_16BITS(cmp->cm_ehello.eh_blksize);
 242             /*seed*/
 243             memcpy((char *)&rtea, (char *)&(cmp->cm_ehello.eh_router),
 244                 sizeof(rtea));
 245             dst = EXTRACT_LE_16BITS(rtea.dne_remote.dne_nodeaddr);
 246             hello = EXTRACT_LE_16BITS(cmp->cm_ehello.eh_hello);
 247             other = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_data);
 248             print_i_info(info);
 249             (void)printf(
 250         "vers %d eco %d ueco %d src %s blksize %d rtr %s hello %d data %o",
 251                         vers, eco, ueco, dnaddr_string(src),
 252                         blksize, dnaddr_string(dst), hello, other);
 253             break;
 254
 255         default:
 256             (void)printf("unknown control message");
 257             default_print((u_char *)rhp, length);
 258             break;
 259         }
 260 }
 261
 262 static void
 263 print_t_info(int info)
 264 {
 265         int ntype = info & 3;
 266         switch (ntype) {
 267         case 0: (void)printf("reserved-ntype? "); break;
 268         case TI_L2ROUT: (void)printf("l2rout "); break;
 269         case TI_L1ROUT: (void)printf("l1rout "); break;
 270         case TI_ENDNODE: (void)printf("endnode "); break;
 271         }
 272         if (info & TI_VERIF)
 273             (void)printf("verif ");
 274         if (info & TI_BLOCK)
 275             (void)printf("blo ");
 276 }
 277
 278 static void
 279 print_l1_routes(const char *rp, u_int len)
 280 {
 281         int count;
 282         int id;
 283         int info;
 284
 285         /* The last short is a checksum */
 286         while (len > (3 * sizeof(short))) {
 287             count = EXTRACT_LE_16BITS(rp);
 288             if (count > 1024)
 289                 return; /* seems to be bogus from here on */
 290             rp += sizeof(short);
 291             len -= sizeof(short);
 292             id = EXTRACT_LE_16BITS(rp);
 293             rp += sizeof(short);
 294             len -= sizeof(short);
 295             info = EXTRACT_LE_16BITS(rp);
 296             rp += sizeof(short);
 297             len -= sizeof(short);
 298             (void)printf("{ids %d-%d cost %d hops %d} ", id, id + count,
 299                             RI_COST(info), RI_HOPS(info));
 300         }
 301 }
 302
 303 static void
 304 print_l2_routes(const char *rp, u_int len)
 305 {
 306         int count;
 307         int area;
 308         int info;
 309
 310         /* The last short is a checksum */
 311         while (len > (3 * sizeof(short))) {
 312             count = EXTRACT_LE_16BITS(rp);
 313             if (count > 1024)
 314                 return; /* seems to be bogus from here on */
 315             rp += sizeof(short);
 316             len -= sizeof(short);
 317             area = EXTRACT_LE_16BITS(rp);
 318             rp += sizeof(short);
 319             len -= sizeof(short);
 320             info = EXTRACT_LE_16BITS(rp);
 321             rp += sizeof(short);
 322             len -= sizeof(short);
 323             (void)printf("{areas %d-%d cost %d hops %d} ", area, area + count,
 324                             RI_COST(info), RI_HOPS(info));
 325         }
 326 }
 327
 328 static void
 329 print_i_info(int info)
 330 {
 331         int ntype = info & II_TYPEMASK;
 332         switch (ntype) {
 333         case 0: (void)printf("reserved-ntype? "); break;
 334         case II_L2ROUT: (void)printf("l2rout "); break;
 335         case II_L1ROUT: (void)printf("l1rout "); break;
 336         case II_ENDNODE: (void)printf("endnode "); break;
 337         }
 338         if (info & II_VERIF)
 339             (void)printf("verif ");
 340         if (info & II_NOMCAST)
 341             (void)printf("nomcast ");
 342         if (info & II_BLOCK)
 343             (void)printf("blo ");
 344 }
 345
 346 static void
 347 print_elist(const char *elp, u_int len)
 348 {
 349         /* Not enough examples available for me to debug this */
 350 }
 351
 352 static void
 353 print_nsp(const u_char *nspp, u_int nsplen)
 354 {
 355         const struct nsphdr *nsphp = (struct nsphdr *)nspp;
 356         int dst, src, flags;
 357
 358         flags = EXTRACT_LE_8BITS(nsphp->nh_flags);
 359         dst = EXTRACT_LE_16BITS(nsphp->nh_dst);
 360         src = EXTRACT_LE_16BITS(nsphp->nh_src);
 361
 362         switch (flags & NSP_TYPEMASK) {
 363         case MFT_DATA:
 364             switch (flags & NSP_SUBMASK) {
 365             case MFS_BOM:
 366             case MFS_MOM:
 367             case MFS_EOM:
 368             case MFS_BOM+MFS_EOM:
 369                 printf("data %d>%d ", src, dst);
 370                 {
 371                     struct seghdr *shp = (struct seghdr *)nspp;
 372                     int ack;
 373 #ifdef  PRINT_NSPDATA
 374                     u_char *dp;
 375 #endif
 376                     u_int data_off = sizeof(struct minseghdr);
 377
 378                     ack = EXTRACT_LE_16BITS(shp->sh_seq[0]);
 379                     if (ack & SGQ_ACK) {        /* acknum field */
 380                         if ((ack & SGQ_NAK) == SGQ_NAK)
 381                             (void)printf("nak %d ", ack & SGQ_MASK);
 382                         else
 383                             (void)printf("ack %d ", ack & SGQ_MASK);
 384                         ack = EXTRACT_LE_16BITS(shp->sh_seq[1]);
 385                         data_off += sizeof(short);
 386                         if (ack & SGQ_OACK) {   /* ackoth field */
 387                             if ((ack & SGQ_ONAK) == SGQ_ONAK)
 388                                 (void)printf("onak %d ", ack & SGQ_MASK);
 389                             else
 390                                 (void)printf("oack %d ", ack & SGQ_MASK);
 391                             ack = EXTRACT_LE_16BITS(shp->sh_seq[2]);
 392                             data_off += sizeof(short);
 393                         }
 394                     }
 395                     (void)printf("seg %d ", ack & SGQ_MASK);
 396 #ifdef  PRINT_NSPDATA
 397                     dp = &(nspp[data_off]);
 398                     pdata(dp, 10);
 399 #endif
 400                 }
 401                 break;
 402             case MFS_ILS+MFS_INT:
 403                 printf("intr ");
 404                 {
 405                     struct seghdr *shp = (struct seghdr *)nspp;
 406                     int ack;
 407 #ifdef  PRINT_NSPDATA
 408                     u_char *dp;
 409 #endif
 410                     u_int data_off = sizeof(struct minseghdr);
 411
 412                     ack = EXTRACT_LE_16BITS(shp->sh_seq[0]);
 413                     if (ack & SGQ_ACK) {        /* acknum field */
 414                         if ((ack & SGQ_NAK) == SGQ_NAK)
 415                             (void)printf("nak %d ", ack & SGQ_MASK);
 416                         else
 417                             (void)printf("ack %d ", ack & SGQ_MASK);
 418                         ack = EXTRACT_LE_16BITS(shp->sh_seq[1]);
 419                         data_off += sizeof(short);
 420                         if (ack & SGQ_OACK) {   /* ackdat field */
 421                             if ((ack & SGQ_ONAK) == SGQ_ONAK)
 422                                 (void)printf("nakdat %d ", ack & SGQ_MASK);
 423                             else
 424                                 (void)printf("ackdat %d ", ack & SGQ_MASK);
 425                             ack = EXTRACT_LE_16BITS(shp->sh_seq[2]);
 426                             data_off += sizeof(short);
 427                         }
 428                     }
 429                     (void)printf("seg %d ", ack & SGQ_MASK);
 430 #ifdef  PRINT_NSPDATA
 431                     dp = &(nspp[data_off]);
 432                     pdata(dp, 10);
 433 #endif
 434                 }
 435                 break;
 436             case MFS_ILS:
 437                 (void)printf("link-service %d>%d ", src, dst);
 438                 {
 439                     struct seghdr *shp = (struct seghdr *)nspp;
 440                     struct lsmsg *lsmp =
 441                         (struct lsmsg *)&(nspp[sizeof(struct seghdr)]);
 442                     int ack;
 443                     int lsflags, fcval;
 444
 445                     ack = EXTRACT_LE_16BITS(shp->sh_seq[0]);
 446                     if (ack & SGQ_ACK) {        /* acknum field */
 447                         if ((ack & SGQ_NAK) == SGQ_NAK)
 448                             (void)printf("nak %d ", ack & SGQ_MASK);
 449                         else
 450                             (void)printf("ack %d ", ack & SGQ_MASK);
 451                         ack = EXTRACT_LE_16BITS(shp->sh_seq[1]);
 452                         if (ack & SGQ_OACK) {   /* ackdat field */
 453                             if ((ack & SGQ_ONAK) == SGQ_ONAK)
 454                                 (void)printf("nakdat %d ", ack & SGQ_MASK);
 455                             else
 456                                 (void)printf("ackdat %d ", ack & SGQ_MASK);
 457                             ack = EXTRACT_LE_16BITS(shp->sh_seq[2]);
 458                         }
 459                     }
 460                     (void)printf("seg %d ", ack & SGQ_MASK);
 461                     lsflags = EXTRACT_LE_8BITS(lsmp->ls_lsflags);
 462                     fcval = EXTRACT_LE_8BITS(lsmp->ls_fcval);
 463                     switch (lsflags & LSI_MASK) {
 464                     case LSI_DATA:
 465                         (void)printf("dat seg count %d ", fcval);
 466                         switch (lsflags & LSM_MASK) {
 467                         case LSM_NOCHANGE:
 468                             break;
 469                         case LSM_DONOTSEND:
 470                             (void)printf("donotsend-data ");
 471                             break;
 472                         case LSM_SEND:
 473                             (void)printf("send-data ");
 474                             break;
 475                         default:
 476                             (void)printf("reserved-fcmod? %x", lsflags);
 477                             break;
 478                         }
 479                         break;
 480                     case LSI_INTR:
 481                         (void)printf("intr req count %d ", fcval);
 482                         break;
 483                     default:
 484                         (void)printf("reserved-fcval-int? %x", lsflags);
 485                         break;
 486                     }
 487                 }
 488                 break;
 489             default:
 490                 (void)printf("reserved-subtype? %x %d > %d", flags, src, dst);
 491                 break;
 492             }
 493             break;
 494         case MFT_ACK:
 495             switch (flags & NSP_SUBMASK) {
 496             case MFS_DACK:
 497                 (void)printf("data-ack %d>%d ", src, dst);
 498                 {
 499                     struct ackmsg *amp = (struct ackmsg *)nspp;
 500                     int ack;
 501
 502                     ack = EXTRACT_LE_16BITS(amp->ak_acknum[0]);
 503                     if (ack & SGQ_ACK) {        /* acknum field */
 504                         if ((ack & SGQ_NAK) == SGQ_NAK)
 505                             (void)printf("nak %d ", ack & SGQ_MASK);
 506                         else
 507                             (void)printf("ack %d ", ack & SGQ_MASK);
 508                         ack = EXTRACT_LE_16BITS(amp->ak_acknum[1]);
 509                         if (ack & SGQ_OACK) {   /* ackoth field */
 510                             if ((ack & SGQ_ONAK) == SGQ_ONAK)
 511                                 (void)printf("onak %d ", ack & SGQ_MASK);
 512                             else
 513                                 (void)printf("oack %d ", ack & SGQ_MASK);
 514                         }
 515                     }
 516                 }
 517                 break;
 518             case MFS_IACK:
 519                 (void)printf("ils-ack %d>%d ", src, dst);
 520                 {
 521                     struct ackmsg *amp = (struct ackmsg *)nspp;
 522                     int ack;
 523
 524                     ack = EXTRACT_LE_16BITS(amp->ak_acknum[0]);
 525                     if (ack & SGQ_ACK) {        /* acknum field */
 526                         if ((ack & SGQ_NAK) == SGQ_NAK)
 527                             (void)printf("nak %d ", ack & SGQ_MASK);
 528                         else
 529                             (void)printf("ack %d ", ack & SGQ_MASK);
 530                         ack = EXTRACT_LE_16BITS(amp->ak_acknum[1]);
 531                         if (ack & SGQ_OACK) {   /* ackdat field */
 532                             if ((ack & SGQ_ONAK) == SGQ_ONAK)
 533                                 (void)printf("nakdat %d ", ack & SGQ_MASK);
 534                             else
 535                                 (void)printf("ackdat %d ", ack & SGQ_MASK);
 536                         }
 537                     }
 538                 }
 539                 break;
 540             case MFS_CACK:
 541                 (void)printf("conn-ack %d", dst);
 542                 break;
 543             default:
 544                 (void)printf("reserved-acktype? %x %d > %d", flags, src, dst);
 545                 break;
 546             }
 547             break;
 548         case MFT_CTL:
 549             switch (flags & NSP_SUBMASK) {
 550             case MFS_CI:
 551             case MFS_RCI:
 552                 if ((flags & NSP_SUBMASK) == MFS_CI)
 553                     (void)printf("conn-initiate ");
 554                 else
 555                     (void)printf("retrans-conn-initiate ");
 556                 (void)printf("%d>%d ", src, dst);
 557                 {
 558                     struct cimsg *cimp = (struct cimsg *)nspp;
 559                     int services, info, segsize;
 560 #ifdef  PRINT_NSPDATA
 561                     u_char *dp;
 562 #endif
 563
 564                     services = EXTRACT_LE_8BITS(cimp->ci_services);
 565                     info = EXTRACT_LE_8BITS(cimp->ci_info);
 566                     segsize = EXTRACT_LE_16BITS(cimp->ci_segsize);
 567
 568                     switch (services & COS_MASK) {
 569                     case COS_NONE:
 570                         break;
 571                     case COS_SEGMENT:
 572                         (void)printf("seg ");
 573                         break;
 574                     case COS_MESSAGE:
 575                         (void)printf("msg ");
 576                         break;
 577                     case COS_CRYPTSER:
 578                         (void)printf("crypt ");
 579                         break;
 580                     }
 581                     switch (info & COI_MASK) {
 582                     case COI_32:
 583                         (void)printf("ver 3.2 ");
 584                         break;
 585                     case COI_31:
 586                         (void)printf("ver 3.1 ");
 587                         break;
 588                     case COI_40:
 589                         (void)printf("ver 4.0 ");
 590                         break;
 591                     case COI_41:
 592                         (void)printf("ver 4.1 ");
 593                         break;
 594                     }
 595                     (void)printf("segsize %d ", segsize);
 596 #ifdef  PRINT_NSPDATA
 597                     dp = &(nspp[sizeof(struct cimsg)]);
 598                     pdata(dp, nsplen - sizeof(struct cimsg));
 599 #endif
 600                 }
 601                 break;
 602             case MFS_CC:
 603                 (void)printf("conn-confirm %d>%d ", src, dst);
 604                 {
 605                     struct ccmsg *ccmp = (struct ccmsg *)nspp;
 606                     int services, info;
 607                     u_int segsize, optlen;
 608 #ifdef  PRINT_NSPDATA
 609                     u_char *dp;
 610 #endif
 611
 612                     services = EXTRACT_LE_8BITS(ccmp->cc_services);
 613                     info = EXTRACT_LE_8BITS(ccmp->cc_info);
 614                     segsize = EXTRACT_LE_16BITS(ccmp->cc_segsize);
 615                     optlen = EXTRACT_LE_8BITS(ccmp->cc_optlen);
 616
 617                     switch (services & COS_MASK) {
 618                     case COS_NONE:
 619                         break;
 620                     case COS_SEGMENT:
 621                         (void)printf("seg ");
 622                         break;
 623                     case COS_MESSAGE:
 624                         (void)printf("msg ");
 625                         break;
 626                     case COS_CRYPTSER:
 627                         (void)printf("crypt ");
 628                         break;
 629                     }
 630                     switch (info & COI_MASK) {
 631                     case COI_32:
 632                         (void)printf("ver 3.2 ");
 633                         break;
 634                     case COI_31:
 635                         (void)printf("ver 3.1 ");
 636                         break;
 637                     case COI_40:
 638                         (void)printf("ver 4.0 ");
 639                         break;
 640                     case COI_41:
 641                         (void)printf("ver 4.1 ");
 642                         break;
 643                     }
 644                     (void)printf("segsize %d ", segsize);
 645                     if (optlen) {
 646                         (void)printf("optlen %d ", optlen);
 647 #ifdef  PRINT_NSPDATA
 648                         optlen = min(optlen, nsplen - sizeof(struct ccmsg));
 649                         dp = &(nspp[sizeof(struct ccmsg)]);
 650                         pdata(dp, optlen);
 651 #endif
 652                     }
 653                 }
 654                 break;
 655             case MFS_DI:
 656                 (void)printf("disconn-initiate %d>%d ", src, dst);
 657                 {
 658                     struct dimsg *dimp = (struct dimsg *)nspp;
 659                     int reason;
 660                     u_int optlen;
 661 #ifdef  PRINT_NSPDATA
 662                     u_char *dp;
 663 #endif
 664
 665                     reason = EXTRACT_LE_16BITS(dimp->di_reason);
 666                     optlen = EXTRACT_LE_8BITS(dimp->di_optlen);
 667
 668                     print_reason(reason);
 669                     if (optlen) {
 670                         (void)printf("optlen %d ", optlen);
 671 #ifdef  PRINT_NSPDATA
 672                         optlen = min(optlen, nsplen - sizeof(struct dimsg));
 673                         dp = &(nspp[sizeof(struct dimsg)]);
 674                         pdata(dp, optlen);
 675 #endif
 676                     }
 677                 }
 678                 break;
 679             case MFS_DC:
 680                 (void)printf("disconn-confirm %d>%d ", src, dst);
 681                 {
 682                     struct dcmsg *dcmp = (struct dcmsg *)nspp;
 683                     int reason;
 684
 685                     reason = EXTRACT_LE_16BITS(dcmp->dc_reason);
 686
 687                     print_reason(reason);
 688                 }
 689                 break;
 690             default:
 691                 (void)printf("reserved-ctltype? %x %d > %d", flags, src, dst);
 692                 break;
 693             }
 694             break;
 695         default:
 696             (void)printf("reserved-type? %x %d > %d", flags, src, dst);
 697             break;
 698         }
 699 }
 700
 701 static struct tok reason2str[] = {
 702         { UC_OBJREJECT,         "object rejected connect" },
 703         { UC_RESOURCES,         "insufficient resources" },
 704         { UC_NOSUCHNODE,        "unrecognized node name" },
 705         { DI_SHUT,              "node is shutting down" },
 706         { UC_NOSUCHOBJ,         "unrecognized object" },
 707         { UC_INVOBJFORMAT,      "invalid object name format" },
 708         { UC_OBJTOOBUSY,        "object too busy" },
 709         { DI_PROTOCOL,          "protocol error discovered" },
 710         { DI_TPA,               "third party abort" },
 711         { UC_USERABORT,         "user abort" },
 712         { UC_INVNODEFORMAT,     "invalid node name format" },
 713         { UC_LOCALSHUT,         "local node shutting down" },
 714         { DI_LOCALRESRC,        "insufficient local resources" },
 715         { DI_REMUSERRESRC,      "insufficient remote user resources" },
 716         { UC_ACCESSREJECT,      "invalid access control information" },
 717         { DI_BADACCNT,          "bad ACCOUNT information" },
 718         { UC_NORESPONSE,        "no response from object" },
 719         { UC_UNREACHABLE,       "node unreachable" },
 720         { DC_NOLINK,            "no link terminate" },
 721         { DC_COMPLETE,          "disconnect complete" },
 722         { DI_BADIMAGE,          "bad image data in connect" },
 723         { DI_SERVMISMATCH,      "cryptographic service mismatch" },
 724         { 0,                    NULL }
 725 };
 726
 727 static void
 728 print_reason(register int reason)
 729 {
 730         printf("%s ", tok2str(reason2str, "reason-%d", reason));
 731 }
 732
 733 char *
 734 dnnum_string(u_short dnaddr)
 735 {
 736         char *str;
 737         size_t siz;
 738         int area = (u_short)(dnaddr & AREAMASK) >> AREASHIFT;
 739         int node = dnaddr & NODEMASK;
 740
 741         str = (char *)malloc(siz = sizeof("00.0000"));
 742         if (str == NULL)
 743                 error("dnnum_string: malloc");
 744         snprintf(str, siz, "%d.%d", area, node);
 745         return(str);
 746 }
 747
 748 char *
 749 dnname_string(u_short dnaddr)
 750 {
 751 #ifdef  HAVE_LIBDNET
 752         struct dn_naddr dna;
 753
 754         dna.a_len = sizeof(short);
 755         memcpy((char *)dna.a_addr, (char *)&dnaddr, sizeof(short));
 756         return (savestr(dnet_htoa(&dna)));
 757 #else
 758         return(dnnum_string(dnaddr));   /* punt */
 759 #endif
 760 }
 761
 762 #ifdef  PRINT_NSPDATA
 763 static void
 764 pdata(u_char *dp, u_int maxlen)
 765 {
 766         char c;
 767         u_int x = maxlen;
 768
 769         while (x-- > 0) {
 770             c = *dp++;
 771             if (isprint(c))
 772                 putchar(c);
 773             else
 774                 printf("\\%o", c & 0xFF);
 775         }
 776 }
 777 #endif