The Tcpdump Group git mirrors - tcpdump/blobdiff

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

*/

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

*/

-#ifndef lint

-static const char rcsid[] _U_ =

- "@(#) $Header: /tcpdump/master/tcpdump/print-chdlc.c,v 1.43 2005-11-29 08:56:19 hannes Exp $ (LBL)";

-#endif

+/* \summary: Cisco HDLC printer */

#ifdef HAVE_CONFIG_H

-#include "config.h"

+#include <config.h>

#endif

-#include <tcpdump-stdinc.h>

-

-#include <pcap.h>

-#include <stdio.h>

+#include "netdissect-stdinc.h"

-#include "interface.h"

+#define ND_LONGJMP_FROM_TCHECK

+#include "netdissect.h"

#include "addrtoname.h"

#include "ethertype.h"

#include "extract.h"

#include "addrtoname.h"

#include "ethertype.h"

#include "extract.h"

-#include "ppp.h"

#include "chdlc.h"

+#include "nlpid.h"

-static void chdlc_slarp_print(const u_char *, u_int);

+static void chdlc_slarp_print(netdissect_options *, const u_char *, u_int);

-const struct tok chdlc_cast_values[] = {

+static const struct tok chdlc_cast_values[] = {

{ CHDLC_UNICAST, "unicast" },

{ CHDLC_BCAST, "bcast" },

{ 0, NULL}

{ CHDLC_UNICAST, "unicast" },

{ CHDLC_BCAST, "bcast" },

{ 0, NULL}

/* Standard CHDLC printer */

-u_int

-chdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)

+void

+chdlc_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h, const u_char *p)

{

- register u_int length = h->len;

- register u_int caplen = h->caplen;

-

- if (caplen < CHDLC_HDRLEN) {

- printf("[|chdlc]");

- return (caplen);

- }

- return (chdlc_print(p,length));

+ ndo->ndo_protocol = "chdlc";

+ ND_TCHECK_LEN(p, CHDLC_HDRLEN);

+ ndo->ndo_ll_hdr_len += CHDLC_HDRLEN;

+ chdlc_print(ndo, p, h->len);

}

-u_int

