The Tcpdump Group git mirrors - tcpdump/blobdiff

* PPTP support contributed by Motonori Shindo ([email protected])

*/

* PPTP support contributed by Motonori Shindo ([email protected])

*/

-

-#ifndef lint

-static const char rcsid[] =

- "@(#) $Header: /tcpdump/master/tcpdump/print-pptp.c,v 1.6 2002-09-05 00:00:17 guy Exp $";

-#endif

-

+#define NETDISSECT_REWORKED

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <tcpdump-stdinc.h>

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <tcpdump-stdinc.h>

-#include <stdio.h>

-

#include "interface.h"

+#include "extract.h"

-static char tstr[] = " [|pptp]";

-

-#ifndef TRUE

-#define TRUE 1

-#endif

-

-#ifndef FALSE

-#define FALSE 0

-#endif

+static const char tstr[] = " [|pptp]";

#define PPTP_MSG_TYPE_CTRL 1 /* Control Message */

#define PPTP_MSG_TYPE_MGMT 2 /* Management Message (currently not used */

#define PPTP_MSG_TYPE_CTRL 1 /* Control Message */

#define PPTP_MSG_TYPE_MGMT 2 /* Management Message (currently not used */

/* common for all PPTP control messages */

struct pptp_hdr {

/* common for all PPTP control messages */

struct pptp_hdr {

- u_int16_t length;

- u_int16_t msg_type;

- u_int32_t magic_cookie;

- u_int16_t ctrl_msg_type;

- u_int16_t reserved0;

+ uint16_t length;

+ uint16_t msg_type;

+ uint32_t magic_cookie;

+ uint16_t ctrl_msg_type;

+ uint16_t reserved0;

};

struct pptp_msg_sccrq {

};

struct pptp_msg_sccrq {

- u_int16_t proto_ver;

- u_int16_t reserved1;

- u_int32_t framing_cap;

- u_int32_t bearer_cap;

- u_int16_t max_channel;

- u_int16_t firm_rev;

+ uint16_t proto_ver;

+ uint16_t reserved1;

+ uint32_t framing_cap;

+ uint32_t bearer_cap;

+ uint16_t max_channel;

+ uint16_t firm_rev;

u_char hostname[64];

u_char vendor[64];

};

struct pptp_msg_sccrp {

u_char hostname[64];

u_char vendor[64];

};

struct pptp_msg_sccrp {

- u_int16_t proto_ver;

- u_int8_t result_code;

- u_int8_t err_code;

- u_int32_t framing_cap;

- u_int32_t bearer_cap;

- u_int16_t max_channel;

- u_int16_t firm_rev;

+ uint16_t proto_ver;

+ uint8_t result_code;

+ uint8_t err_code;

+ uint32_t framing_cap;

+ uint32_t bearer_cap;

+ uint16_t max_channel;

+ uint16_t firm_rev;

u_char hostname[64];

u_char vendor[64];

};

struct pptp_msg_stopccrq {

u_char hostname[64];

u_char vendor[64];

};

struct pptp_msg_stopccrq {

- u_int8_t reason;

- u_int8_t reserved1;

- u_int16_t reserved2;

+ uint8_t reason;

+ uint8_t reserved1;

+ uint16_t reserved2;

};

struct pptp_msg_stopccrp {

};

struct pptp_msg_stopccrp {

- u_int8_t result_code;

- u_int8_t err_code;

- u_int16_t reserved1;

+ uint8_t result_code;

+ uint8_t err_code;

+ uint16_t reserved1;

};

struct pptp_msg_echorq {

};

struct pptp_msg_echorq {

- u_int32_t id;

+ uint32_t id;

};

struct pptp_msg_echorp {

};

struct pptp_msg_echorp {

- u_int32_t id;

- u_int8_t result_code;

- u_int8_t err_code;

- u_int16_t reserved1;

+ uint32_t id;

+ uint8_t result_code;

+ uint8_t err_code;

+ uint16_t reserved1;

};

struct pptp_msg_ocrq {

};

struct pptp_msg_ocrq {

- u_int16_t call_id;

- u_int16_t call_ser;

- u_int32_t min_bps;

- u_int32_t max_bps;

- u_int32_t bearer_type;

- u_int32_t framing_type;

- u_int16_t recv_winsiz;

- u_int16_t pkt_proc_delay;

- u_int16_t phone_no_len;

- u_int16_t reserved1;

+ uint16_t call_id;

+ uint16_t call_ser;

+ uint32_t min_bps;

+ uint32_t max_bps;

+ uint32_t bearer_type;

+ uint32_t framing_type;

+ uint16_t recv_winsiz;

+ uint16_t pkt_proc_delay;

+ uint16_t phone_no_len;

+ uint16_t reserved1;

u_char phone_no[64];

u_char subaddr[64];

};

struct pptp_msg_ocrp {

u_char phone_no[64];

u_char subaddr[64];

};

struct pptp_msg_ocrp {

- u_int16_t call_id;

- u_int16_t peer_call_id;

- u_int8_t result_code;

- u_int8_t err_code;

- u_int16_t cause_code;

- u_int32_t conn_speed;

- u_int16_t recv_winsiz;

- u_int16_t pkt_proc_delay;

- u_int32_t phy_chan_id;

+ uint16_t call_id;

+ uint16_t peer_call_id;

+ uint8_t result_code;

+ uint8_t err_code;

+ uint16_t cause_code;

+ uint32_t conn_speed;

+ uint16_t recv_winsiz;

+ uint16_t pkt_proc_delay;

+ uint32_t phy_chan_id;

};

struct pptp_msg_icrq {

};

struct pptp_msg_icrq {

- u_int16_t call_id;

- u_int16_t call_ser;

- u_int32_t bearer_type;

- u_int32_t phy_chan_id;

- u_int16_t dialed_no_len;

- u_int16_t dialing_no_len;

+ uint16_t call_id;

+ uint16_t call_ser;

+ uint32_t bearer_type;

+ uint32_t phy_chan_id;

+ uint16_t dialed_no_len;

+ uint16_t dialing_no_len;

u_char dialed_no[64]; /* DNIS */

u_char dialing_no[64]; /* CLID */

u_char subaddr[64];

};

struct pptp_msg_icrp {

u_char dialed_no[64]; /* DNIS */

u_char dialing_no[64]; /* CLID */

u_char subaddr[64];

};

struct pptp_msg_icrp {

- u_int16_t call_id;

- u_int16_t peer_call_id;

- u_int8_t result_code;

- u_int8_t err_code;

- u_int16_t recv_winsiz;

- u_int16_t pkt_proc_delay;

- u_int16_t reserved1;

+ uint16_t call_id;

+ uint16_t peer_call_id;

+ uint8_t result_code;

+ uint8_t err_code;

+ uint16_t recv_winsiz;

+ uint16_t pkt_proc_delay;

+ uint16_t reserved1;

};

struct pptp_msg_iccn {

};

struct pptp_msg_iccn {

- u_int16_t peer_call_id;

- u_int16_t reserved1;

- u_int32_t conn_speed;

- u_int16_t recv_winsiz;

- u_int16_t pkt_proc_delay;

- u_int32_t framing_type;

+ uint16_t peer_call_id;

+ uint16_t reserved1;

+ uint32_t conn_speed;

+ uint16_t recv_winsiz;

+ uint16_t pkt_proc_delay;

+ uint32_t framing_type;

};

struct pptp_msg_ccrq {

};

struct pptp_msg_ccrq {

- u_int16_t call_id;

- u_int16_t reserved1;

+ uint16_t call_id;

+ uint16_t reserved1;

};

struct pptp_msg_cdn {

};

struct pptp_msg_cdn {

- u_int16_t call_id;

- u_int8_t result_code;

- u_int8_t err_code;

- u_int16_t cause_code;

- u_int16_t reserved1;

+ uint16_t call_id;

+ uint8_t result_code;

+ uint8_t err_code;

+ uint16_t cause_code;

+ uint16_t reserved1;

u_char call_stats[128];

};

struct pptp_msg_wen {

u_char call_stats[128];

};

struct pptp_msg_wen {

- u_int16_t peer_call_id;

- u_int16_t reserved1;

- u_int32_t crc_err;

- u_int32_t framing_err;

- u_int32_t hardware_overrun;

- u_int32_t buffer_overrun;

- u_int32_t timeout_err;

- u_int32_t align_err;

+ uint16_t peer_call_id;

+ uint16_t reserved1;

+ uint32_t crc_err;

+ uint32_t framing_err;

+ uint32_t hardware_overrun;

+ uint32_t buffer_overrun;

+ uint32_t timeout_err;

+ uint32_t align_err;

};

struct pptp_msg_sli {

};

struct pptp_msg_sli {

- u_int16_t peer_call_id;

- u_int16_t reserved1;

- u_int32_t send_accm;

- u_int32_t recv_accm;

+ uint16_t peer_call_id;

+ uint16_t reserved1;

+ uint32_t send_accm;

+ uint32_t recv_accm;

};

/* attributes that appear more than once in above messages:

};

/* attributes that appear more than once in above messages:

Number of

occurence attributes

--------------------------------------

Number of

occurence attributes

--------------------------------------

- 2 u_int32_t bearer_cap;

- 2 u_int32_t bearer_type;

- 6 u_int16_t call_id;

- 2 u_int16_t call_ser;

- 2 u_int16_t cause_code;

- 2 u_int32_t conn_speed;

- 6 u_int8_t err_code;

- 2 u_int16_t firm_rev;

- 2 u_int32_t framing_cap;

- 2 u_int32_t framing_type;

+ 2 uint32_t bearer_cap;

+ 2 uint32_t bearer_type;

+ 6 uint16_t call_id;

+ 2 uint16_t call_ser;

+ 2 uint16_t cause_code;

+ 2 uint32_t conn_speed;

+ 6 uint8_t err_code;

+ 2 uint16_t firm_rev;

+ 2 uint32_t framing_cap;

+ 2 uint32_t framing_type;

2 u_char hostname[64];

- 2 u_int32_t id;

- 2 u_int16_t max_channel;

- 5 u_int16_t peer_call_id;

- 2 u_int32_t phy_chan_id;

- 4 u_int16_t pkt_proc_delay;

- 2 u_int16_t proto_ver;

- 4 u_int16_t recv_winsiz;

- 2 u_int8_t reserved1;

- 9 u_int16_t reserved1;

- 6 u_int8_t result_code;

+ 2 uint32_t id;

+ 2 uint16_t max_channel;

+ 5 uint16_t peer_call_id;

+ 2 uint32_t phy_chan_id;

+ 4 uint16_t pkt_proc_delay;

+ 2 uint16_t proto_ver;

+ 4 uint16_t recv_winsiz;

+ 2 uint8_t reserved1;

+ 9 uint16_t reserved1;

+ 6 uint8_t result_code;

2 u_char subaddr[64];

2 u_char vendor[64];

2 u_char subaddr[64];

2 u_char vendor[64];

/******************************************/

/* In these attribute-specific print-out functions, it't not necessary

/******************************************/

/* In these attribute-specific print-out functions, it't not necessary

- to do TCHECK because they are already checked in the caller of

+ to do ND_TCHECK because they are already checked in the caller of

these functions. */

static void

these functions. */

static void

-pptp_bearer_cap_print(const u_int32_t *bearer_cap)

+pptp_bearer_cap_print(netdissect_options *ndo,

+ const uint32_t *bearer_cap)

{

- printf(" BEARER_CAP(");

- if (ntohl(*bearer_cap) & PPTP_BEARER_CAP_DIGITAL_MASK) {

- printf("D");

- }

- if (ntohl(*bearer_cap) & PPTP_BEARER_CAP_ANALOG_MASK) {

- printf("A");

- }

- printf(")");

+ ND_PRINT((ndo, " BEARER_CAP(%s%s)",

+ EXTRACT_32BITS(bearer_cap) & PPTP_BEARER_CAP_DIGITAL_MASK ? "D" : "",

+ EXTRACT_32BITS(bearer_cap) & PPTP_BEARER_CAP_ANALOG_MASK ? "A" : ""));

}

+static const struct tok pptp_btype_str[] = {

+ { 1, "A" }, /* Analog */

+ { 2, "D" }, /* Digital */

+ { 3, "Any" },

+ { 0, NULL }

+};

+

static void

-pptp_bearer_type_print(const u_int32_t *bearer_type)

+pptp_bearer_type_print(netdissect_options *ndo,

+ const uint32_t *bearer_type)

{

- printf(" BEARER_TYPE(");

- switch (ntohl(*bearer_type)) {

- case 1:

- printf("A"); /* Analog */

- break;

- case 2:

- printf("D"); /* Digital */

- break;

- case 3:

- printf("Any");

- break;

- default:

- printf("?");

- break;

- }

- printf(")");

+ ND_PRINT((ndo, " BEARER_TYPE(%s)",

+ tok2str(pptp_btype_str, "?", EXTRACT_32BITS(bearer_type))));

}

static void

}

