Home | History | Annotate | Line # | Download | only in dist
print-stp.c revision 1.6 
      1 /*
      2  * Copyright (c) 2000 Lennert Buytenhek
      3  *
      4  * This software may be distributed either under the terms of the
      5  * BSD-style license that accompanies tcpdump or the GNU General
      6  * Public License
      7  *
      8  * Format and print IEEE 802.1d spanning tree protocol packets.
      9  * Contributed by Lennert Buytenhek <buytenh (at) gnu.org>
     10  */
     11 
     12 #include <sys/cdefs.h>
     13 #ifndef lint
     14 __RCSID("$NetBSD: print-stp.c,v 1.6 2017/01/24 23:29:14 christos Exp $");
     15 #endif
     16 
     17 #ifdef HAVE_CONFIG_H
     18 #include "config.h"
     19 #endif
     20 
     21 #include <netdissect-stdinc.h>
     22 
     23 #include <stdio.h>
     24 
     25 #include "netdissect.h"
     26 #include "extract.h"
     27 
     28 #define	RSTP_EXTRACT_PORT_ROLE(x) (((x)&0x0C)>>2)
     29 /* STP timers are expressed in multiples of 1/256th second */
     30 #define STP_TIME_BASE 256
     31 #define STP_BPDU_MSTP_MIN_LEN 102
     32 
     33 struct stp_bpdu_ {
     34     uint8_t protocol_id[2];
     35     uint8_t protocol_version;
     36     uint8_t bpdu_type;
     37     uint8_t flags;
     38     uint8_t root_id[8];
     39     uint8_t root_path_cost[4];
     40     uint8_t bridge_id[8];
     41     uint8_t port_id[2];
     42     uint8_t message_age[2];
     43     uint8_t max_age[2];
     44     uint8_t hello_time[2];
     45     uint8_t forward_delay[2];
     46     uint8_t v1_length;
     47 };
     48 
     49 #define STP_PROTO_REGULAR 0x00
     50 #define STP_PROTO_RAPID   0x02
     51 #define STP_PROTO_MSTP    0x03
     52 #define STP_PROTO_SPB     0x04
     53 
     54 static const struct tok stp_proto_values[] = {
     55     { STP_PROTO_REGULAR, "802.1d" },
     56     { STP_PROTO_RAPID, "802.1w" },
     57     { STP_PROTO_MSTP, "802.1s" },
     58     { STP_PROTO_SPB, "802.1aq" },
     59     { 0, NULL}
     60 };
     61 
     62 #define STP_BPDU_TYPE_CONFIG      0x00
     63 #define STP_BPDU_TYPE_RSTP        0x02
     64 #define STP_BPDU_TYPE_TOPO_CHANGE 0x80
     65 
     66 static const struct tok stp_bpdu_flag_values[] = {
     67     { 0x01, "Topology change" },
     68     { 0x02, "Proposal" },
     69     { 0x10, "Learn" },
     70     { 0x20, "Forward" },
     71     { 0x40, "Agreement" },
     72     { 0x80, "Topology change ACK" },
     73     { 0, NULL}
     74 };
     75 
     76 static const struct tok stp_bpdu_type_values[] = {
     77     { STP_BPDU_TYPE_CONFIG, "Config" },
     78     { STP_BPDU_TYPE_RSTP, "Rapid STP" },
     79     { STP_BPDU_TYPE_TOPO_CHANGE, "Topology Change" },
     80     { 0, NULL}
     81 };
     82 
     83 static const struct tok rstp_obj_port_role_values[] = {
     84     { 0x00, "Unknown" },
     85     { 0x01, "Alternate" },
     86     { 0x02, "Root" },
     87     { 0x03, "Designated" },
     88     { 0, NULL}
     89 };
     90 
     91 static char *
     92 stp_print_bridge_id(const u_char *p)
     93 {
     94     static char bridge_id_str[sizeof("pppp.aa:bb:cc:dd:ee:ff")];
     95 
     96     snprintf(bridge_id_str, sizeof(bridge_id_str),
     97              "%.2x%.2x.%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
     98              p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
     99 
    100     return bridge_id_str;
    101 }
    102 
    103 static void
    104 stp_print_config_bpdu(netdissect_options *ndo, const struct stp_bpdu_ *stp_bpdu,
    105                       u_int length)
    106 {
    107     ND_PRINT((ndo, ", Flags [%s]",
    108            bittok2str(stp_bpdu_flag_values, "none", stp_bpdu->flags)));
    109 
    110     ND_PRINT((ndo, ", bridge-id %s.%04x, length %u",
    111            stp_print_bridge_id((const u_char *)&stp_bpdu->bridge_id),
    112            EXTRACT_16BITS(&stp_bpdu->port_id), length));
    113 
    114     /* in non-verbose mode just print the bridge-id */
    115     if (!ndo->ndo_vflag) {
    116         return;
    117     }
    118 
    119     ND_PRINT((ndo, "\n\tmessage-age %.2fs, max-age %.2fs"
    120            ", hello-time %.2fs, forwarding-delay %.2fs",
    121            (float)EXTRACT_16BITS(&stp_bpdu->message_age) / STP_TIME_BASE,
    122            (float)EXTRACT_16BITS(&stp_bpdu->max_age) / STP_TIME_BASE,
    123            (float)EXTRACT_16BITS(&stp_bpdu->hello_time) / STP_TIME_BASE,
    124            (float)EXTRACT_16BITS(&stp_bpdu->forward_delay) / STP_TIME_BASE));
    125 
    126     ND_PRINT((ndo, "\n\troot-id %s, root-pathcost %u",
    127            stp_print_bridge_id((const u_char *)&stp_bpdu->root_id),
    128            EXTRACT_32BITS(&stp_bpdu->root_path_cost)));
    129 
    130     /* Port role is only valid for 802.1w */
    131     if (stp_bpdu->protocol_version == STP_PROTO_RAPID) {
    132         ND_PRINT((ndo, ", port-role %s",
    133                tok2str(rstp_obj_port_role_values, "Unknown",
    134                        RSTP_EXTRACT_PORT_ROLE(stp_bpdu->flags))));
    135     }
    136 }
    137 
    138 /*
    139  * MSTP packet format
    140  * Ref. IEEE 802.1Q 2003 Ed. Section 14
    141  *
    142  * MSTP BPDU
    143  *
    144  * 2 -  bytes Protocol Id
    145  * 1 -  byte  Protocol Ver.
    146  * 1 -  byte  BPDU tye
    147  * 1 -  byte  Flags
    148  * 8 -  bytes CIST Root Identifier
    149  * 4 -  bytes CIST External Path Cost
    150  * 8 -  bytes CIST Regional Root Identifier
    151  * 2 -  bytes CIST Port Identifier
    152  * 2 -  bytes Message Age
    153  * 2 -  bytes Max age
    154  * 2 -  bytes Hello Time
    155  * 2 -  bytes Forward delay
    156  * 1 -  byte  Version 1 length. Must be 0
    157  * 2 -  bytes Version 3 length
    158  * 1 -  byte  Config Identifier
    159  * 32 - bytes Config Name
    160  * 2 -  bytes Revision level
    161  * 16 - bytes Config Digest [MD5]
    162  * 4 -  bytes CIST Internal Root Path Cost
    163  * 8 -  bytes CIST Bridge Identifier
    164  * 1 -  byte  CIST Remaining Hops
    165  * 16 - bytes MSTI information [Max 64 MSTI, each 16 bytes]
    166  *
    167  *
    168  * SPB BPDU
    169  * Ref. IEEE 802.1aq. Section 14
    170  *
    171  * 2 -  bytes Version 4 length
    172  * 1 -  byte  Aux Config Identifier
    173  * 32 - bytes Aux Config Name
    174  * 2 -  bytes Aux Revision level
    175  * 16 - bytes Aux Config Digest [MD5]
    176  * 1 -  byte  (1 - 2) Agreement Number
    177  *            (3 - 4) Discarded Agreement Number
    178  *            (5) Agreement Valid Flag
    179  *            (6) Restricted Role Flag
    180  *            (7 - 8) Unused sent zero
    181  * 1 -  byte Unused
    182  * 1 -  byte (1 - 4) Agreement Digest Format Identifier
    183  *           (5 - 8) Agreement Digest Format Capabilities
    184  * 1 -  byte (1 - 4) Agreement Digest Convention Identifier
    185  *           (5 - 8) Agreement Digest Convention Capabilities
    186  * 2 -  bytes Agreement Digest Edge Count
    187  * 8 -  byte Reserved Set
    188  * 20 - bytes Computed Topology Digest
    189  *
    190  *
    191  * MSTI Payload
    192  *
    193  * 1 - byte  MSTI flag
    194  * 8 - bytes MSTI Regional Root Identifier
    195  * 4 - bytes MSTI Regional Path Cost
    196  * 1 - byte  MSTI Bridge Priority
    197  * 1 - byte  MSTI Port Priority
    198  * 1 - byte  MSTI Remaining Hops
    199  *
    200  */
    201 
    202 #define MST_BPDU_MSTI_LENGTH		    16
    203 #define MST_BPDU_CONFIG_INFO_LENGTH	    64
    204 
    205 /* Offsets of fields from the begginning for the packet */
    206 #define MST_BPDU_VER3_LEN_OFFSET	    36
    207 #define MST_BPDU_CONFIG_NAME_OFFSET	    39
    208 #define MST_BPDU_CONFIG_DIGEST_OFFSET	    73
    209 #define MST_BPDU_CIST_INT_PATH_COST_OFFSET  89
    210 #define MST_BPDU_CIST_BRIDGE_ID_OFFSET	    93
    211 #define MST_BPDU_CIST_REMAIN_HOPS_OFFSET    101
    212 #define MST_BPDU_MSTI_OFFSET		    102
    213 /* Offsets within  an MSTI */
    214 #define MST_BPDU_MSTI_ROOT_PRIO_OFFSET	    1
    215 #define MST_BPDU_MSTI_ROOT_PATH_COST_OFFSET 9
    216 #define MST_BPDU_MSTI_BRIDGE_PRIO_OFFSET    13
    217 #define MST_BPDU_MSTI_PORT_PRIO_OFFSET	    14
    218 #define MST_BPDU_MSTI_REMAIN_HOPS_OFFSET    15
    219 
    220 #define SPB_BPDU_MIN_LEN                  87
    221 #define SPB_BPDU_CONFIG_NAME_OFFSET       3
    222 #define SPB_BPDU_CONFIG_REV_OFFSET        SPB_BPDU_CONFIG_NAME_OFFSET + 32
    223 #define SPB_BPDU_CONFIG_DIGEST_OFFSET     SPB_BPDU_CONFIG_REV_OFFSET + 2
    224 #define SPB_BPDU_AGREEMENT_OFFSET         SPB_BPDU_CONFIG_DIGEST_OFFSET + 16
    225 #define SPB_BPDU_AGREEMENT_UNUSED_OFFSET  SPB_BPDU_AGREEMENT_OFFSET + 1
    226 #define SPB_BPDU_AGREEMENT_FORMAT_OFFSET  SPB_BPDU_AGREEMENT_UNUSED_OFFSET + 1
    227 #define SPB_BPDU_AGREEMENT_CON_OFFSET     SPB_BPDU_AGREEMENT_FORMAT_OFFSET + 1
    228 #define SPB_BPDU_AGREEMENT_EDGE_OFFSET    SPB_BPDU_AGREEMENT_CON_OFFSET + 1
    229 #define SPB_BPDU_AGREEMENT_RES1_OFFSET    SPB_BPDU_AGREEMENT_EDGE_OFFSET + 2
    230 #define SPB_BPDU_AGREEMENT_RES2_OFFSET    SPB_BPDU_AGREEMENT_RES1_OFFSET + 4
    231 #define SPB_BPDU_AGREEMENT_DIGEST_OFFSET  SPB_BPDU_AGREEMENT_RES2_OFFSET + 4
    232 
    233 
    234 static void
    235 stp_print_mstp_bpdu(netdissect_options *ndo, const struct stp_bpdu_ *stp_bpdu,
    236                     u_int length)
    237 {
    238     const u_char *ptr;
    239     uint16_t	    v3len;
    240     uint16_t	    len;
    241     uint16_t	    msti;
    242     u_int	    offset;
    243 
    244     ptr = (const u_char *)stp_bpdu;
    245     ND_PRINT((ndo, ", CIST Flags [%s], length %u",
    246            bittok2str(stp_bpdu_flag_values, "none", stp_bpdu->flags), length));
    247 
    248     /*
    249      * in non-verbose mode just print the flags.
    250      */
    251     if (!ndo->ndo_vflag) {
    252         return;
    253     }
    254 
    255     ND_PRINT((ndo, "\n\tport-role %s, ",
    256            tok2str(rstp_obj_port_role_values, "Unknown",
    257                    RSTP_EXTRACT_PORT_ROLE(stp_bpdu->flags))));
    258 
    259     ND_PRINT((ndo, "CIST root-id %s, CIST ext-pathcost %u ",
    260            stp_print_bridge_id((const u_char *)&stp_bpdu->root_id),
    261            EXTRACT_32BITS(&stp_bpdu->root_path_cost)));
    262 
    263     ND_PRINT((ndo, "\n\tCIST regional-root-id %s, ",
    264            stp_print_bridge_id((const u_char *)&stp_bpdu->bridge_id)));
    265 
    266     ND_PRINT((ndo, "CIST port-id %04x, ", EXTRACT_16BITS(&stp_bpdu->port_id)));
    267 
    268     ND_PRINT((ndo, "\n\tmessage-age %.2fs, max-age %.2fs"
    269            ", hello-time %.2fs, forwarding-delay %.2fs",
    270            (float)EXTRACT_16BITS(&stp_bpdu->message_age) / STP_TIME_BASE,
    271            (float)EXTRACT_16BITS(&stp_bpdu->max_age) / STP_TIME_BASE,
    272            (float)EXTRACT_16BITS(&stp_bpdu->hello_time) / STP_TIME_BASE,
    273            (float)EXTRACT_16BITS(&stp_bpdu->forward_delay) / STP_TIME_BASE));
    274 
    275     ND_PRINT((ndo, "\n\tv3len %d, ", EXTRACT_16BITS(ptr + MST_BPDU_VER3_LEN_OFFSET)));
    276     ND_PRINT((ndo, "MCID Name %s, rev %u, "
    277             "\n\t\tdigest %08x%08x%08x%08x, ",
    278             ptr + MST_BPDU_CONFIG_NAME_OFFSET,
    279 	          EXTRACT_16BITS(ptr + MST_BPDU_CONFIG_NAME_OFFSET + 32),
    280       	    EXTRACT_32BITS(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET),
    281         	  EXTRACT_32BITS(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET + 4),
    282 	          EXTRACT_32BITS(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET + 8),
    283 	          EXTRACT_32BITS(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET + 12)));
    284 
    285     ND_PRINT((ndo, "CIST int-root-pathcost %u, ",
    286             EXTRACT_32BITS(ptr + MST_BPDU_CIST_INT_PATH_COST_OFFSET)));
    287 
    288     ND_PRINT((ndo, "\n\tCIST bridge-id %s, ",
    289            stp_print_bridge_id(ptr + MST_BPDU_CIST_BRIDGE_ID_OFFSET)));
    290 
    291     ND_PRINT((ndo, "CIST remaining-hops %d", ptr[MST_BPDU_CIST_REMAIN_HOPS_OFFSET]));
    292 
    293     /* Dump all MSTI's */
    294     v3len = EXTRACT_16BITS(ptr + MST_BPDU_VER3_LEN_OFFSET);
    295     if (v3len > MST_BPDU_CONFIG_INFO_LENGTH) {
    296         len = v3len - MST_BPDU_CONFIG_INFO_LENGTH;
    297         offset = MST_BPDU_MSTI_OFFSET;
    298         while (len >= MST_BPDU_MSTI_LENGTH) {
    299             msti = EXTRACT_16BITS(ptr + offset +
    300                                   MST_BPDU_MSTI_ROOT_PRIO_OFFSET);
    301             msti = msti & 0x0FFF;
    302 
    303             ND_PRINT((ndo, "\n\tMSTI %d, Flags [%s], port-role %s",
    304                    msti, bittok2str(stp_bpdu_flag_values, "none", ptr[offset]),
    305                    tok2str(rstp_obj_port_role_values, "Unknown",
    306                            RSTP_EXTRACT_PORT_ROLE(ptr[offset]))));
    307             ND_PRINT((ndo, "\n\t\tMSTI regional-root-id %s, pathcost %u",
    308                    stp_print_bridge_id(ptr + offset +
    309                                        MST_BPDU_MSTI_ROOT_PRIO_OFFSET),
    310                    EXTRACT_32BITS(ptr + offset +
    311                                   MST_BPDU_MSTI_ROOT_PATH_COST_OFFSET)));
    312             ND_PRINT((ndo, "\n\t\tMSTI bridge-prio %d, port-prio %d, hops %d",
    313                    ptr[offset + MST_BPDU_MSTI_BRIDGE_PRIO_OFFSET] >> 4,
    314                    ptr[offset + MST_BPDU_MSTI_PORT_PRIO_OFFSET] >> 4,
    315                    ptr[offset + MST_BPDU_MSTI_REMAIN_HOPS_OFFSET]));
    316 
    317             len -= MST_BPDU_MSTI_LENGTH;
    318             offset += MST_BPDU_MSTI_LENGTH;
    319         }
    320     }
    321 }
    322 
    323 static void
    324 stp_print_spb_bpdu(netdissect_options *ndo, const struct stp_bpdu_ *stp_bpdu,
    325                    u_int offset)
    326 {
    327     const u_char *ptr;
    328 
    329     /*
    330      * in non-verbose mode don't print anything.
    331      */
    332     if (!ndo->ndo_vflag) {
    333         return;
    334     }
    335 
    336     ptr = (const u_char *)stp_bpdu;
    337     ND_PRINT((ndo, "\n\tv4len %d AUXMCID Name %s, Rev %u, \n\t\tdigest %08x%08x%08x%08x",
    338             EXTRACT_16BITS (ptr + offset),
    339             ptr + offset + SPB_BPDU_CONFIG_NAME_OFFSET,
    340             EXTRACT_16BITS(ptr + offset + SPB_BPDU_CONFIG_REV_OFFSET),
    341             EXTRACT_32BITS(ptr + offset + SPB_BPDU_CONFIG_DIGEST_OFFSET),
    342             EXTRACT_32BITS(ptr + offset + SPB_BPDU_CONFIG_DIGEST_OFFSET + 4),
    343             EXTRACT_32BITS(ptr + offset + SPB_BPDU_CONFIG_DIGEST_OFFSET + 8),
    344             EXTRACT_32BITS(ptr + offset + SPB_BPDU_CONFIG_DIGEST_OFFSET + 12)));
    345 
    346     ND_PRINT((ndo, "\n\tAgreement num %d, Discarded Agreement num %d, Agreement valid-"
    347             "flag %d, \n\tRestricted role-flag: %d, Format id %d cap %d, "
    348             "Convention id %d cap %d, \n\tEdge count %d, "
    349             "Agreement digest %08x%08x%08x%08x%08x\n",
    350             ptr[offset + SPB_BPDU_AGREEMENT_OFFSET]>>6,
    351             ptr[offset + SPB_BPDU_AGREEMENT_OFFSET]>>4 & 0x3,
    352             ptr[offset + SPB_BPDU_AGREEMENT_OFFSET]>>3 & 0x1,
    353             ptr[offset + SPB_BPDU_AGREEMENT_OFFSET]>>2 & 0x1,
    354             ptr[offset + SPB_BPDU_AGREEMENT_FORMAT_OFFSET]>>4,
    355             ptr[offset + SPB_BPDU_AGREEMENT_FORMAT_OFFSET]&0x00ff,
    356             ptr[offset + SPB_BPDU_AGREEMENT_CON_OFFSET]>>4,
    357             ptr[offset + SPB_BPDU_AGREEMENT_CON_OFFSET]&0x00ff,
    358             EXTRACT_16BITS(ptr + offset + SPB_BPDU_AGREEMENT_EDGE_OFFSET),
    359             EXTRACT_32BITS(ptr + offset + SPB_BPDU_AGREEMENT_DIGEST_OFFSET),
    360             EXTRACT_32BITS(ptr + offset + SPB_BPDU_AGREEMENT_DIGEST_OFFSET)+4,
    361             EXTRACT_32BITS(ptr + offset + SPB_BPDU_AGREEMENT_DIGEST_OFFSET)+8,
    362             EXTRACT_32BITS(ptr + offset + SPB_BPDU_AGREEMENT_DIGEST_OFFSET)+12,
    363             EXTRACT_32BITS(ptr + offset + SPB_BPDU_AGREEMENT_DIGEST_OFFSET)+16));
    364 }
    365 
    366 /*
    367  * Print 802.1d / 802.1w / 802.1q (mstp) / 802.1aq (spb) packets.
    368  */
    369 void
    370 stp_print(netdissect_options *ndo, const u_char *p, u_int length)
    371 {
    372     const struct stp_bpdu_ *stp_bpdu;
    373     u_int                  mstp_len;
    374     u_int                  spb_len;
    375 
    376     stp_bpdu = (const struct stp_bpdu_*)p;
    377 
    378     /* Minimum STP Frame size. */
    379     if (length < 4)
    380         goto trunc;
    381 
    382     if (EXTRACT_16BITS(&stp_bpdu->protocol_id)) {
    383         ND_PRINT((ndo, "unknown STP version, length %u", length));
    384         return;
    385     }
    386 
    387     ND_PRINT((ndo, "STP %s", tok2str(stp_proto_values, "Unknown STP protocol (0x%02x)",
    388                          stp_bpdu->protocol_version)));
    389 
    390     switch (stp_bpdu->protocol_version) {
    391     case STP_PROTO_REGULAR:
    392     case STP_PROTO_RAPID:
    393     case STP_PROTO_MSTP:
    394     case STP_PROTO_SPB:
    395         break;
    396     default:
    397         return;
    398     }
    399 
    400     ND_PRINT((ndo, ", %s", tok2str(stp_bpdu_type_values, "Unknown BPDU Type (0x%02x)",
    401                            stp_bpdu->bpdu_type)));
    402 
    403     switch (stp_bpdu->bpdu_type) {
    404     case STP_BPDU_TYPE_CONFIG:
    405         if (length < sizeof(struct stp_bpdu_) - 1) {
    406             goto trunc;
    407         }
    408         stp_print_config_bpdu(ndo, stp_bpdu, length);
    409         break;
    410 
    411     case STP_BPDU_TYPE_RSTP:
    412         if (stp_bpdu->protocol_version == STP_PROTO_RAPID) {
    413             if (length < sizeof(struct stp_bpdu_)) {
    414                 goto trunc;
    415             }
    416             stp_print_config_bpdu(ndo, stp_bpdu, length);
    417         } else if (stp_bpdu->protocol_version == STP_PROTO_MSTP ||
    418                    stp_bpdu->protocol_version == STP_PROTO_SPB) {
    419             if (length < STP_BPDU_MSTP_MIN_LEN) {
    420                 goto trunc;
    421             }
    422 
    423             if (stp_bpdu->v1_length != 0) {
    424                 /* FIX ME: Emit a message here ? */
    425                 goto trunc;
    426             }
    427 
    428             /* Validate v3 length */
    429             mstp_len = EXTRACT_16BITS(p + MST_BPDU_VER3_LEN_OFFSET);
    430             mstp_len += 2;  /* length encoding itself is 2 bytes */
    431             if (length < (sizeof(struct stp_bpdu_) + mstp_len)) {
    432                 goto trunc;
    433             }
    434             stp_print_mstp_bpdu(ndo, stp_bpdu, length);
    435 
    436             if (stp_bpdu->protocol_version == STP_PROTO_SPB)
    437             {
    438               /* Validate v4 length */
    439               spb_len = EXTRACT_16BITS (p + MST_BPDU_VER3_LEN_OFFSET + mstp_len);
    440               spb_len += 2;
    441               if (length < (sizeof(struct stp_bpdu_) + mstp_len + spb_len) ||
    442                   spb_len < SPB_BPDU_MIN_LEN) {
    443                 goto trunc;
    444               }
    445               stp_print_spb_bpdu(ndo, stp_bpdu, (sizeof(struct stp_bpdu_) + mstp_len));
    446             }
    447         }
    448         break;
    449 
    450     case STP_BPDU_TYPE_TOPO_CHANGE:
    451         /* always empty message - just break out */
    452         break;
    453 
    454     default:
    455         break;
    456     }
    457 
    458     return;
    459  trunc:
    460     ND_PRINT((ndo, "[|stp %d]", length));
    461 }
    462 
    463 /*
    464  * Local Variables:
    465  * c-style: whitesmith
    466  * c-basic-offset: 4
    467  * End:
    468  */
    469