print-cfm.c revision 259065 
1/*
2 * Copyright (c) 1998-2006 The TCPDUMP project
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that: (1) source code
6 * distributions retain the above copyright notice and this paragraph
7 * in its entirety, and (2) distributions including binary code include
8 * the above copyright notice and this paragraph in its entirety in
9 * the documentation or other materials provided with the distribution.
10 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
11 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
12 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
13 * FOR A PARTICULAR PURPOSE.
14 *
15 * Support for the IEEE Connectivity Fault Management Protocols as per 802.1ag.
16 *
17 * Original code by Hannes Gredler (hannes@juniper.net)
18 */
19
20#ifndef lint
21static const char rcsid[] _U_ =
22    "@(#) $Header: /tcpdump/master/tcpdump/print-cfm.c,v 1.5 2007-07-24 16:01:42 hannes Exp $";
23#endif
24
25#ifdef HAVE_CONFIG_H
26#include "config.h"
27#endif
28
29#include <tcpdump-stdinc.h>
30
31#include <stdio.h>
32#include <stdlib.h>
33#include <string.h>
34
35#include "interface.h"
36#include "extract.h"
37#include "ether.h"
38#include "addrtoname.h"
39#include "oui.h"
40#include "af.h"
41
42/*
43 * Prototypes
44 */
45const char * cfm_egress_id_string(register const u_char *);
46int cfm_mgmt_addr_print(register const u_char *);
47
48struct cfm_common_header_t {
49    u_int8_t mdlevel_version;
50    u_int8_t opcode;
51    u_int8_t flags;
52    u_int8_t first_tlv_offset;
53};
54
55#define	CFM_VERSION 0
56#define CFM_EXTRACT_VERSION(x) (((x)&0x1f))
57#define CFM_EXTRACT_MD_LEVEL(x) (((x)&0xe0)>>5)
58
59#define	CFM_OPCODE_CCM 1
60#define	CFM_OPCODE_LBR 2
61#define	CFM_OPCODE_LBM 3
62#define	CFM_OPCODE_LTR 4
63#define	CFM_OPCODE_LTM 5
64
65static const struct tok cfm_opcode_values[] = {
66    { CFM_OPCODE_CCM, "Continouity Check Message"},
67    { CFM_OPCODE_LBR, "Loopback Reply"},
68    { CFM_OPCODE_LBM, "Loopback Message"},
69    { CFM_OPCODE_LTR, "Linktrace Reply"},
70    { CFM_OPCODE_LTM, "Linktrace Message"},
71    { 0, NULL}
72};
73
74/*
75 * Message Formats.
76 */
77struct cfm_ccm_t {
78    u_int8_t sequence[4];
79    u_int8_t ma_epi[2];
80    u_int8_t md_nameformat;
81    u_int8_t md_namelength;
82    u_int8_t md_name[46]; /* md name and short ma name */
83    u_int8_t reserved_itu[16];
84    u_int8_t reserved[6];
85};
86
87/*
88 * Timer Bases for the CCM Interval field.
89 * Expressed in units of seconds.
90 */
91const float ccm_interval_base[8] = {0, 0.003333, 0.01, 0.1, 1, 10, 60, 600};
92#define CCM_INTERVAL_MIN_MULTIPLIER 3.25
93#define CCM_INTERVAL_MAX_MULTIPLIER 3.5
94
95#define CFM_CCM_RDI_FLAG 0x80
96#define CFM_EXTRACT_CCM_INTERVAL(x) (((x)&0x07))
97
98#define CFM_CCM_MD_FORMAT_8021 0
99#define CFM_CCM_MD_FORMAT_NONE 1
100#define CFM_CCM_MD_FORMAT_DNS  2
101#define CFM_CCM_MD_FORMAT_MAC  3
102#define CFM_CCM_MD_FORMAT_CHAR 4
103
104static const struct tok cfm_md_nameformat_values[] = {
105    { CFM_CCM_MD_FORMAT_8021, "IEEE 802.1"},
106    { CFM_CCM_MD_FORMAT_NONE, "No MD Name present"},
107    { CFM_CCM_MD_FORMAT_DNS, "DNS string"},
108    { CFM_CCM_MD_FORMAT_MAC, "MAC + 16Bit Integer"},
109    { CFM_CCM_MD_FORMAT_CHAR, "Character string"},
110    { 0, NULL}
111};
112
113#define CFM_CCM_MA_FORMAT_8021 0
114#define CFM_CCM_MA_FORMAT_VID  1
115#define CFM_CCM_MA_FORMAT_CHAR 2
116#define CFM_CCM_MA_FORMAT_INT  3
117#define CFM_CCM_MA_FORMAT_VPN  4
118
119static const struct tok cfm_ma_nameformat_values[] = {
120    { CFM_CCM_MA_FORMAT_8021, "IEEE 802.1"},
121    { CFM_CCM_MA_FORMAT_VID, "Primary VID"},
122    { CFM_CCM_MA_FORMAT_CHAR, "Character string"},
123    { CFM_CCM_MA_FORMAT_INT, "16Bit Integer"},
124    { CFM_CCM_MA_FORMAT_VPN, "RFC2685 VPN-ID"},
125    { 0, NULL}
126};
127
128struct cfm_lbm_t {
129    u_int8_t transaction_id[4];
130    u_int8_t reserved[4];
131};
132
133struct cfm_ltm_t {
134    u_int8_t transaction_id[4];
135    u_int8_t egress_id[8];
136    u_int8_t ttl;
137    u_int8_t original_mac[ETHER_ADDR_LEN];
138    u_int8_t target_mac[ETHER_ADDR_LEN];
139    u_int8_t reserved[3];
140};
141
142static const struct tok cfm_ltm_flag_values[] = {
143    { 0x80, "Use Forwarding-DB only"},
144    { 0, NULL}
145};
146
147struct cfm_ltr_t {
148    u_int8_t transaction_id[4];
149    u_int8_t last_egress_id[8];
150    u_int8_t next_egress_id[8];
151    u_int8_t ttl;
152    u_int8_t replay_action;
153    u_int8_t reserved[6];
154};
155
156static const struct tok cfm_ltr_flag_values[] = {
157    { 0x80, "Forwarded"},
158    { 0x40, "Terminal MEP"},
159    { 0, NULL}
160};
161
162static const struct tok cfm_ltr_replay_action_values[] = {
163    { 1, "Exact Match"},
164    { 2, "Filtering DB"},
165    { 3, "MIP CCM DB"},
166    { 0, NULL}
167};
168
169
170#define CFM_TLV_END 0
171#define CFM_TLV_SENDER_ID 1
172#define CFM_TLV_PORT_STATUS 2
173#define CFM_TLV_INTERFACE_STATUS 3
174#define CFM_TLV_DATA 4
175#define CFM_TLV_REPLY_INGRESS 5
176#define CFM_TLV_REPLY_EGRESS 6
177#define CFM_TLV_PRIVATE 31
178
179static const struct tok cfm_tlv_values[] = {
180    { CFM_TLV_END, "End"},
181    { CFM_TLV_SENDER_ID, "Sender ID"},
182    { CFM_TLV_PORT_STATUS, "Port status"},
183    { CFM_TLV_INTERFACE_STATUS, "Interface status"},
184    { CFM_TLV_DATA, "Data"},
185    { CFM_TLV_REPLY_INGRESS, "Reply Ingress"},
186    { CFM_TLV_REPLY_EGRESS, "Reply Egress"},
187    { CFM_TLV_PRIVATE, "Organization Specific"},
188    { 0, NULL}
189};
190
191/*
192 * TLVs
193 */
194
195struct cfm_tlv_header_t {
196    u_int8_t type;
197    u_int8_t length[2];
198};
199
200/* FIXME define TLV formats */
201
202static const struct tok cfm_tlv_port_status_values[] = {
203    { 1, "Blocked"},
204    { 2, "Up"},
205    { 0, NULL}
206};
207
208static const struct tok cfm_tlv_interface_status_values[] = {
209    { 1, "Up"},
210    { 2, "Down"},
211    { 3, "Testing"},
212    { 5, "Dormant"},
213    { 6, "not present"},
214    { 7, "lower Layer down"},
215    { 0, NULL}
216};
217
218#define CFM_CHASSIS_ID_CHASSIS_COMPONENT 1
219#define CFM_CHASSIS_ID_INTERFACE_ALIAS 2
220#define CFM_CHASSIS_ID_PORT_COMPONENT 3
221#define CFM_CHASSIS_ID_MAC_ADDRESS 4
222#define CFM_CHASSIS_ID_NETWORK_ADDRESS 5
223#define CFM_CHASSIS_ID_INTERFACE_NAME 6
224#define CFM_CHASSIS_ID_LOCAL 7
225
226static const struct tok cfm_tlv_senderid_chassisid_values[] = {
227    { 0, "Reserved"},
228    { CFM_CHASSIS_ID_CHASSIS_COMPONENT, "Chassis component"},
229    { CFM_CHASSIS_ID_INTERFACE_ALIAS, "Interface alias"},
230    { CFM_CHASSIS_ID_PORT_COMPONENT, "Port component"},
231    { CFM_CHASSIS_ID_MAC_ADDRESS, "MAC address"},
232    { CFM_CHASSIS_ID_NETWORK_ADDRESS, "Network address"},
233    { CFM_CHASSIS_ID_INTERFACE_NAME, "Interface name"},
234    { CFM_CHASSIS_ID_LOCAL, "Locally assigned"},
235    { 0, NULL}
236};
237
238
239int
240cfm_mgmt_addr_print(register const u_char *tptr) {
241
242    u_int mgmt_addr_type;
243    u_int hexdump =  FALSE;
244
245    /*
246     * Altough AFIs are tpically 2 octects wide,
247     * 802.1ab specifies that this field width
248     * is only once octet
249     */
250    mgmt_addr_type = *tptr;
251    printf("\n\t  Management Address Type %s (%u)",
252           tok2str(af_values, "Unknown", mgmt_addr_type),
253           mgmt_addr_type);
254
255    /*
256     * Resolve the passed in Address.
257     */
258    switch(mgmt_addr_type) {
259    case AFNUM_INET:
260        printf(", %s", ipaddr_string(tptr + 1));
261        break;
262
263#ifdef INET6
264    case AFNUM_INET6:
265        printf(", %s", ip6addr_string(tptr + 1));
266        break;
267#endif
268
269    default:
270        hexdump = TRUE;
271        break;
272    }
273
274    return hexdump;
275}
276
277/*
278 * The egress-ID string is a 16-Bit string plus a MAC address.
279 */
280const char *
281cfm_egress_id_string(register const u_char *tptr) {
282    static char egress_id_buffer[80];
283
284    snprintf(egress_id_buffer, sizeof(egress_id_buffer),
285             "MAC %0x4x-%s",
286             EXTRACT_16BITS(tptr),
287             etheraddr_string(tptr+2));
288
289    return egress_id_buffer;
290}
291
292void
293cfm_print(register const u_char *pptr, register u_int length) {
294
295    const struct cfm_common_header_t *cfm_common_header;
296    const struct cfm_tlv_header_t *cfm_tlv_header;
297    const u_int8_t *tptr, *tlv_ptr, *ma_name, *ma_nameformat, *ma_namelength;
298    u_int hexdump, tlen, cfm_tlv_len, cfm_tlv_type, ccm_interval;
299
300
301    union {
302        const struct cfm_ccm_t *cfm_ccm;
303        const struct cfm_lbm_t *cfm_lbm;
304        const struct cfm_ltm_t *cfm_ltm;
305        const struct cfm_ltr_t *cfm_ltr;
306    } msg_ptr;
307
308    tptr=pptr;
309    cfm_common_header = (const struct cfm_common_header_t *)pptr;
310    TCHECK(*cfm_common_header);
311
312    /*
313     * Sanity checking of the header.
314     */
315    if (CFM_EXTRACT_VERSION(cfm_common_header->mdlevel_version) != CFM_VERSION) {
316	printf("CFMv%u not supported, length %u",
317               CFM_EXTRACT_VERSION(cfm_common_header->mdlevel_version), length);
318	return;
319    }
320
321    printf("CFMv%u %s, MD Level %u, length %u",
322           CFM_EXTRACT_VERSION(cfm_common_header->mdlevel_version),
323           tok2str(cfm_opcode_values, "unknown (%u)", cfm_common_header->opcode),
324           CFM_EXTRACT_MD_LEVEL(cfm_common_header->mdlevel_version),
325           length);
326
327    /*
328     * In non-verbose mode just print the opcode and md-level.
329     */
330    if (vflag < 1) {
331        return;
332    }
333
334    printf("\n\tFirst TLV offset %u", cfm_common_header->first_tlv_offset);
335
336    tptr += sizeof(const struct cfm_common_header_t);
337    tlen = length - sizeof(struct cfm_common_header_t);
338
339    switch (cfm_common_header->opcode) {
340    case CFM_OPCODE_CCM:
341        msg_ptr.cfm_ccm = (const struct cfm_ccm_t *)tptr;
342
343        ccm_interval = CFM_EXTRACT_CCM_INTERVAL(cfm_common_header->flags);
344        printf(", Flags [CCM Interval %u%s]",
345               ccm_interval,
346               cfm_common_header->flags & CFM_CCM_RDI_FLAG ?
347               ", RDI" : "");
348
349        /*
350         * Resolve the CCM interval field.
351         */
352        if (ccm_interval) {
353            printf("\n\t  CCM Interval %.3fs"
354                   ", min CCM Lifetime %.3fs, max CCM Lifetime %.3fs",
355                   ccm_interval_base[ccm_interval],
356                   ccm_interval_base[ccm_interval] * CCM_INTERVAL_MIN_MULTIPLIER,
357                   ccm_interval_base[ccm_interval] * CCM_INTERVAL_MAX_MULTIPLIER);
358        }
359
360        printf("\n\t  Sequence Number 0x%08x, MA-End-Point-ID 0x%04x",
361               EXTRACT_32BITS(msg_ptr.cfm_ccm->sequence),
362               EXTRACT_16BITS(msg_ptr.cfm_ccm->ma_epi));
363
364
365        /*
366         * Resolve the MD fields.
367         */
368        printf("\n\t  MD Name Format %s (%u), MD Name length %u",
369               tok2str(cfm_md_nameformat_values, "Unknown",
370                       msg_ptr.cfm_ccm->md_nameformat),
371               msg_ptr.cfm_ccm->md_nameformat,
372               msg_ptr.cfm_ccm->md_namelength);
373
374        if (msg_ptr.cfm_ccm->md_nameformat != CFM_CCM_MD_FORMAT_NONE) {
375            printf("\n\t  MD Name: ");
376            switch (msg_ptr.cfm_ccm->md_nameformat) {
377            case CFM_CCM_MD_FORMAT_DNS:
378            case CFM_CCM_MD_FORMAT_CHAR:
379                safeputs((const char *)msg_ptr.cfm_ccm->md_name, msg_ptr.cfm_ccm->md_namelength);
380                break;
381
382            case CFM_CCM_MD_FORMAT_MAC:
383                printf("\n\t  MAC %s", etheraddr_string(
384                           msg_ptr.cfm_ccm->md_name));
385                break;
386
387                /* FIXME add printers for those MD formats - hexdump for now */
388            case CFM_CCM_MA_FORMAT_8021:
389            default:
390                print_unknown_data(msg_ptr.cfm_ccm->md_name, "\n\t    ",
391                                   msg_ptr.cfm_ccm->md_namelength);
392            }
393        }
394
395
396        /*
397         * Resolve the MA fields.
398         */
399        ma_nameformat = msg_ptr.cfm_ccm->md_name + msg_ptr.cfm_ccm->md_namelength;
400        ma_namelength = msg_ptr.cfm_ccm->md_name + msg_ptr.cfm_ccm->md_namelength + 1;
401        ma_name = msg_ptr.cfm_ccm->md_name + msg_ptr.cfm_ccm->md_namelength + 2;
402
403        printf("\n\t  MA Name-Format %s (%u), MA name length %u",
404               tok2str(cfm_ma_nameformat_values, "Unknown",
405                       *ma_nameformat),
406               *ma_nameformat,
407               *ma_namelength);
408
409        printf("\n\t  MA Name: ");
410        switch (*ma_nameformat) {
411        case CFM_CCM_MA_FORMAT_CHAR:
412            safeputs((const char *)ma_name, *ma_namelength);
413            break;
414
415            /* FIXME add printers for those MA formats - hexdump for now */
416        case CFM_CCM_MA_FORMAT_8021:
417        case CFM_CCM_MA_FORMAT_VID:
418        case CFM_CCM_MA_FORMAT_INT:
419        case CFM_CCM_MA_FORMAT_VPN:
420        default:
421            print_unknown_data(ma_name, "\n\t    ", *ma_namelength);
422        }
423        break;
424
425    case CFM_OPCODE_LTM:
426        msg_ptr.cfm_ltm = (const struct cfm_ltm_t *)tptr;
427
428        printf(", Flags [%s]",
429               bittok2str(cfm_ltm_flag_values, "none",  cfm_common_header->flags));
430
431        printf("\n\t  Transaction-ID 0x%08x, Egress-ID %s, ttl %u",
432               EXTRACT_32BITS(msg_ptr.cfm_ltm->transaction_id),
433               cfm_egress_id_string(msg_ptr.cfm_ltm->egress_id),
434               msg_ptr.cfm_ltm->ttl);
435
436        printf("\n\t  Original-MAC %s, Target-MAC %s",
437               etheraddr_string(msg_ptr.cfm_ltm->original_mac),
438               etheraddr_string(msg_ptr.cfm_ltm->target_mac));
439        break;
440
441    case CFM_OPCODE_LTR:
442        msg_ptr.cfm_ltr = (const struct cfm_ltr_t *)tptr;
443
444        printf(", Flags [%s]",
445               bittok2str(cfm_ltr_flag_values, "none",  cfm_common_header->flags));
446
447        printf("\n\t  Transaction-ID 0x%08x, Last-Egress-ID %s",
448               EXTRACT_32BITS(msg_ptr.cfm_ltr->transaction_id),
449               cfm_egress_id_string(msg_ptr.cfm_ltr->last_egress_id));
450
451        printf("\n\t  Next-Egress-ID %s, ttl %u",
452               cfm_egress_id_string(msg_ptr.cfm_ltr->next_egress_id),
453               msg_ptr.cfm_ltr->ttl);
454
455        printf("\n\t  Replay-Action %s (%u)",
456               tok2str(cfm_ltr_replay_action_values,
457                       "Unknown",
458                       msg_ptr.cfm_ltr->replay_action),
459               msg_ptr.cfm_ltr->replay_action);
460        break;
461
462        /*
463         * No message decoder yet.
464         * Hexdump everything up until the start of the TLVs
465         */
466    case CFM_OPCODE_LBR:
467    case CFM_OPCODE_LBM:
468    default:
469        if (tlen > cfm_common_header->first_tlv_offset) {
470            print_unknown_data(tptr, "\n\t  ",
471                               tlen -  cfm_common_header->first_tlv_offset);
472        }
473        break;
474    }
475
476    /*
477     * Sanity check for not walking off.
478     */
479    if (tlen <= cfm_common_header->first_tlv_offset) {
480        return;
481    }
482
483    tptr += cfm_common_header->first_tlv_offset;
484    tlen -= cfm_common_header->first_tlv_offset;
485
486    while (tlen > 0) {
487        cfm_tlv_header = (const struct cfm_tlv_header_t *)tptr;
488
489        /* Enough to read the tlv type ? */
490        TCHECK2(*tptr, 1);
491        cfm_tlv_type=cfm_tlv_header->type;
492
493        if (cfm_tlv_type != CFM_TLV_END) {
494            /* did we capture enough for fully decoding the object header ? */
495            TCHECK2(*tptr, sizeof(struct cfm_tlv_header_t));
496            cfm_tlv_len=EXTRACT_16BITS(&cfm_tlv_header->length);
497        } else {
498            cfm_tlv_len = 0;
499        }
500
501        printf("\n\t%s TLV (0x%02x), length %u",
502               tok2str(cfm_tlv_values, "Unknown", cfm_tlv_type),
503               cfm_tlv_type,
504               cfm_tlv_len);
505
506        /* sanity check for not walking off and infinite loop check. */
507        if ((cfm_tlv_type != CFM_TLV_END) &&
508            ((cfm_tlv_len + sizeof(struct cfm_tlv_header_t) > tlen) ||
509             (!cfm_tlv_len))) {
510            print_unknown_data(tptr,"\n\t  ",tlen);
511            return;
512        }
513
514        tptr += sizeof(struct cfm_tlv_header_t);
515        tlen -= sizeof(struct cfm_tlv_header_t);
516        tlv_ptr = tptr;
517
518        /* did we capture enough for fully decoding the object ? */
519        if (cfm_tlv_type != CFM_TLV_END) {
520            TCHECK2(*tptr, cfm_tlv_len);
521        }
522        hexdump = FALSE;
523
524        switch(cfm_tlv_type) {
525        case CFM_TLV_END:
526            /* we are done - bail out */
527            return;
528
529        case CFM_TLV_PORT_STATUS:
530            printf(", Status: %s (%u)",
531                   tok2str(cfm_tlv_port_status_values, "Unknown", *tptr),
532                   *tptr);
533            break;
534
535        case CFM_TLV_INTERFACE_STATUS:
536            printf(", Status: %s (%u)",
537                   tok2str(cfm_tlv_interface_status_values, "Unknown", *tptr),
538                   *tptr);
539            break;
540
541        case CFM_TLV_PRIVATE:
542            printf(", Vendor: %s (%u), Sub-Type %u",
543                   tok2str(oui_values,"Unknown", EXTRACT_24BITS(tptr)),
544                   EXTRACT_24BITS(tptr),
545                   *(tptr+3));
546            hexdump = TRUE;
547            break;
548
549        case CFM_TLV_SENDER_ID:
550        {
551            u_int chassis_id_type, chassis_id_length;
552            u_int mgmt_addr_length;
553
554            /*
555             * Check if there is a Chassis-ID.
556             */
557            chassis_id_length = *tptr;
558            if (chassis_id_length > tlen) {
559                hexdump = TRUE;
560                break;
561            }
562
563            tptr++;
564            tlen--;
565
566            if (chassis_id_length) {
567                chassis_id_type = *tptr;
568                printf("\n\t  Chassis-ID Type %s (%u), Chassis-ID length %u",
569                       tok2str(cfm_tlv_senderid_chassisid_values,
570                               "Unknown",
571                               chassis_id_type),
572                       chassis_id_type,
573                       chassis_id_length);
574
575                switch (chassis_id_type) {
576                case CFM_CHASSIS_ID_MAC_ADDRESS:
577                    printf("\n\t  MAC %s", etheraddr_string(tptr+1));
578                    break;
579
580                case CFM_CHASSIS_ID_NETWORK_ADDRESS:
581                    hexdump |= cfm_mgmt_addr_print(tptr);
582                    break;
583
584                case CFM_CHASSIS_ID_INTERFACE_NAME: /* fall through */
585                case CFM_CHASSIS_ID_INTERFACE_ALIAS:
586                case CFM_CHASSIS_ID_LOCAL:
587                case CFM_CHASSIS_ID_CHASSIS_COMPONENT:
588                case CFM_CHASSIS_ID_PORT_COMPONENT:
589                    safeputs((const char *)tptr+1, chassis_id_length);
590                    break;
591
592                default:
593                    hexdump = TRUE;
594                    break;
595                }
596            }
597
598            tptr += chassis_id_length;
599            tlen -= chassis_id_length;
600
601            /*
602             * Check if there is a Management Address.
603             */
604            mgmt_addr_length = *tptr;
605            if (mgmt_addr_length > tlen) {
606                hexdump = TRUE;
607                break;
608            }
609
610            tptr++;
611            tlen--;
612
613            if (mgmt_addr_length) {
614                hexdump |= cfm_mgmt_addr_print(tptr);
615            }
616
617            tptr += mgmt_addr_length;
618            tlen -= mgmt_addr_length;
619
620        }
621        break;
622
623            /*
624             * FIXME those are the defined TLVs that lack a decoder
625             * you are welcome to contribute code ;-)
626             */
627
628        case CFM_TLV_DATA:
629        case CFM_TLV_REPLY_INGRESS:
630        case CFM_TLV_REPLY_EGRESS:
631        default:
632            hexdump = TRUE;
633            break;
634        }
635        /* do we want to see an additional hexdump ? */
636        if (hexdump || vflag > 1)
637            print_unknown_data(tlv_ptr, "\n\t  ", cfm_tlv_len);
638
639        tptr+=cfm_tlv_len;
640        tlen-=cfm_tlv_len;
641    }
642    return;
643trunc:
644    printf("\n\t\t packet exceeded snapshot");
645}
646