static void

-pptp_call_id_print(const u_int16_t *call_id)

+pptp_call_id_print(netdissect_options *ndo,

+ const uint16_t *call_id)

{

- printf(" CALL_ID(%u)", ntohs(*call_id));

+ ND_PRINT((ndo, " CALL_ID(%u)", EXTRACT_16BITS(call_id)));

}

static void

}

static void

-pptp_call_ser_print(const u_int16_t *call_ser)

+pptp_call_ser_print(netdissect_options *ndo,

+ const uint16_t *call_ser)

{

- printf(" CALL_SER_NUM(%u)", ntohs(*call_ser));

+ ND_PRINT((ndo, " CALL_SER_NUM(%u)", EXTRACT_16BITS(call_ser)));

}

static void

}

static void

-pptp_cause_code_print(const u_int16_t *cause_code)

+pptp_cause_code_print(netdissect_options *ndo,

+ const uint16_t *cause_code)

{

- printf(" CAUSE_CODE(%u)", ntohs(*cause_code));

+ ND_PRINT((ndo, " CAUSE_CODE(%u)", EXTRACT_16BITS(cause_code)));

}

static void

}

static void

-pptp_conn_speed_print(const u_int32_t *conn_speed)

+pptp_conn_speed_print(netdissect_options *ndo,

+ const uint32_t *conn_speed)

