src/rxdebug/rxdebug.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13
  14 #include <sys/types.h>
  15 #include <errno.h>
  16 #ifdef AFS_NT40_ENV
  17 #include <winsock2.h>
  18 #else
  19 #include <sys/socket.h>
  20 #include <sys/file.h>
  21 #include <netdb.h>
  22 #include <arpa/inet.h>
  23 #endif
  24 #ifdef HAVE_NETINET_IN_H
  25 #include <netinet/in.h>
  26 #endif
  27 #ifdef HAVE_SYS_TIME_H
  28 #include <sys/time.h>
  29 #endif
  30 #ifdef HAVE_UNISTD_H
  31 #include <unistd.h>
  32 #endif
  33 #include <string.h>
  34 #include <sys/stat.h>
  35 #include <afs/afsutil.h>
  36 #include <afs/stds.h>
  37 #include <afs/cmd.h>
  38
  39 #include <stdio.h>
  40
  41 #include <rx/rx_user.h>
  42 #include <rx/rx_clock.h>
  43 #include <rx/rx_queue.h>
  44 #include <rx/rx.h>
  45 #include <rx/rx_globals.h>
  46
  47
  48 #define TIMEOUT     20
  49
  50 static short
  51 PortNumber(char *aport)
  52 {
  53     register int tc;
  54     register short total;
  55
  56     total = 0;
  57     while ((tc = *aport++)) {
  58         if (tc < '0' || tc > '9')
  59             return -1;          /* bad port number */
  60         total *= 10;
  61         total += tc - (int)'0';
  62     }
  63     return htons(total);
  64 }
  65
  66 static short
  67 PortName(char *aname)
  68 {
  69     register struct servent *ts;
  70     ts = getservbyname(aname, NULL);
  71     if (!ts)
  72         return -1;
  73     return ts->s_port;          /* returns it in network byte order */
  74 }
  75
  76 int
  77 MainCommand(struct cmd_syndesc *as, void *arock)
  78 {
  79     register int i;
  80     osi_socket s;
  81     int j;
  82     struct sockaddr_in taddr;
  83     afs_int32 host;
  84     struct in_addr hostAddr;
  85     short port;
  86     struct hostent *th;
  87     register afs_int32 code;
  88     int nodally;
  89     int allconns;
  90     int rxstats;
  91     int onlyClient, onlyServer;
  92     afs_int32 onlyHost;
  93     short onlyPort;
  94     int onlyAuth;
  95     int flag;
  96     int dallyCounter;
  97     int withSecStats;
  98     int withAllConn;
  99     int withRxStats;
 100     int withWaiters;
 101     int withIdleThreads;
 102     int withWaited;
 103     int withPeers;
 104     int withPackets;
 105     struct rx_debugStats tstats;
 106     char *portName, *hostName;
 107     char hoststr[20];
 108     struct rx_debugConn tconn;
 109     short noConns;
 110     short showPeers;
 111     short showLong;
 112     int version_flag;
 113     char version[64];
 114     afs_int32 length = 64;
 115
 116     afs_uint32 supportedDebugValues = 0;
 117     afs_uint32 supportedStatValues = 0;
 118     afs_uint32 supportedConnValues = 0;
 119     afs_uint32 supportedPeerValues = 0;
 120     afs_int32 nextconn = 0;
 121     afs_int32 nextpeer = 0;
 122
 123     nodally = (as->parms[2].items ? 1 : 0);
 124     allconns = (as->parms[3].items ? 1 : 0);
 125     rxstats = (as->parms[4].items ? 1 : 0);
 126     onlyServer = (as->parms[5].items ? 1 : 0);
 127     onlyClient = (as->parms[6].items ? 1 : 0);
 128     version_flag = (as->parms[10].items ? 1 : 0);
 129     noConns = (as->parms[11].items ? 1 : 0);
 130     showPeers = (as->parms[12].items ? 1 : 0);
 131     showLong = (as->parms[13].items ? 1 : 0);
 132
 133     if (as->parms[0].items)
 134         hostName = as->parms[0].items->data;
 135     else
 136         hostName = NULL;
 137
 138     if (as->parms[1].items)
 139         portName = as->parms[1].items->data;
 140     else
 141         portName = NULL;
 142
 143     if (as->parms[7].items) {
 144         char *name = as->parms[7].items->data;
 145         if ((onlyPort = PortNumber(name)) == -1)
 146             onlyPort = PortName(name);
 147         if (onlyPort == -1) {
 148             printf("rxdebug: can't resolve port name %s\n", name);
 149             exit(1);
 150         }
 151     } else
 152         onlyPort = -1;
 153
 154     if (as->parms[8].items) {
 155         char *name = as->parms[8].items->data;
 156         struct hostent *th;
 157         th = hostutil_GetHostByName(name);
 158         if (!th) {
 159             printf("rxdebug: host %s not found in host table\n", name);
 160             exit(1);
 161         }
 162         memcpy(&onlyHost, th->h_addr, sizeof(afs_int32));
 163     } else
 164         onlyHost = -1;
 165
 166     if (as->parms[9].items) {
 167         char *name = as->parms[9].items->data;
 168         if (strcmp(name, "clear") == 0)
 169             onlyAuth = 0;
 170         else if (strcmp(name, "auth") == 0)
 171             onlyAuth = 1;
 172         else if (strcmp(name, "crypt") == 0)
 173             onlyAuth = 2;
 174         else if ((strcmp(name, "null") == 0) || (strcmp(name, "none") == 0)
 175                  || (strncmp(name, "noauth", 6) == 0)
 176                  || (strncmp(name, "unauth", 6) == 0))
 177             onlyAuth = -1;
 178         else {
 179             fprintf(stderr, "Unknown authentication level: %s\n", name);
 180             exit(1);
 181         }
 182     } else
 183         onlyAuth = 999;
 184
 185     /* lookup host */
 186     if (hostName) {
 187         th = hostutil_GetHostByName(hostName);
 188         if (!th) {
 189             printf("rxdebug: host %s not found in host table\n", hostName);
 190             exit(1);
 191         }
 192         memcpy(&host, th->h_addr, sizeof(afs_int32));
 193     } else
 194         host = htonl(0x7f000001);       /* IP localhost */
 195
 196     if (!portName)
 197         port = htons(7000);     /* default is fileserver */
 198     else {
 199         if ((port = PortNumber(portName)) == -1)
 200             port = PortName(portName);
 201         if (port == -1) {
 202             printf("rxdebug: can't resolve port name %s\n", portName);
 203             exit(1);
 204         }
 205     }
 206
 207     dallyCounter = 0;
 208
 209     hostAddr.s_addr = host;
 210     afs_inet_ntoa_r(hostAddr.s_addr, hoststr);
 211     printf("Trying %s (port %d):\n", hoststr, ntohs(port));
 212     s = socket(AF_INET, SOCK_DGRAM, 0);
 213     taddr.sin_family = AF_INET;
 214     taddr.sin_port = 0;
 215     taddr.sin_addr.s_addr = 0;
 216 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
 217     taddr.sin_len = sizeof(struct sockaddr_in);
 218 #endif
 219     code = bind(s, (struct sockaddr *)&taddr, sizeof(struct sockaddr_in));
 220     if (code) {
 221         perror("bind");
 222         exit(1);
 223     }
 224
 225     if (version_flag) {
 226
 227         code = rx_GetServerVersion(s, host, port, length, version);
 228         if (code < 0) {
 229             printf("get version call failed with code %d, errno %d\n", code,
 230                    errno);
 231             exit(1);
 232         }
 233         printf("AFS version: %s\n", version);
 234         fflush(stdout);
 235
 236         exit(0);
 237
 238     }
 239
 240
 241     code = rx_GetServerDebug(s, host, port, &tstats, &supportedDebugValues);
 242     if (code < 0) {
 243         printf("getstats call failed with code %d\n", code);
 244         exit(1);
 245     }
 246
 247     withSecStats = (supportedDebugValues & RX_SERVER_DEBUG_SEC_STATS);
 248     withAllConn = (supportedDebugValues & RX_SERVER_DEBUG_ALL_CONN);
 249     withRxStats = (supportedDebugValues & RX_SERVER_DEBUG_RX_STATS);
 250     withWaiters = (supportedDebugValues & RX_SERVER_DEBUG_WAITER_CNT);
 251     withIdleThreads = (supportedDebugValues & RX_SERVER_DEBUG_IDLE_THREADS);
 252     withWaited = (supportedDebugValues & RX_SERVER_DEBUG_WAITED_CNT);
 253     withPeers = (supportedDebugValues & RX_SERVER_DEBUG_ALL_PEER);
 254     withPackets = (supportedDebugValues & RX_SERVER_DEBUG_PACKETS_CNT);
 255
 256     if (withPackets)
 257         printf("Free packets: %d/%d, packet reclaims: %d, calls: %d, used FDs: %d\n",
 258                tstats.nFreePackets, tstats.nPackets, tstats.packetReclaims,
 259                tstats.callsExecuted, tstats.usedFDs);
 260     else
 261         printf("Free packets: %d, packet reclaims: %d, calls: %d, used FDs: %d\n",
 262                tstats.nFreePackets, tstats.packetReclaims, tstats.callsExecuted,
 263                tstats.usedFDs);
 264     if (!tstats.waitingForPackets)
 265         printf("not ");
 266     printf("waiting for packets.\n");
 267     if (withWaiters)
 268         printf("%d calls waiting for a thread\n", tstats.nWaiting);
 269     if (withIdleThreads)
 270         printf("%d threads are idle\n", tstats.idleThreads);
 271     if (withWaited)
 272         printf("%d calls have waited for a thread\n", tstats.nWaited);
 273
 274     if (rxstats) {
 275         if (!withRxStats) {
 276           noRxStats:
 277             withRxStats = 0;
 278             fprintf(stderr,
 279                     "WARNING: Server doesn't support retrieval of Rx statistics\n");
 280         } else {
 281             union {
 282                 struct rx_statistics rxstats;
 283                 struct rx_debugIn debug;
 284             } packet;
 285
 286             /* should gracefully handle the case where rx_stats grows */
 287             code =
 288                 rx_GetServerStats(s, host, port, &packet.rxstats,
 289                                   &supportedStatValues);
 290             if (code < 0) {
 291                 printf("rxstats call failed with code %d\n", code);
 292                 exit(1);
 293             }
 294             if (code != sizeof(packet.rxstats)) {
 295                 if (packet.debug.type == RX_DEBUGI_BADTYPE)
 296                     goto noRxStats;
 297                 printf
 298                     ("WARNING: returned Rx statistics of unexpected size (got %d)\n",
 299                      code);
 300                 /* handle other versions?... */
 301             }
 302
 303             rx_PrintTheseStats(stdout, &packet.rxstats, sizeof(packet.rxstats),
 304                                tstats.nFreePackets, tstats.version);
 305         }
 306     }
 307
 308     if (!noConns) {
 309         if (allconns) {
 310             if (!withAllConn)
 311                 fprintf(stderr,
 312                         "WARNING: Server doesn't support retrieval of all connections,\n         getting only interesting instead.\n");
 313         }
 314
 315         if (onlyServer)
 316             printf("Showing only server connections\n");
 317         if (onlyClient)
 318             printf("Showing only client connections\n");
 319         if (onlyAuth != 999) {
 320             static char *name[] =
 321                 { "unauthenticated", "rxkad_clear", "rxkad_auth",
 322                 "rxkad_crypt"
 323             };
 324             printf("Showing only %s connections\n", name[onlyAuth + 1]);
 325         }
 326         if (onlyHost != -1) {
 327             hostAddr.s_addr = onlyHost;
 328             afs_inet_ntoa_r(hostAddr.s_addr, hoststr);
 329             printf("Showing only connections from host %s\n",
 330                    hoststr);
 331         }
 332         if (onlyPort != -1)
 333             printf("Showing only connections on port %u\n", ntohs(onlyPort));
 334
 335         for (i = 0;; i++) {
 336             code =
 337                 rx_GetServerConnections(s, host, port, &nextconn, allconns,
 338                                         supportedDebugValues, &tconn,
 339                                         &supportedConnValues);
 340             if (code < 0) {
 341                 printf("getconn call failed with code %d\n", code);
 342                 break;
 343             }
 344             if (tconn.cid == (afs_int32) 0xffffffff) {
 345                 printf("Done.\n");
 346                 break;
 347             }
 348
 349             /* see if we're in nodally mode and all calls are dallying */
 350             if (nodally) {
 351                 flag = 0;
 352                 for (j = 0; j < RX_MAXCALLS; j++) {
 353                     if (tconn.callState[j] != RX_STATE_NOTINIT
 354                         && tconn.callState[j] != RX_STATE_DALLY) {
 355                         flag = 1;
 356                         break;
 357                     }
 358                 }
 359                 if (flag == 0) {
 360                     /* this call looks too ordinary, bump skipped count and go
 361                      * around again */
 362                     dallyCounter++;
 363                     continue;
 364                 }
 365             }
 366             if ((onlyHost != -1) && (onlyHost != tconn.host))
 367                 continue;
 368             if ((onlyPort != -1) && (onlyPort != tconn.port))
 369                 continue;
 370             if (onlyServer && (tconn.type != RX_SERVER_CONNECTION))
 371                 continue;
 372             if (onlyClient && (tconn.type != RX_CLIENT_CONNECTION))
 373                 continue;
 374             if (onlyAuth != 999) {
 375                 if (onlyAuth == -1) {
 376                     if (tconn.securityIndex != 0)
 377                         continue;
 378                 } else {
 379                     if (tconn.securityIndex != 2)
 380                         continue;
 381                     if (withSecStats && (tconn.secStats.type == 3)
 382                         && (tconn.secStats.level != onlyAuth))
 383                         continue;
 384                 }
 385             }
 386
 387             /* now display the connection */
 388             hostAddr.s_addr = tconn.host;
 389             afs_inet_ntoa_r(hostAddr.s_addr, hoststr);
 390             printf("Connection from host %s, port %hu, ", hoststr,
 391                    ntohs(tconn.port));
 392             if (tconn.epoch)
 393                 printf("Cuid %x/%x", tconn.epoch, tconn.cid);
 394             else
 395                 printf("cid %x", tconn.cid);
 396             if (tconn.error)
 397                 printf(", error %d", tconn.error);
 398             printf("\n  serial %d, ", tconn.serial);
 399             printf(" natMTU %d, ", tconn.natMTU);
 400
 401             if (tconn.flags) {
 402                 printf("flags");
 403                 if (tconn.flags & RX_CONN_MAKECALL_WAITING)
 404                     printf(" MAKECALL_WAITING");
 405                 if (tconn.flags & RX_CONN_DESTROY_ME)
 406                     printf(" DESTROYED");
 407                 if (tconn.flags & RX_CONN_USING_PACKET_CKSUM)
 408                     printf(" pktCksum");
 409                 if (tconn.flags & RX_CONN_KNOW_WINDOW)
 410                     printf(" knowWindow");
 411                 if (tconn.flags & RX_CONN_RESET)
 412                     printf(" reset");
 413                 if (tconn.flags & RX_CONN_BUSY)
 414                     printf(" busy");
 415                 if (tconn.flags & RX_CONN_ATTACHWAIT)
 416                     printf(" attachWait");
 417                 printf(", ");
 418             }
 419             printf("security index %d, ", tconn.securityIndex);
 420             if (tconn.type == RX_CLIENT_CONNECTION)
 421                 printf("client conn\n");
 422             else
 423                 printf("server conn\n");
 424
 425             if (withSecStats) {
 426                 switch ((int)tconn.secStats.type) {
 427                 case 0:
 428                     if (tconn.securityIndex == 2)
 429                         printf
 430                             ("  no GetStats procedure for security object\n");
 431                     break;
 432                 case 1:
 433                     printf("  rxnull level=%d, flags=%d\n",
 434                            tconn.secStats.level, tconn.secStats.flags);
 435                     break;
 436                 case 2:
 437                     printf("  rxvab level=%d, flags=%d\n",
 438                            tconn.secStats.level, tconn.secStats.flags);
 439                     break;
 440                 case 3:{
 441                         char *level;
 442                         char flags = tconn.secStats.flags;
 443                         if (tconn.secStats.level == 0)
 444                             level = "clear";
 445                         else if (tconn.secStats.level == 1)
 446                             level = "auth";
 447                         else if (tconn.secStats.level == 2)
 448                             level = "crypt";
 449                         else
 450                             level = "unknown";
 451                         printf("  rxkad: level %s", level);
 452                         if (flags)
 453                             printf(", flags");
 454                         if (flags & 1)
 455                             printf(" unalloc");
 456                         if (flags & 2)
 457                             printf(" authenticated");
 458                         if (flags & 4)
 459                             printf(" expired");
 460                         if (flags & 8)
 461                             printf(" pktCksum");
 462                         if (tconn.secStats.expires)
 463                             /* Apparently due to a bug in the RT compiler that
 464                              * prevents (afs_uint32)0xffffffff => (double) from working,
 465                              * this code produces negative lifetimes when run on the
 466                              * RT. */
 467                             printf(", expires in %.1f hours",
 468                                    ((afs_uint32) tconn.secStats.expires -
 469                                     time(0)) / 3600.0);
 470                         if (!(flags & 1)) {
 471                             printf("\n  Received %u bytes in %u packets\n",
 472                                    tconn.secStats.bytesReceived,
 473                                    tconn.secStats.packetsReceived);
 474                             printf("  Sent %u bytes in %u packets\n",
 475                                    tconn.secStats.bytesSent,
 476                                    tconn.secStats.packetsSent);
 477                         } else
 478                             printf("\n");
 479                         break;
 480                     }
 481
 482                 default:
 483                     printf("  unknown\n");
 484                 }
 485             }
 486
 487             for (j = 0; j < RX_MAXCALLS; j++) {
 488                 printf("    call %d: # %d, state ", j, tconn.callNumber[j]);
 489                 if (tconn.callState[j] == RX_STATE_NOTINIT) {
 490                     printf("not initialized\n");
 491                     continue;
 492                 } else if (tconn.callState[j] == RX_STATE_PRECALL)
 493                     printf("precall, ");
 494                 else if (tconn.callState[j] == RX_STATE_ACTIVE)
 495                     printf("active, ");
 496                 else if (tconn.callState[j] == RX_STATE_DALLY)
 497                     printf("dally, ");
 498                 else if (tconn.callState[j] == RX_STATE_HOLD)
 499                     printf("hold, ");
 500                 printf("mode: ");
 501                 if (tconn.callMode[j] == RX_MODE_SENDING)
 502                     printf("sending");
 503                 else if (tconn.callMode[j] == RX_MODE_RECEIVING)
 504                     printf("receiving");
 505                 else if (tconn.callMode[j] == RX_MODE_ERROR)
 506                     printf("error");
 507                 else if (tconn.callMode[j] == RX_MODE_EOF)
 508                     printf("eof");
 509                 else
 510                     printf("unknown");
 511                 if (tconn.callFlags[j]) {
 512                     printf(", flags:");
 513                     if (tconn.callFlags[j] & RX_CALL_READER_WAIT)
 514                         printf(" reader_wait");
 515                     if (tconn.callFlags[j] & RX_CALL_WAIT_WINDOW_ALLOC)
 516                         printf(" window_alloc");
 517                     if (tconn.callFlags[j] & RX_CALL_WAIT_WINDOW_SEND)
 518                         printf(" window_send");
 519                     if (tconn.callFlags[j] & RX_CALL_WAIT_PACKETS)
 520                         printf(" wait_packets");
 521                     if (tconn.callFlags[j] & RX_CALL_WAIT_PROC)
 522                         printf(" waiting_for_process");
 523                     if (tconn.callFlags[j] & RX_CALL_RECEIVE_DONE)
 524                         printf(" receive_done");
 525                     if (tconn.callFlags[j] & RX_CALL_CLEARED)
 526                         printf(" call_cleared");
 527                 }
 528                 if (tconn.callOther[j] & RX_OTHER_IN)
 529                     printf(", has_input_packets");
 530                 if (tconn.callOther[j] & RX_OTHER_OUT)
 531                     printf(", has_output_packets");
 532                 printf("\n");
 533             }
 534         }
 535         if (nodally)
 536             printf("Skipped %d dallying connections.\n", dallyCounter);
 537     }
 538     if (showPeers && withPeers) {
 539         for (i = 0;; i++) {
 540             struct rx_debugPeer tpeer;
 541             code =
 542                 rx_GetServerPeers(s, host, port, &nextpeer, allconns, &tpeer,
 543                                   &supportedPeerValues);
 544             if (code < 0) {
 545                 printf("getpeer call failed with code %d\n", code);
 546                 break;
 547             }
 548             if (tpeer.host == 0xffffffff) {
 549                 printf("Done.\n");
 550                 break;
 551             }
 552
 553             if ((onlyHost != -1) && (onlyHost != tpeer.host))
 554                 continue;
 555             if ((onlyPort != -1) && (onlyPort != tpeer.port))
 556                 continue;
 557
 558             /* now display the peer */
 559             hostAddr.s_addr = tpeer.host;
 560             afs_inet_ntoa_r(hostAddr.s_addr, hoststr);
 561             printf("Peer at host %s, port %hu\n", hoststr,
 562                    ntohs(tpeer.port));
 563             printf("\tifMTU %hu\tnatMTU %hu\tmaxMTU %hu\n", tpeer.ifMTU,
 564                    tpeer.natMTU, tpeer.maxMTU);
 565             printf("\tpackets sent %u\tpacket resends %u\n", tpeer.nSent,
 566                    tpeer.reSends);
 567             printf("\tbytes sent high %u low %u\n", tpeer.bytesSent.high,
 568                    tpeer.bytesSent.low);
 569             printf("\tbytes received high %u low %u\n",
 570                    tpeer.bytesReceived.high, tpeer.bytesReceived.low);
 571             printf("\trtt %u msec, rtt_dev %u msec\n", tpeer.rtt >> 3,
 572                    tpeer.rtt_dev >> 2);
 573             printf("\ttimeout %u.%03u sec\n", tpeer.timeout.sec,
 574                    tpeer.timeout.usec / 1000);
 575             if (!showLong)
 576                 continue;
 577
 578             printf("\tin/out packet skew: %d/%d\n", tpeer.inPacketSkew,
 579                     tpeer.outPacketSkew);
 580             printf("\tcongestion window %d, MTU %d\n", tpeer.cwind,
 581                    tpeer.MTU);
 582             printf("\tcurrent/if/max jumbogram size: %d/%d/%d\n",
 583                    tpeer.nDgramPackets, tpeer.ifDgramPackets,
 584                    tpeer.maxDgramPackets);
 585         }
 586     }
 587     exit(0);
 588 }
 589
 590 /* simple main program */
 591 #ifndef AFS_NT40_ENV
 592 #include "AFS_component_version_number.c"
 593 #endif
 594 int
 595 main(int argc, char **argv)
 596 {
 597     struct cmd_syndesc *ts;
 598
 599 #ifdef RXDEBUG
 600     rxi_DebugInit();
 601 #endif
 602 #ifdef AFS_NT40_ENV
 603     if (afs_winsockInit() < 0) {
 604         printf("%s: Couldn't initialize winsock. Exiting...\n", argv[0]);
 605         return 1;
 606     }
 607 #endif
 608
 609     ts = cmd_CreateSyntax(NULL, MainCommand, NULL, "probe RX server");
 610     cmd_AddParm(ts, "-servers", CMD_SINGLE, CMD_REQUIRED, "server machine");
 611     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "IP port");
 612     cmd_AddParm(ts, "-nodally", CMD_FLAG, CMD_OPTIONAL,
 613                 "don't show dallying conns");
 614     cmd_AddParm(ts, "-allconnections", CMD_FLAG, CMD_OPTIONAL,
 615                 "don't filter out uninteresting connections on server");
 616     cmd_AddParm(ts, "-rxstats", CMD_FLAG, CMD_OPTIONAL, "show Rx statistics");
 617     cmd_AddParm(ts, "-onlyserver", CMD_FLAG, CMD_OPTIONAL,
 618                 "only show server conns");
 619     cmd_AddParm(ts, "-onlyclient", CMD_FLAG, CMD_OPTIONAL,
 620                 "only show client conns");
 621     cmd_AddParm(ts, "-onlyport", CMD_SINGLE, CMD_OPTIONAL,
 622                 "show only <port>");
 623     cmd_AddParm(ts, "-onlyhost", CMD_SINGLE, CMD_OPTIONAL,
 624                 "show only <host>");
 625     cmd_AddParm(ts, "-onlyauth", CMD_SINGLE, CMD_OPTIONAL,
 626                 "show only <auth level>");
 627
 628     cmd_AddParm(ts, "-version", CMD_FLAG, CMD_OPTIONAL,
 629                 "show AFS version id");
 630     cmd_AddParm(ts, "-noconns", CMD_FLAG, CMD_OPTIONAL,
 631                 "show no connections");
 632     cmd_AddParm(ts, "-peers", CMD_FLAG, CMD_OPTIONAL, "show peers");
 633     cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "detailed output");
 634
 635     cmd_Dispatch(argc, argv);
 636     exit(0);
 637 }