X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/10afb02ac804db7fa41a776fd61eff922c09c4df..0845bc813c1cc48b18cdefff0b387c110647463c:/print-pptp.c diff --git a/print-pptp.c b/print-pptp.c index 00f5fe5a..58b1c56c 100644 --- a/print-pptp.c +++ b/print-pptp.c @@ -21,31 +21,16 @@ * PPTP support contributed by Motonori Shindo (mshindo@mshindo.net) */ - -#ifndef lint -static const char rcsid[] = - "@(#) $Header: /tcpdump/master/tcpdump/print-pptp.c,v 1.8 2002-11-09 17:19:29 itojun Exp $"; -#endif - #ifdef HAVE_CONFIG_H #include "config.h" #endif #include -#include - -#include "interface.h" +#include "netdissect.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 */ @@ -98,175 +83,175 @@ static const char *pptp_message_type_string[] = { /* 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; -} __attribute__((packed)); + uint16_t length; + uint16_t msg_type; + uint32_t magic_cookie; + uint16_t ctrl_msg_type; + uint16_t reserved0; +}; 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]; -} __attribute__((packed)); +}; 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]; -} __attribute__((packed)); +}; struct pptp_msg_stopccrq { - u_int8_t reason; - u_int8_t reserved1; - u_int16_t reserved2; -} __attribute__((packed)); + uint8_t reason; + uint8_t reserved1; + uint16_t reserved2; +}; struct pptp_msg_stopccrp { - u_int8_t result_code; - u_int8_t err_code; - u_int16_t reserved1; -} __attribute__((packed)); + uint8_t result_code; + uint8_t err_code; + uint16_t reserved1; +}; struct pptp_msg_echorq { - u_int32_t id; -} __attribute__((packed)); + uint32_t id; +}; struct pptp_msg_echorp { - u_int32_t id; - u_int8_t result_code; - u_int8_t err_code; - u_int16_t reserved1; -} __attribute__((packed)); + uint32_t id; + uint8_t result_code; + uint8_t err_code; + uint16_t reserved1; +}; 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]; -} __attribute__((packed)); +}; 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; -} __attribute__((packed)); + 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 { - 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]; -} __attribute__((packed)); +}; 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; -} __attribute__((packed)); + 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 { - 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; -} __attribute__((packed)); + 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 { - u_int16_t call_id; - u_int16_t reserved1; -} __attribute__((packed)); + uint16_t call_id; + uint16_t reserved1; +}; 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]; -} __attribute__((packed)); +}; 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; -} __attribute__((packed)); + 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 { - u_int16_t peer_call_id; - u_int16_t reserved1; - u_int32_t send_accm; - u_int32_t recv_accm; -} __attribute__((packed)); + 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: 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]; @@ -279,782 +264,733 @@ struct pptp_msg_sli { /******************************************/ /* 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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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; - 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 -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 -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_sccrq_print(const u_char *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]); +pptp_sccrq_print(netdissect_options *ndo, + const u_char *dat) +{ + const struct pptp_msg_sccrq *ptr = (const struct pptp_msg_sccrq *)dat; + + 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: - printf("%s", tstr); -} - -static void -pptp_sccrp_print(const u_char *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_PRINT((ndo, "%s", tstr)); +} + +static void +pptp_sccrp_print(netdissect_options *ndo, + const u_char *dat) +{ + const struct pptp_msg_sccrp *ptr = (const struct pptp_msg_sccrp *)dat; + + 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; + const struct pptp_msg_stopccrq *ptr = (const 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: - printf(":None"); + ND_PRINT((ndo, ":None")); break; case 2: - printf(":Stop-Protocol"); + ND_PRINT((ndo, ":Stop-Protocol")); break; case 3: - printf(":Stop-Local-Shutdown"); + ND_PRINT((ndo, ":Stop-Local-Shutdown")); break; default: - printf(":?"); + ND_PRINT((ndo, ":?")); break; } } - printf(")"); - TCHECK(ptr->reserved1); - TCHECK(ptr->reserved2); + ND_PRINT((ndo, ")")); + ND_TCHECK(ptr->reserved1); + ND_TCHECK(ptr->reserved2); return; trunc: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; + const struct pptp_msg_stopccrp *ptr = (const 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; + const struct pptp_msg_echorq *ptr = (const 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; + const struct pptp_msg_echorp *ptr = (const 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: - printf("%s", tstr); -} - -static void -pptp_ocrq_print(const u_char *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_PRINT((ndo, "%s", tstr)); +} + +static void +pptp_ocrq_print(netdissect_options *ndo, + const u_char *dat) +{ + const struct pptp_msg_ocrq *ptr = (const struct pptp_msg_ocrq *)dat; + + 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: - printf("%s", tstr); -} - -static void -pptp_ocrp_print(const u_char *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_PRINT((ndo, "%s", tstr)); +} + +static void +pptp_ocrp_print(netdissect_options *ndo, + const u_char *dat) +{ + const struct pptp_msg_ocrp *ptr = (const struct pptp_msg_ocrp *)dat; + + 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: - printf("%s", tstr); -} - -static void -pptp_icrq_print(const u_char *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_PRINT((ndo, "%s", tstr)); +} + +static void +pptp_icrq_print(netdissect_options *ndo, + const u_char *dat) +{ + const struct pptp_msg_icrq *ptr = (const struct pptp_msg_icrq *)dat; + + 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; - - 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); + const struct pptp_msg_icrp *ptr = (const struct pptp_msg_icrp *)dat; + + 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; - - 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); + const struct pptp_msg_iccn *ptr = (const struct pptp_msg_iccn *)dat; + + 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; + const struct pptp_msg_ccrq *ptr = (const 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; - - 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); + const struct pptp_msg_cdn *ptr = (const struct pptp_msg_cdn *)dat; + + 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; - - 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)); + const struct pptp_msg_wen *ptr = (const struct pptp_msg_wen *)dat; + + 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } 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; + const struct pptp_msg_sli *ptr = (const 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: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); } void -pptp_print(const u_char *dat) +pptp_print(netdissect_options *ndo, + const u_char *dat) { 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; + hdr = (const 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: - printf(" MGMT-MSG"); + ND_PRINT((ndo, " MGMT-MSG")); break; default: - printf(" UNKNOWN-MSG-TYPE"); + ND_PRINT((ndo, " UNKNOWN-MSG-TYPE")); 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: - pptp_sccrq_print(dat); + pptp_sccrq_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_SCCRP: - pptp_sccrp_print(dat); + pptp_sccrp_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_StopCCRQ: - pptp_stopccrq_print(dat); + pptp_stopccrq_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_StopCCRP: - pptp_stopccrp_print(dat); + pptp_stopccrp_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_ECHORQ: - pptp_echorq_print(dat); + pptp_echorq_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_ECHORP: - pptp_echorp_print(dat); + pptp_echorp_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_OCRQ: - pptp_ocrq_print(dat); + pptp_ocrq_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_OCRP: - pptp_ocrp_print(dat); + pptp_ocrp_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_ICRQ: - pptp_icrq_print(dat); + pptp_icrq_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_ICRP: - pptp_icrp_print(dat); + pptp_icrp_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_ICCN: - pptp_iccn_print(dat); + pptp_iccn_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_CCRQ: - pptp_ccrq_print(dat); + pptp_ccrq_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_CDN: - pptp_cdn_print(dat); + pptp_cdn_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_WEN: - pptp_wen_print(dat); + pptp_wen_print(ndo, dat); break; case PPTP_CTRL_MSG_TYPE_SLI: - pptp_sli_print(dat); + pptp_sli_print(ndo, dat); break; default: /* do nothing */ @@ -1064,5 +1000,5 @@ pptp_print(const u_char *dat) return; trunc: - printf("%s", tstr); + ND_PRINT((ndo, "%s", tstr)); }