{

- printf(" CONN_SPEED(%lu)", (unsigned long)ntohl(*conn_speed));

+ ND_PRINT((ndo, " CONN_SPEED(%u)", EXTRACT_32BITS(conn_speed)));

}

+static const struct tok pptp_errcode_str[] = {

+ { 0, "None" },

+ { 1, "Not-Connected" },

+ { 2, "Bad-Format" },

+ { 3, "Bad-Value" },

+ { 4, "No-Resource" },

+ { 5, "Bad-Call-ID" },

+ { 6, "PAC-Error" },

+ { 0, NULL }

+};

+

static void

-pptp_err_code_print(const u_int8_t *err_code)

+pptp_err_code_print(netdissect_options *ndo,

+ const uint8_t *err_code)

{

- printf(" ERR_CODE(%u", *err_code);

- if (vflag) {

- switch (*err_code) {

- case 0:

- printf(":None");

- break;

- case 1:

- printf(":Not-Connected");

- break;

- case 2:

- printf(":Bad-Format");

- break;

- case 3:

- printf(":Bad-Valude");

- break;

- case 4:

- printf(":No-Resource");

- break;

- case 5:

- printf(":Bad-Call-ID");

- break;

- case 6:

- printf(":PAC-Error");

- break;

- default:

- printf(":?");

- break;

- }

+ ND_PRINT((ndo, " ERR_CODE(%u", *err_code));

+ if (ndo->ndo_vflag) {

+ ND_PRINT((ndo, ":%s", tok2str(pptp_errcode_str, "?", *err_code)));

}

- printf(")");

+ ND_PRINT((ndo, ")"));

}

static void

}

static void

-pptp_firm_rev_print(const u_int16_t *firm_rev)

+pptp_firm_rev_print(netdissect_options *ndo,

+ const uint16_t *firm_rev)

{

- printf(" FIRM_REV(%u)", ntohs(*firm_rev));

+ ND_PRINT((ndo, " FIRM_REV(%u)", EXTRACT_16BITS(firm_rev)));

}

static void

}

static void

-pptp_framing_cap_print(const u_int32_t *framing_cap)

+pptp_framing_cap_print(netdissect_options *ndo,

+ const uint32_t *framing_cap)

{

- printf(" FRAME_CAP(");

- if (ntohl(*framing_cap) & PPTP_FRAMING_CAP_ASYNC_MASK) {

- printf("A"); /* Async */

+ ND_PRINT((ndo, " FRAME_CAP("));

+ if (EXTRACT_32BITS(framing_cap) & PPTP_FRAMING_CAP_ASYNC_MASK) {

+ ND_PRINT((ndo, "A")); /* Async */

}

- if (ntohl(*framing_cap) & PPTP_FRAMING_CAP_SYNC_MASK) {

- printf("S"); /* Sync */

+ if (EXTRACT_32BITS(framing_cap) & PPTP_FRAMING_CAP_SYNC_MASK) {

+ ND_PRINT((ndo, "S")); /* Sync */

}

- printf(")");

+ ND_PRINT((ndo, ")"));

}

+static const struct tok pptp_ftype_str[] = {

+ { 1, "A" }, /* Async */

+ { 2, "S" }, /* Sync */

+ { 3, "E" }, /* Either */

+ { 0, NULL }

+};

+

static void

-pptp_framing_type_print(const u_int32_t *framing_type)

+pptp_framing_type_print(netdissect_options *ndo,

+ const uint32_t *framing_type)

{

- printf(" FRAME_TYPE(");

- switch (ntohl(*framing_type)) {

- case 1:

- printf("A"); /* Async */

- break;

- case 2:

- printf("S"); /* Sync */

- break;

- case 3:

- printf("E"); /* Either */

- break;

- default:

- printf("?");

- break;

- }

- printf(")");

+ ND_PRINT((ndo, " FRAME_TYPE(%s)",

+ tok2str(pptp_ftype_str, "?", EXTRACT_32BITS(framing_type))));

}

static void

}

static void

-pptp_hostname_print(const u_char *hostname)

+pptp_hostname_print(netdissect_options *ndo,

+ const u_char *hostname)

{

- printf(" HOSTNAME(%.64s)", hostname);

+ ND_PRINT((ndo, " HOSTNAME(%.64s)", hostname));

}

static void

}

static void

-pptp_id_print(const u_int32_t *id)

+pptp_id_print(netdissect_options *ndo,

+ const uint32_t *id)

{

- printf(" ID(%lu)", (unsigned long)ntohl(*id));

+ ND_PRINT((ndo, " ID(%u)", EXTRACT_32BITS(id)));

}

static void

}

static void

-pptp_max_channel_print(const u_int16_t *max_channel)

+pptp_max_channel_print(netdissect_options *ndo,

+ const uint16_t *max_channel)

{

- printf(" MAX_CHAN(%u)", ntohs(*max_channel));

+ ND_PRINT((ndo, " MAX_CHAN(%u)", EXTRACT_16BITS(max_channel)));

}

static void

}

static void

-pptp_peer_call_id_print(const u_int16_t *peer_call_id)

+pptp_peer_call_id_print(netdissect_options *ndo,

+ const uint16_t *peer_call_id)

{

- printf(" PEER_CALL_ID(%u)", ntohs(*peer_call_id));

+ ND_PRINT((ndo, " PEER_CALL_ID(%u)", EXTRACT_16BITS(peer_call_id)));

}

static void

}

static void

-pptp_phy_chan_id_print(const u_int32_t *phy_chan_id)

+pptp_phy_chan_id_print(netdissect_options *ndo,

+ const uint32_t *phy_chan_id)

{

- printf(" PHY_CHAN_ID(%lu)", (unsigned long)ntohl(*phy_chan_id));

+ ND_PRINT((ndo, " PHY_CHAN_ID(%u)", EXTRACT_32BITS(phy_chan_id)));

}

static void

}

static void

-pptp_pkt_proc_delay_print(const u_int16_t *pkt_proc_delay)

+pptp_pkt_proc_delay_print(netdissect_options *ndo,

+ const uint16_t *pkt_proc_delay)

{

- printf(" PROC_DELAY(%u)", ntohs(*pkt_proc_delay));

+ ND_PRINT((ndo, " PROC_DELAY(%u)", EXTRACT_16BITS(pkt_proc_delay)));

}

static void

}

static void

-pptp_proto_ver_print(const u_int16_t *proto_ver)

+pptp_proto_ver_print(netdissect_options *ndo,

+ const uint16_t *proto_ver)

{

- printf(" PROTO_VER(%u.%u)", /* Version.Revision */

- ntohs(*proto_ver) >> 8, ntohs(*proto_ver) & 0xff);

+ ND_PRINT((ndo, " PROTO_VER(%u.%u)", /* Version.Revision */

+ EXTRACT_16BITS(proto_ver) >> 8,

+ EXTRACT_16BITS(proto_ver) & 0xff));

}

static void

}

static void

-pptp_recv_winsiz_print(const u_int16_t *recv_winsiz)

+pptp_recv_winsiz_print(netdissect_options *ndo,

+ const uint16_t *recv_winsiz)

{

- printf(" RECV_WIN(%u)", ntohs(*recv_winsiz));

+ ND_PRINT((ndo, " RECV_WIN(%u)", EXTRACT_16BITS(recv_winsiz)));

}