-chdlc_print(register const u_char *p, u_int length) {

+void

+chdlc_print(netdissect_options *ndo, const u_char *p, u_int length)

+{

u_int proto;

- proto = EXTRACT_16BITS(&p[2]);

- if (eflag) {

- printf("%s, ethertype %s (0x%04x), length %u: ",

- tok2str(chdlc_cast_values, "0x%02x", p[0]),

+ ndo->ndo_protocol = "chdlc";

+ ND_ICHECK_U(length, <, CHDLC_HDRLEN);

+ proto = GET_BE_U_2(p + 2);

+ if (ndo->ndo_eflag) {

+ ND_PRINT("%s, ethertype %s (0x%04x), length %u: ",

+ tok2str(chdlc_cast_values, "0x%02x", GET_U_1(p)),

tok2str(ethertype_values, "Unknown", proto),

proto,

length);

tok2str(ethertype_values, "Unknown", proto),

proto,

length);

switch (proto) {

case ETHERTYPE_IP:

switch (proto) {

case ETHERTYPE_IP:

- ip_print(gndo, p, length);

+ ip_print(ndo, p, length);

break;

-#ifdef INET6

case ETHERTYPE_IPV6:

- ip6_print(gndo, p, length);

+ ip6_print(ndo, p, length);

break;

-#endif

case CHDLC_TYPE_SLARP:

- chdlc_slarp_print(p, length);

- break;

-#if 0

- case CHDLC_TYPE_CDP:

- chdlc_cdp_print(p, length);

+ chdlc_slarp_print(ndo, p, length);

break;

-#endif

case ETHERTYPE_MPLS:

case ETHERTYPE_MPLS_MULTI:

case ETHERTYPE_MPLS:

case ETHERTYPE_MPLS_MULTI:

- mpls_print(p, length);

+ mpls_print(ndo, p, length);

break;

case ETHERTYPE_ISO:

/* is the fudge byte set ? lets verify by spotting ISO headers */

break;

case ETHERTYPE_ISO:

/* is the fudge byte set ? lets verify by spotting ISO headers */

- if (*(p+1) == 0x81 ||

- *(p+1) == 0x82 ||

- *(p+1) == 0x83)

- isoclns_print(p+1, length-1, length-1);

+ ND_ICHECK_U(length, <, 2);

+ if (GET_U_1(p + 1) == NLPID_CLNP ||

+ GET_U_1(p + 1) == NLPID_ESIS ||

+ GET_U_1(p + 1) == NLPID_ISIS)

+ isoclns_print(ndo, p + 1, length - 1);

else

- isoclns_print(p, length, length);

+ isoclns_print(ndo, p, length);

break;

default:

break;

default:

- if (!eflag)

- printf("unknown CHDLC protocol (0x%04x)", proto);

+ if (!ndo->ndo_eflag)

+ ND_PRINT("unknown CHDLC protocol (0x%04x)", proto);

break;

}

break;

}

- return (CHDLC_HDRLEN);

+ return;

+

+invalid:

+ nd_print_invalid(ndo);

}

/*

* The fixed-length portion of a SLARP packet.

*/

struct cisco_slarp {

}

/*

* The fixed-length portion of a SLARP packet.

*/

struct cisco_slarp {

- u_int8_t code[4];

+ nd_uint32_t code;

#define SLARP_REQUEST 0

#define SLARP_REPLY 1

#define SLARP_KEEPALIVE 2

union {

struct {

#define SLARP_REQUEST 0

#define SLARP_REPLY 1

#define SLARP_KEEPALIVE 2

union {

struct {

- u_int8_t addr[4];

- u_int8_t mask[4];

+ uint8_t addr[4];

+ uint8_t mask[4];

} addr;

struct {

} addr;

struct {

- u_int8_t myseq[4];

- u_int8_t yourseq[4];

- u_int8_t rel[2];

+ nd_uint32_t myseq;

+ nd_uint32_t yourseq;

+ nd_uint16_t rel;

} keep;

} un;

};

} keep;

} un;

};

#define SLARP_MAX_LEN 18

static void

#define SLARP_MAX_LEN 18

static void

-chdlc_slarp_print(const u_char *cp, u_int length)

+chdlc_slarp_print(netdissect_options *ndo, const u_char *cp, u_int length)

{

const struct cisco_slarp *slarp;

u_int sec,min,hrs,days;

{

const struct cisco_slarp *slarp;

u_int sec,min,hrs,days;

- printf("SLARP (length: %u), ",length);

- if (length < SLARP_MIN_LEN)

- goto trunc;

+ ndo->ndo_protocol = "chdlc_slarp";

+ ND_PRINT("SLARP");

+ ND_ICHECK_U(length, <, SLARP_MIN_LEN);

+ ND_PRINT(" (length: %u), ",length);

slarp = (const struct cisco_slarp *)cp;

- TCHECK2(*slarp, SLARP_MIN_LEN);

- switch (EXTRACT_32BITS(&slarp->code)) {

+ ND_TCHECK_LEN(slarp, SLARP_MIN_LEN);

+ switch (GET_BE_U_4(slarp->code)) {

case SLARP_REQUEST:

- printf("request");

+ ND_PRINT("request");

/*

* At least according to William "Chops" Westfield's

* message in

*

/*

* At least according to William "Chops" Westfield's

* message in

*

- * http://www.nethelp.no/net/cisco-hdlc.txt

+ * https://web.archive.org/web/20190725151313/www.nethelp.no/net/cisco-hdlc.txt

*

* the address and mask aren't used in requests -

* they're just zero.

*/

break;

case SLARP_REPLY:

*

* the address and mask aren't used in requests -

* they're just zero.

*/

break;

case SLARP_REPLY:

- printf("reply %s/%s",

- ipaddr_string(&slarp->un.addr.addr),

- ipaddr_string(&slarp->un.addr.mask));

+ ND_PRINT("reply %s/%s",

+ GET_IPADDR_STRING(slarp->un.addr.addr),

+ GET_IPADDR_STRING(slarp->un.addr.mask));

break;

case SLARP_KEEPALIVE:

break;

case SLARP_KEEPALIVE:

- printf("keepalive: mineseen=0x%08x, yourseen=0x%08x, reliability=0x%04x",

- EXTRACT_32BITS(&slarp->un.keep.myseq),

- EXTRACT_32BITS(&slarp->un.keep.yourseq),

- EXTRACT_16BITS(&slarp->un.keep.rel));

+ ND_PRINT("keepalive: mineseen=0x%08x, yourseen=0x%08x, reliability=0x%04x",

+ GET_BE_U_4(slarp->un.keep.myseq),

+ GET_BE_U_4(slarp->un.keep.yourseq),

+ GET_BE_U_2(slarp->un.keep.rel));

if (length >= SLARP_MAX_LEN) { /* uptime-stamp is optional */

cp += SLARP_MIN_LEN;

if (length >= SLARP_MAX_LEN) { /* uptime-stamp is optional */

cp += SLARP_MIN_LEN;

- if (!TTEST2(*cp, 4))

- goto trunc;

- sec = EXTRACT_32BITS(cp) / 1000;

+ sec = GET_BE_U_4(cp) / 1000;

min = sec / 60; sec -= min * 60;

hrs = min / 60; min -= hrs * 60;

days = hrs / 24; hrs -= days * 24;

min = sec / 60; sec -= min * 60;

hrs = min / 60; min -= hrs * 60;

days = hrs / 24; hrs -= days * 24;

- printf(", link uptime=%ud%uh%um%us",days,hrs,min,sec);

+ ND_PRINT(", link uptime=%ud%uh%um%us",days,hrs,min,sec);

}

break;

default:

}

break;

default:

- printf("0x%02x unknown", EXTRACT_32BITS(&slarp->code));

- if (vflag <= 1)

- print_unknown_data(cp+4,"\n\t",length-4);

+ ND_PRINT("0x%02x unknown", GET_BE_U_4(slarp->code));

+ if (ndo->ndo_vflag <= 1)

+ print_unknown_data(ndo,cp+4,"\n\t",length-4);

break;

}

break;

}

- if (SLARP_MAX_LEN < length && vflag)

- printf(", (trailing junk: %d bytes)", length - SLARP_MAX_LEN);

- if (vflag > 1)

- print_unknown_data(cp+4,"\n\t",length-4);

+ if (SLARP_MAX_LEN < length && ndo->ndo_vflag)

+ ND_PRINT(", (trailing junk: %u bytes)", length - SLARP_MAX_LEN);

+ if (ndo->ndo_vflag > 1)

+ print_unknown_data(ndo,cp+4,"\n\t",length-4);

return;

-trunc:

- printf("[|slarp]");

+invalid:

+ nd_print_invalid(ndo);

}

-

-/*

- * Local Variables:

- * c-style: whitesmith

- * c-basic-offset: 8

- * End:

- */