+static const struct tok pptp_scrrp_str[] = {

+ { 1, "Successful channel establishment" },

+ { 2, "General error" },

+ { 3, "Command channel already exists" },

+ { 4, "Requester is not authorized to establish a command channel" },

+ { 5, "The protocol version of the requester is not supported" },

+ { 0, NULL }

+};

+

+static const struct tok pptp_echorp_str[] = {

+ { 1, "OK" },

+ { 2, "General Error" },

+ { 0, NULL }

+};

+

+static const struct tok pptp_ocrp_str[] = {

+ { 1, "Connected" },

+ { 2, "General Error" },

+ { 3, "No Carrier" },

+ { 4, "Busy" },

+ { 5, "No Dial Tone" },

+ { 6, "Time-out" },

+ { 7, "Do Not Accept" },

+ { 0, NULL }

+};

+

+static const struct tok pptp_icrp_str[] = {

+ { 1, "Connect" },

+ { 2, "General Error" },

+ { 3, "Do Not Accept" },

+ { 0, NULL }

+};

+

+static const struct tok pptp_cdn_str[] = {

+ { 1, "Lost Carrier" },

+ { 2, "General Error" },

+ { 3, "Admin Shutdown" },

+ { 4, "Request" },

+ { 0, NULL }

+};

+

static void

-pptp_result_code_print(const u_int8_t *result_code, int ctrl_msg_type)

-{

- printf(" RESULT_CODE(%u", *result_code);

- if (vflag) {

- switch (ctrl_msg_type) {

- case PPTP_CTRL_MSG_TYPE_SCCRP:

- switch (*result_code) {

- case 1:

- printf(":Successful channel establishment");

- break;

- case 2:

- printf(":General error");

- break;

- case 3:

- printf(":Command channel already exists");

- break;

- case 4:

- printf(":Requester is not authorized to establish a command channel");

- break;

- case 5:

- printf(":The protocol version of the requester is not supported");

- break;

- default:

- printf(":?");

- break;

- }

- break;

- case PPTP_CTRL_MSG_TYPE_StopCCRP:

- case PPTP_CTRL_MSG_TYPE_ECHORP:

- switch (*result_code) {

- case 1:

- printf(":OK");

- break;

- case 2:

- printf(":General Error");

- break;

- default:

- printf(":?");

- break;

- }

- break;

- case PPTP_CTRL_MSG_TYPE_OCRP:

- switch (*result_code) {

- case 1:

- printf(":Connected");

- break;

- case 2:

- printf(":General Error");

- break;

- case 3:

- printf(":No Carrier");

- break;

- case 4:

- printf(":Busy");

- break;

- case 5:

- printf(":No Dial Tone");

- break;

- case 6:

- printf(":Time-out");

- break;

- case 7:

- printf(":Do Not Accept");

- break;

- default:

- printf(":?");

- break;

- }

- break;

- case PPTP_CTRL_MSG_TYPE_ICRP:

- switch (*result_code) {

- case 1:

- printf(":Connect");

- break;

- case 2:

- printf(":General Error");

- break;

- case 3:

- printf(":Do Not Accept");

- break;

- default:

- printf(":?");

- break;

- }

- break;

- case PPTP_CTRL_MSG_TYPE_CDN:

- switch (*result_code) {

- case 1:

- printf(":Lost Carrier");

- break;

- case 2:

- printf(":General Error");

- break;

- case 3:

- printf(":Admin Shutdown");

- break;

- case 4:

- printf(":Request");

- default:

- printf(":?");

- break;

- }

- default:

- /* assertion error */

- break;

- }

+pptp_result_code_print(netdissect_options *ndo,

+ const uint8_t *result_code, int ctrl_msg_type)

+{

+ ND_PRINT((ndo, " RESULT_CODE(%u", *result_code));

+ if (ndo->ndo_vflag) {

+ const struct tok *dict =

+ ctrl_msg_type == PPTP_CTRL_MSG_TYPE_SCCRP ? pptp_scrrp_str :

+ ctrl_msg_type == PPTP_CTRL_MSG_TYPE_StopCCRP ? pptp_echorp_str :

+ ctrl_msg_type == PPTP_CTRL_MSG_TYPE_ECHORP ? pptp_echorp_str :

+ ctrl_msg_type == PPTP_CTRL_MSG_TYPE_OCRP ? pptp_ocrp_str :

+ ctrl_msg_type == PPTP_CTRL_MSG_TYPE_ICRP ? pptp_icrp_str :

+ ctrl_msg_type == PPTP_CTRL_MSG_TYPE_CDN ? pptp_cdn_str :

+ NULL; /* assertion error */

+ if (dict != NULL)

+ ND_PRINT((ndo, ":%s", tok2str(dict, "?", *result_code)));

}

- printf(")");

+ ND_PRINT((ndo, ")"));

}

static void

}

static void

-pptp_subaddr_print(const u_char *subaddr)

+pptp_subaddr_print(netdissect_options *ndo,

+ const u_char *subaddr)

{

- printf(" SUB_ADDR(%.64s)", subaddr);

+ ND_PRINT((ndo, " SUB_ADDR(%.64s)", subaddr));

}

static void

}

static void

-pptp_vendor_print(const u_char *vendor)

+pptp_vendor_print(netdissect_options *ndo,

+ const u_char *vendor)

{

- printf(" VENDOR(%.64s)", vendor);

+ ND_PRINT((ndo, " VENDOR(%.64s)", vendor));

}

/************************************/

/* PPTP message print out functions */

/************************************/

static void

}

/************************************/

/* PPTP message print out functions */

/************************************/

static void

-pptp_sccrq_print(const u_char *dat)

+pptp_sccrq_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_sccrq *ptr = (struct pptp_msg_sccrq *)dat;

{

struct pptp_msg_sccrq *ptr = (struct pptp_msg_sccrq *)dat;

- TCHECK(ptr->proto_ver);

- pptp_proto_ver_print(&ptr->proto_ver);

- TCHECK(ptr->reserved1);

- TCHECK(ptr->framing_cap);

- pptp_framing_cap_print(&ptr->framing_cap);

- TCHECK(ptr->bearer_cap);

- pptp_bearer_cap_print(&ptr->bearer_cap);

- TCHECK(ptr->max_channel);

- pptp_max_channel_print(&ptr->max_channel);

- TCHECK(ptr->firm_rev);

- pptp_firm_rev_print(&ptr->firm_rev);

- TCHECK(ptr->hostname);

- pptp_hostname_print(&ptr->hostname[0]);

- TCHECK(ptr->vendor);

- pptp_vendor_print(&ptr->vendor[0]);

+ ND_TCHECK(ptr->proto_ver);

+ pptp_proto_ver_print(ndo, &ptr->proto_ver);

+ ND_TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->framing_cap);

+ pptp_framing_cap_print(ndo, &ptr->framing_cap);

+ ND_TCHECK(ptr->bearer_cap);

+ pptp_bearer_cap_print(ndo, &ptr->bearer_cap);

+ ND_TCHECK(ptr->max_channel);

+ pptp_max_channel_print(ndo, &ptr->max_channel);

+ ND_TCHECK(ptr->firm_rev);

+ pptp_firm_rev_print(ndo, &ptr->firm_rev);

+ ND_TCHECK(ptr->hostname);

+ pptp_hostname_print(ndo, &ptr->hostname[0]);

+ ND_TCHECK(ptr->vendor);

+ pptp_vendor_print(ndo, &ptr->vendor[0]);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_sccrp_print(const u_char *dat)

+pptp_sccrp_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_sccrp *ptr = (struct pptp_msg_sccrp *)dat;

{

struct pptp_msg_sccrp *ptr = (struct pptp_msg_sccrp *)dat;

- TCHECK(ptr->proto_ver);

- pptp_proto_ver_print(&ptr->proto_ver);

- TCHECK(ptr->result_code);

- pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_SCCRP);

- TCHECK(ptr->err_code);

- pptp_err_code_print(&ptr->err_code);

- TCHECK(ptr->framing_cap);

- pptp_framing_cap_print(&ptr->framing_cap);

- TCHECK(ptr->bearer_cap);

- pptp_bearer_cap_print(&ptr->bearer_cap);

- TCHECK(ptr->max_channel);

- pptp_max_channel_print(&ptr->max_channel);

- TCHECK(ptr->firm_rev);

- pptp_firm_rev_print(&ptr->firm_rev);

- TCHECK(ptr->hostname);

- pptp_hostname_print(&ptr->hostname[0]);

- TCHECK(ptr->vendor);

- pptp_vendor_print(&ptr->vendor[0]);

+ ND_TCHECK(ptr->proto_ver);

+ pptp_proto_ver_print(ndo, &ptr->proto_ver);

+ ND_TCHECK(ptr->result_code);

+ pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_SCCRP);

+ ND_TCHECK(ptr->err_code);

+ pptp_err_code_print(ndo, &ptr->err_code);

+ ND_TCHECK(ptr->framing_cap);

+ pptp_framing_cap_print(ndo, &ptr->framing_cap);

+ ND_TCHECK(ptr->bearer_cap);

+ pptp_bearer_cap_print(ndo, &ptr->bearer_cap);

+ ND_TCHECK(ptr->max_channel);

+ pptp_max_channel_print(ndo, &ptr->max_channel);

+ ND_TCHECK(ptr->firm_rev);

+ pptp_firm_rev_print(ndo, &ptr->firm_rev);

+ ND_TCHECK(ptr->hostname);

+ pptp_hostname_print(ndo, &ptr->hostname[0]);

+ ND_TCHECK(ptr->vendor);

+ pptp_vendor_print(ndo, &ptr->vendor[0]);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_stopccrq_print(const u_char *dat)

+pptp_stopccrq_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_stopccrq *ptr = (struct pptp_msg_stopccrq *)dat;

{

struct pptp_msg_stopccrq *ptr = (struct pptp_msg_stopccrq *)dat;

- TCHECK(ptr->reason);

- printf(" REASON(%u", ptr->reason);

- if (vflag) {

+ ND_TCHECK(ptr->reason);

+ ND_PRINT((ndo, " REASON(%u", ptr->reason));

+ if (ndo->ndo_vflag) {

switch (ptr->reason) {

case 1:

switch (ptr->reason) {

case 1:

- printf(":None");

+ ND_PRINT((ndo, ":None"));

break;

case 2:

break;

case 2:

- printf(":Stop-Protocol");

+ ND_PRINT((ndo, ":Stop-Protocol"));

break;

case 3:

break;

case 3:

- printf(":Stop-Local-Shutdown");

+ ND_PRINT((ndo, ":Stop-Local-Shutdown"));

break;

default:

break;

default:

- printf(":?");

+ ND_PRINT((ndo, ":?"));

break;

}

break;

}

- printf(")");

- TCHECK(ptr->reserved1);

- TCHECK(ptr->reserved2);

+ ND_PRINT((ndo, ")"));

+ ND_TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->reserved2);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_stopccrp_print(const u_char *dat)

+pptp_stopccrp_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_stopccrp *ptr = (struct pptp_msg_stopccrp *)dat;

{

struct pptp_msg_stopccrp *ptr = (struct pptp_msg_stopccrp *)dat;

- TCHECK(ptr->result_code);

- pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_StopCCRP);

- TCHECK(ptr->err_code);

- pptp_err_code_print(&ptr->err_code);

- TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->result_code);

+ pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_StopCCRP);

+ ND_TCHECK(ptr->err_code);

+ pptp_err_code_print(ndo, &ptr->err_code);

+ ND_TCHECK(ptr->reserved1);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_echorq_print(const u_char *dat)

+pptp_echorq_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_echorq *ptr = (struct pptp_msg_echorq *)dat;

{

struct pptp_msg_echorq *ptr = (struct pptp_msg_echorq *)dat;

- TCHECK(ptr->id);

- pptp_id_print(&ptr->id);

+ ND_TCHECK(ptr->id);

+ pptp_id_print(ndo, &ptr->id);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_echorp_print(const u_char *dat)

+pptp_echorp_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_echorp *ptr = (struct pptp_msg_echorp *)dat;

{

struct pptp_msg_echorp *ptr = (struct pptp_msg_echorp *)dat;

- TCHECK(ptr->id);

- pptp_id_print(&ptr->id);

- TCHECK(ptr->result_code);

- pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_ECHORP);

- TCHECK(ptr->err_code);

- pptp_err_code_print(&ptr->err_code);

- TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->id);

+ pptp_id_print(ndo, &ptr->id);

+ ND_TCHECK(ptr->result_code);

+ pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_ECHORP);

+ ND_TCHECK(ptr->err_code);

+ pptp_err_code_print(ndo, &ptr->err_code);

+ ND_TCHECK(ptr->reserved1);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_ocrq_print(const u_char *dat)

+pptp_ocrq_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_ocrq *ptr = (struct pptp_msg_ocrq *)dat;

{

struct pptp_msg_ocrq *ptr = (struct pptp_msg_ocrq *)dat;

- TCHECK(ptr->call_id);

- pptp_call_id_print(&ptr->call_id);

- TCHECK(ptr->call_ser);

- pptp_call_ser_print(&ptr->call_ser);

- TCHECK(ptr->min_bps);

- printf(" MIN_BPS(%lu)", (unsigned long)ntohl(ptr->min_bps));

- TCHECK(ptr->max_bps);

- printf(" MAX_BPS(%lu)", (unsigned long)ntohl(ptr->max_bps));

- TCHECK(ptr->bearer_type);

- pptp_bearer_type_print(&ptr->bearer_type);

- TCHECK(ptr->framing_type);

- pptp_framing_type_print(&ptr->framing_type);

- TCHECK(ptr->recv_winsiz);

- pptp_recv_winsiz_print(&ptr->recv_winsiz);

- TCHECK(ptr->pkt_proc_delay);

- pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay);

- TCHECK(ptr->phone_no_len);

- printf(" PHONE_NO_LEN(%u)", ntohs(ptr->phone_no_len));

- TCHECK(ptr->reserved1);

- TCHECK(ptr->phone_no);

- printf(" PHONE_NO(%.64s)", ptr->phone_no);

- TCHECK(ptr->subaddr);

- pptp_subaddr_print(&ptr->subaddr[0]);

+ ND_TCHECK(ptr->call_id);

+ pptp_call_id_print(ndo, &ptr->call_id);

+ ND_TCHECK(ptr->call_ser);

+ pptp_call_ser_print(ndo, &ptr->call_ser);

+ ND_TCHECK(ptr->min_bps);

+ ND_PRINT((ndo, " MIN_BPS(%u)", EXTRACT_32BITS(&ptr->min_bps)));

+ ND_TCHECK(ptr->max_bps);

+ ND_PRINT((ndo, " MAX_BPS(%u)", EXTRACT_32BITS(&ptr->max_bps)));

+ ND_TCHECK(ptr->bearer_type);

+ pptp_bearer_type_print(ndo, &ptr->bearer_type);

+ ND_TCHECK(ptr->framing_type);

+ pptp_framing_type_print(ndo, &ptr->framing_type);

+ ND_TCHECK(ptr->recv_winsiz);

+ pptp_recv_winsiz_print(ndo, &ptr->recv_winsiz);

+ ND_TCHECK(ptr->pkt_proc_delay);

+ pptp_pkt_proc_delay_print(ndo, &ptr->pkt_proc_delay);

+ ND_TCHECK(ptr->phone_no_len);

+ ND_PRINT((ndo, " PHONE_NO_LEN(%u)", EXTRACT_16BITS(&ptr->phone_no_len)));

+ ND_TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->phone_no);

+ ND_PRINT((ndo, " PHONE_NO(%.64s)", ptr->phone_no));

+ ND_TCHECK(ptr->subaddr);

+ pptp_subaddr_print(ndo, &ptr->subaddr[0]);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_ocrp_print(const u_char *dat)

+pptp_ocrp_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_ocrp *ptr = (struct pptp_msg_ocrp *)dat;

{

struct pptp_msg_ocrp *ptr = (struct pptp_msg_ocrp *)dat;

- TCHECK(ptr->call_id);

- pptp_call_id_print(&ptr->call_id);

- TCHECK(ptr->peer_call_id);

- pptp_peer_call_id_print(&ptr->peer_call_id);

- TCHECK(ptr->result_code);

- pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_OCRP);

- TCHECK(ptr->err_code);

- pptp_err_code_print(&ptr->err_code);

- TCHECK(ptr->cause_code);

- pptp_cause_code_print(&ptr->cause_code);

- TCHECK(ptr->conn_speed);

- pptp_conn_speed_print(&ptr->conn_speed);

- TCHECK(ptr->recv_winsiz);

- pptp_recv_winsiz_print(&ptr->recv_winsiz);

- TCHECK(ptr->pkt_proc_delay);

- pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay);

- TCHECK(ptr->phy_chan_id);

- pptp_phy_chan_id_print(&ptr->phy_chan_id);

+ ND_TCHECK(ptr->call_id);

+ pptp_call_id_print(ndo, &ptr->call_id);

+ ND_TCHECK(ptr->peer_call_id);

+ pptp_peer_call_id_print(ndo, &ptr->peer_call_id);

+ ND_TCHECK(ptr->result_code);

+ pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_OCRP);

+ ND_TCHECK(ptr->err_code);

+ pptp_err_code_print(ndo, &ptr->err_code);

+ ND_TCHECK(ptr->cause_code);

+ pptp_cause_code_print(ndo, &ptr->cause_code);

+ ND_TCHECK(ptr->conn_speed);

+ pptp_conn_speed_print(ndo, &ptr->conn_speed);

+ ND_TCHECK(ptr->recv_winsiz);

+ pptp_recv_winsiz_print(ndo, &ptr->recv_winsiz);

+ ND_TCHECK(ptr->pkt_proc_delay);

+ pptp_pkt_proc_delay_print(ndo, &ptr->pkt_proc_delay);

+ ND_TCHECK(ptr->phy_chan_id);

+ pptp_phy_chan_id_print(ndo, &ptr->phy_chan_id);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_icrq_print(const u_char *dat)

+pptp_icrq_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_icrq *ptr = (struct pptp_msg_icrq *)dat;

{

struct pptp_msg_icrq *ptr = (struct pptp_msg_icrq *)dat;

- TCHECK(ptr->call_id);

- pptp_call_id_print(&ptr->call_id);

- TCHECK(ptr->call_ser);

- pptp_call_ser_print(&ptr->call_ser);

- TCHECK(ptr->bearer_type);

- pptp_bearer_type_print(&ptr->bearer_type);

- TCHECK(ptr->phy_chan_id);

- pptp_phy_chan_id_print(&ptr->phy_chan_id);

- TCHECK(ptr->dialed_no_len);

- printf(" DIALED_NO_LEN(%u)", ntohs(ptr->dialed_no_len));

- TCHECK(ptr->dialing_no_len);

- printf(" DIALING_NO_LEN(%u)", ntohs(ptr->dialing_no_len));

- TCHECK(ptr->dialed_no);

- printf(" DIALED_NO(%.64s)", ptr->dialed_no);

- TCHECK(ptr->dialing_no);

- printf(" DIALING_NO(%.64s)", ptr->dialing_no);

- TCHECK(ptr->subaddr);

- pptp_subaddr_print(&ptr->subaddr[0]);

+ ND_TCHECK(ptr->call_id);

+ pptp_call_id_print(ndo, &ptr->call_id);

+ ND_TCHECK(ptr->call_ser);

+ pptp_call_ser_print(ndo, &ptr->call_ser);

+ ND_TCHECK(ptr->bearer_type);

+ pptp_bearer_type_print(ndo, &ptr->bearer_type);

+ ND_TCHECK(ptr->phy_chan_id);

+ pptp_phy_chan_id_print(ndo, &ptr->phy_chan_id);

+ ND_TCHECK(ptr->dialed_no_len);

+ ND_PRINT((ndo, " DIALED_NO_LEN(%u)", EXTRACT_16BITS(&ptr->dialed_no_len)));

+ ND_TCHECK(ptr->dialing_no_len);

+ ND_PRINT((ndo, " DIALING_NO_LEN(%u)", EXTRACT_16BITS(&ptr->dialing_no_len)));

+ ND_TCHECK(ptr->dialed_no);

+ ND_PRINT((ndo, " DIALED_NO(%.64s)", ptr->dialed_no));

+ ND_TCHECK(ptr->dialing_no);

+ ND_PRINT((ndo, " DIALING_NO(%.64s)", ptr->dialing_no));

+ ND_TCHECK(ptr->subaddr);

+ pptp_subaddr_print(ndo, &ptr->subaddr[0]);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_icrp_print(const u_char *dat)

+pptp_icrp_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_icrp *ptr = (struct pptp_msg_icrp *)dat;

{

struct pptp_msg_icrp *ptr = (struct pptp_msg_icrp *)dat;

- TCHECK(ptr->call_id);

- pptp_call_id_print(&ptr->call_id);

- TCHECK(ptr->peer_call_id);

- pptp_peer_call_id_print(&ptr->peer_call_id);

- TCHECK(ptr->result_code);

- pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_ICRP);

- TCHECK(ptr->err_code);

- pptp_err_code_print(&ptr->err_code);

- TCHECK(ptr->recv_winsiz);

- pptp_recv_winsiz_print(&ptr->recv_winsiz);

- TCHECK(ptr->pkt_proc_delay);

- pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay);

- TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->call_id);

+ pptp_call_id_print(ndo, &ptr->call_id);

+ ND_TCHECK(ptr->peer_call_id);

+ pptp_peer_call_id_print(ndo, &ptr->peer_call_id);

+ ND_TCHECK(ptr->result_code);

+ pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_ICRP);

+ ND_TCHECK(ptr->err_code);

+ pptp_err_code_print(ndo, &ptr->err_code);

+ ND_TCHECK(ptr->recv_winsiz);

+ pptp_recv_winsiz_print(ndo, &ptr->recv_winsiz);

+ ND_TCHECK(ptr->pkt_proc_delay);

+ pptp_pkt_proc_delay_print(ndo, &ptr->pkt_proc_delay);

+ ND_TCHECK(ptr->reserved1);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_iccn_print(const u_char *dat)

+pptp_iccn_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_iccn *ptr = (struct pptp_msg_iccn *)dat;

{

struct pptp_msg_iccn *ptr = (struct pptp_msg_iccn *)dat;

- TCHECK(ptr->peer_call_id);

- pptp_peer_call_id_print(&ptr->peer_call_id);

- TCHECK(ptr->reserved1);

- TCHECK(ptr->conn_speed);

- pptp_conn_speed_print(&ptr->conn_speed);

- TCHECK(ptr->recv_winsiz);

- pptp_recv_winsiz_print(&ptr->recv_winsiz);

- TCHECK(ptr->pkt_proc_delay);

- pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay);

- TCHECK(ptr->framing_type);

- pptp_framing_type_print(&ptr->framing_type);

+ ND_TCHECK(ptr->peer_call_id);

+ pptp_peer_call_id_print(ndo, &ptr->peer_call_id);

+ ND_TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->conn_speed);

+ pptp_conn_speed_print(ndo, &ptr->conn_speed);

+ ND_TCHECK(ptr->recv_winsiz);

+ pptp_recv_winsiz_print(ndo, &ptr->recv_winsiz);

+ ND_TCHECK(ptr->pkt_proc_delay);

+ pptp_pkt_proc_delay_print(ndo, &ptr->pkt_proc_delay);

+ ND_TCHECK(ptr->framing_type);

+ pptp_framing_type_print(ndo, &ptr->framing_type);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_ccrq_print(const u_char *dat)

+pptp_ccrq_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_ccrq *ptr = (struct pptp_msg_ccrq *)dat;

{

struct pptp_msg_ccrq *ptr = (struct pptp_msg_ccrq *)dat;

- TCHECK(ptr->call_id);

- pptp_call_id_print(&ptr->call_id);

- TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->call_id);

+ pptp_call_id_print(ndo, &ptr->call_id);

+ ND_TCHECK(ptr->reserved1);

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_cdn_print(const u_char *dat)

+pptp_cdn_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_cdn *ptr = (struct pptp_msg_cdn *)dat;

{

struct pptp_msg_cdn *ptr = (struct pptp_msg_cdn *)dat;

- TCHECK(ptr->call_id);

- pptp_call_id_print(&ptr->call_id);

- TCHECK(ptr->result_code);

- pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_CDN);

- TCHECK(ptr->err_code);

- pptp_err_code_print(&ptr->err_code);

- TCHECK(ptr->cause_code);

- pptp_cause_code_print(&ptr->cause_code);

- TCHECK(ptr->reserved1);

- TCHECK(ptr->call_stats);

- printf(" CALL_STATS(%.128s)", ptr->call_stats);

+ ND_TCHECK(ptr->call_id);

+ pptp_call_id_print(ndo, &ptr->call_id);

+ ND_TCHECK(ptr->result_code);

+ pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_CDN);

+ ND_TCHECK(ptr->err_code);

+ pptp_err_code_print(ndo, &ptr->err_code);

+ ND_TCHECK(ptr->cause_code);

+ pptp_cause_code_print(ndo, &ptr->cause_code);

+ ND_TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->call_stats);

+ ND_PRINT((ndo, " CALL_STATS(%.128s)", ptr->call_stats));

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_wen_print(const u_char *dat)

+pptp_wen_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_wen *ptr = (struct pptp_msg_wen *)dat;

{

struct pptp_msg_wen *ptr = (struct pptp_msg_wen *)dat;

- TCHECK(ptr->peer_call_id);

- pptp_peer_call_id_print(&ptr->peer_call_id);

- TCHECK(ptr->reserved1);

- TCHECK(ptr->crc_err);

- printf(" CRC_ERR(%lu)", (unsigned long)ntohl(ptr->crc_err));

- TCHECK(ptr->framing_err);

- printf(" FRAMING_ERR(%lu)", (unsigned long)ntohl(ptr->framing_err));

- TCHECK(ptr->hardware_overrun);

- printf(" HARDWARE_OVERRUN(%lu)",

- (unsigned long)ntohl(ptr->hardware_overrun));

- TCHECK(ptr->buffer_overrun);

- printf(" BUFFER_OVERRUN(%lu)",

- (unsigned long)ntohl(ptr->buffer_overrun));

- TCHECK(ptr->timeout_err);

- printf(" TIMEOUT_ERR(%lu)", (unsigned long)ntohl(ptr->timeout_err));

- TCHECK(ptr->align_err);

- printf(" ALIGN_ERR(%lu)", (unsigned long)ntohl(ptr->align_err));

+ ND_TCHECK(ptr->peer_call_id);

+ pptp_peer_call_id_print(ndo, &ptr->peer_call_id);

+ ND_TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->crc_err);

+ ND_PRINT((ndo, " CRC_ERR(%u)", EXTRACT_32BITS(&ptr->crc_err)));

+ ND_TCHECK(ptr->framing_err);

+ ND_PRINT((ndo, " FRAMING_ERR(%u)", EXTRACT_32BITS(&ptr->framing_err)));

+ ND_TCHECK(ptr->hardware_overrun);

+ ND_PRINT((ndo, " HARDWARE_OVERRUN(%u)", EXTRACT_32BITS(&ptr->hardware_overrun)));

+ ND_TCHECK(ptr->buffer_overrun);

+ ND_PRINT((ndo, " BUFFER_OVERRUN(%u)", EXTRACT_32BITS(&ptr->buffer_overrun)));

+ ND_TCHECK(ptr->timeout_err);

+ ND_PRINT((ndo, " TIMEOUT_ERR(%u)", EXTRACT_32BITS(&ptr->timeout_err)));

+ ND_TCHECK(ptr->align_err);

+ ND_PRINT((ndo, " ALIGN_ERR(%u)", EXTRACT_32BITS(&ptr->align_err)));

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

static void

}

static void

-pptp_sli_print(const u_char *dat)

+pptp_sli_print(netdissect_options *ndo,

+ const u_char *dat)

{

struct pptp_msg_sli *ptr = (struct pptp_msg_sli *)dat;

{

struct pptp_msg_sli *ptr = (struct pptp_msg_sli *)dat;

- TCHECK(ptr->peer_call_id);

- pptp_peer_call_id_print(&ptr->peer_call_id);

- TCHECK(ptr->reserved1);

- TCHECK(ptr->send_accm);

- printf(" SEND_ACCM(0x%08lx)", (unsigned long)ntohl(ptr->send_accm));

- TCHECK(ptr->recv_accm);

- printf(" RECV_ACCM(0x%08lx)", (unsigned long)ntohl(ptr->recv_accm));

+ ND_TCHECK(ptr->peer_call_id);

+ pptp_peer_call_id_print(ndo, &ptr->peer_call_id);

+ ND_TCHECK(ptr->reserved1);

+ ND_TCHECK(ptr->send_accm);

+ ND_PRINT((ndo, " SEND_ACCM(0x%08x)", EXTRACT_32BITS(&ptr->send_accm)));

+ ND_TCHECK(ptr->recv_accm);

+ ND_PRINT((ndo, " RECV_ACCM(0x%08x)", EXTRACT_32BITS(&ptr->recv_accm)));

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}

void

}

void

-pptp_print(const u_char *dat, u_int length)

+pptp_print(netdissect_options *ndo,

+ const u_char *dat)

{

const struct pptp_hdr *hdr;

{

const struct pptp_hdr *hdr;

- u_int32_t mc;

- u_int16_t ctrl_msg_type;

+ uint32_t mc;

+ uint16_t ctrl_msg_type;

- printf(": pptp");

+ ND_PRINT((ndo, ": pptp"));

hdr = (struct pptp_hdr *)dat;

- TCHECK(hdr->length);

- if (vflag) {

- printf(" Length=%u", ntohs(hdr->length));

+ ND_TCHECK(hdr->length);

+ if (ndo->ndo_vflag) {

+ ND_PRINT((ndo, " Length=%u", EXTRACT_16BITS(&hdr->length)));

}

- TCHECK(hdr->msg_type);

- if (vflag) {

- switch(ntohs(hdr->msg_type)) {

+ ND_TCHECK(hdr->msg_type);

+ if (ndo->ndo_vflag) {

+ switch(EXTRACT_16BITS(&hdr->msg_type)) {

case PPTP_MSG_TYPE_CTRL:

- printf(" CTRL-MSG");

+ ND_PRINT((ndo, " CTRL-MSG"));

break;

case PPTP_MSG_TYPE_MGMT:

break;

case PPTP_MSG_TYPE_MGMT:

- printf(" MGMT-MSG");

+ ND_PRINT((ndo, " MGMT-MSG"));

break;

default:

break;

default:

- printf(" UNKNOWN-MSG-TYPE");

+ ND_PRINT((ndo, " UNKNOWN-MSG-TYPE"));

break;

}

break;

}

- TCHECK(hdr->magic_cookie);

- mc = ntohl(hdr->magic_cookie);

+ ND_TCHECK(hdr->magic_cookie);

+ mc = EXTRACT_32BITS(&hdr->magic_cookie);

if (mc != PPTP_MAGIC_COOKIE) {

- printf(" UNEXPECTED Magic-Cookie!!(%08x)", mc);

+ ND_PRINT((ndo, " UNEXPECTED Magic-Cookie!!(%08x)", mc));

}

- if (vflag || mc != PPTP_MAGIC_COOKIE) {

- printf(" Magic-Cookie=%08x", mc);

+ if (ndo->ndo_vflag || mc != PPTP_MAGIC_COOKIE) {

+ ND_PRINT((ndo, " Magic-Cookie=%08x", mc));

}

- TCHECK(hdr->ctrl_msg_type);

- ctrl_msg_type = ntohs(hdr->ctrl_msg_type);

+ ND_TCHECK(hdr->ctrl_msg_type);

+ ctrl_msg_type = EXTRACT_16BITS(&hdr->ctrl_msg_type);

if (ctrl_msg_type < PPTP_MAX_MSGTYPE_INDEX) {

- printf(" CTRL_MSGTYPE=%s",

- pptp_message_type_string[ctrl_msg_type]);

+ ND_PRINT((ndo, " CTRL_MSGTYPE=%s",

+ pptp_message_type_string[ctrl_msg_type]));

} else {

- printf(" UNKNOWN_CTRL_MSGTYPE(%u)", ctrl_msg_type);

+ ND_PRINT((ndo, " UNKNOWN_CTRL_MSGTYPE(%u)", ctrl_msg_type));

}

- TCHECK(hdr->reserved0);

+ ND_TCHECK(hdr->reserved0);

dat += 12;

switch(ctrl_msg_type) {

case PPTP_CTRL_MSG_TYPE_SCCRQ:

dat += 12;

switch(ctrl_msg_type) {

case PPTP_CTRL_MSG_TYPE_SCCRQ:

- pptp_sccrq_print(dat);

+ pptp_sccrq_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_SCCRP:

break;

case PPTP_CTRL_MSG_TYPE_SCCRP:

- pptp_sccrp_print(dat);

+ pptp_sccrp_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_StopCCRQ:

break;

case PPTP_CTRL_MSG_TYPE_StopCCRQ:

- pptp_stopccrq_print(dat);

+ pptp_stopccrq_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_StopCCRP:

break;

case PPTP_CTRL_MSG_TYPE_StopCCRP:

- pptp_stopccrp_print(dat);

+ pptp_stopccrp_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_ECHORQ:

break;

case PPTP_CTRL_MSG_TYPE_ECHORQ:

- pptp_echorq_print(dat);

+ pptp_echorq_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_ECHORP:

break;

case PPTP_CTRL_MSG_TYPE_ECHORP:

- pptp_echorp_print(dat);

+ pptp_echorp_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_OCRQ:

break;

case PPTP_CTRL_MSG_TYPE_OCRQ:

- pptp_ocrq_print(dat);

+ pptp_ocrq_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_OCRP:

break;

case PPTP_CTRL_MSG_TYPE_OCRP:

- pptp_ocrp_print(dat);

+ pptp_ocrp_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_ICRQ:

break;

case PPTP_CTRL_MSG_TYPE_ICRQ:

- pptp_icrq_print(dat);

+ pptp_icrq_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_ICRP:

break;

case PPTP_CTRL_MSG_TYPE_ICRP:

- pptp_icrp_print(dat);

+ pptp_icrp_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_ICCN:

break;

case PPTP_CTRL_MSG_TYPE_ICCN:

- pptp_iccn_print(dat);

+ pptp_iccn_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_CCRQ:

break;

case PPTP_CTRL_MSG_TYPE_CCRQ:

- pptp_ccrq_print(dat);

+ pptp_ccrq_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_CDN:

break;

case PPTP_CTRL_MSG_TYPE_CDN:

- pptp_cdn_print(dat);

+ pptp_cdn_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_WEN:

break;

case PPTP_CTRL_MSG_TYPE_WEN:

- pptp_wen_print(dat);

+ pptp_wen_print(ndo, dat);

break;

case PPTP_CTRL_MSG_TYPE_SLI:

break;

case PPTP_CTRL_MSG_TYPE_SLI:

- pptp_sli_print(dat);

+ pptp_sli_print(ndo, dat);

break;

default:

/* do nothing */

break;

default:

/* do nothing */

return;

trunc:

return;

trunc:

- printf("%s", tstr);

+ ND_PRINT((ndo, "%s", tstr));

}