X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/f085c93f59fb2332e09f3da20eef5fb2bbd04431..5ef0bcb5edd748de9d9af13c40da0395dfdd94e8:/print-pptp.c diff --git a/print-pptp.c b/print-pptp.c index 9049384f..c1e7644c 100644 --- a/print-pptp.c +++ b/print-pptp.c @@ -23,16 +23,17 @@ /* \summary: Point-to-Point Tunnelling Protocol (PPTP) printer */ +/* specification: RFC 2637 */ + #ifdef HAVE_CONFIG_H -#include "config.h" +#include #endif -#include +#include "netdissect-stdinc.h" #include "netdissect.h" #include "extract.h" -static const char tstr[] = " [|pptp]"; #define PPTP_MSG_TYPE_CTRL 1 /* Control Message */ #define PPTP_MSG_TYPE_MGMT 2 /* Management Message (currently not used */ @@ -85,153 +86,153 @@ static const char *pptp_message_type_string[] = { /* common for all PPTP control messages */ struct pptp_hdr { - uint16_t length; - uint16_t msg_type; - uint32_t magic_cookie; - uint16_t ctrl_msg_type; - uint16_t reserved0; + nd_uint16_t length; + nd_uint16_t msg_type; + nd_uint32_t magic_cookie; + nd_uint16_t ctrl_msg_type; + nd_uint16_t reserved0; }; struct pptp_msg_sccrq { - 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]; + nd_uint16_t proto_ver; + nd_uint16_t reserved1; + nd_uint32_t framing_cap; + nd_uint32_t bearer_cap; + nd_uint16_t max_channel; + nd_uint16_t firm_rev; + nd_byte hostname[64]; + nd_byte vendor[64]; }; struct pptp_msg_sccrp { - 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]; + nd_uint16_t proto_ver; + nd_uint8_t result_code; + nd_uint8_t err_code; + nd_uint32_t framing_cap; + nd_uint32_t bearer_cap; + nd_uint16_t max_channel; + nd_uint16_t firm_rev; + nd_byte hostname[64]; + nd_byte vendor[64]; }; struct pptp_msg_stopccrq { - uint8_t reason; - uint8_t reserved1; - uint16_t reserved2; + nd_uint8_t reason; + nd_uint8_t reserved1; + nd_uint16_t reserved2; }; struct pptp_msg_stopccrp { - uint8_t result_code; - uint8_t err_code; - uint16_t reserved1; + nd_uint8_t result_code; + nd_uint8_t err_code; + nd_uint16_t reserved1; }; struct pptp_msg_echorq { - uint32_t id; + nd_uint32_t id; }; struct pptp_msg_echorp { - uint32_t id; - uint8_t result_code; - uint8_t err_code; - uint16_t reserved1; + nd_uint32_t id; + nd_uint8_t result_code; + nd_uint8_t err_code; + nd_uint16_t reserved1; }; struct pptp_msg_ocrq { - 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]; + nd_uint16_t call_id; + nd_uint16_t call_ser; + nd_uint32_t min_bps; + nd_uint32_t max_bps; + nd_uint32_t bearer_type; + nd_uint32_t framing_type; + nd_uint16_t recv_winsiz; + nd_uint16_t pkt_proc_delay; + nd_uint16_t phone_no_len; + nd_uint16_t reserved1; + nd_byte phone_no[64]; + nd_byte subaddr[64]; }; struct pptp_msg_ocrp { - 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; + nd_uint16_t call_id; + nd_uint16_t peer_call_id; + nd_uint8_t result_code; + nd_uint8_t err_code; + nd_uint16_t cause_code; + nd_uint32_t conn_speed; + nd_uint16_t recv_winsiz; + nd_uint16_t pkt_proc_delay; + nd_uint32_t phy_chan_id; }; struct pptp_msg_icrq { - 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]; + nd_uint16_t call_id; + nd_uint16_t call_ser; + nd_uint32_t bearer_type; + nd_uint32_t phy_chan_id; + nd_uint16_t dialed_no_len; + nd_uint16_t dialing_no_len; + nd_byte dialed_no[64]; /* DNIS */ + nd_byte dialing_no[64]; /* CLID */ + nd_byte subaddr[64]; }; struct pptp_msg_icrp { - 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; + nd_uint16_t call_id; + nd_uint16_t peer_call_id; + nd_uint8_t result_code; + nd_uint8_t err_code; + nd_uint16_t recv_winsiz; + nd_uint16_t pkt_proc_delay; + nd_uint16_t reserved1; }; struct pptp_msg_iccn { - 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; + nd_uint16_t peer_call_id; + nd_uint16_t reserved1; + nd_uint32_t conn_speed; + nd_uint16_t recv_winsiz; + nd_uint16_t pkt_proc_delay; + nd_uint32_t framing_type; }; struct pptp_msg_ccrq { - uint16_t call_id; - uint16_t reserved1; + nd_uint16_t call_id; + nd_uint16_t reserved1; }; struct pptp_msg_cdn { - uint16_t call_id; - uint8_t result_code; - uint8_t err_code; - uint16_t cause_code; - uint16_t reserved1; - u_char call_stats[128]; + nd_uint16_t call_id; + nd_uint8_t result_code; + nd_uint8_t err_code; + nd_uint16_t cause_code; + nd_uint16_t reserved1; + nd_byte call_stats[128]; }; struct pptp_msg_wen { - 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; + nd_uint16_t peer_call_id; + nd_uint16_t reserved1; + nd_uint32_t crc_err; + nd_uint32_t framing_err; + nd_uint32_t hardware_overrun; + nd_uint32_t buffer_overrun; + nd_uint32_t timeout_err; + nd_uint32_t align_err; }; struct pptp_msg_sli { - uint16_t peer_call_id; - uint16_t reserved1; - uint32_t send_accm; - uint32_t recv_accm; + nd_uint16_t peer_call_id; + nd_uint16_t reserved1; + nd_uint32_t send_accm; + nd_uint32_t recv_accm; }; /* attributes that appear more than once in above messages: Number of - occurence attributes + occurrence attributes -------------------------------------- 2 uint32_t bearer_cap; 2 uint32_t bearer_type; @@ -261,6 +262,16 @@ struct pptp_msg_sli { reserved*). */ +#define PRINT_RESERVED_IF_NOT_ZERO_1(reserved) \ + if (GET_U_1(reserved)) \ + ND_PRINT(" [ERROR: reserved=%u must be zero]", \ + GET_U_1(reserved)); + +#define PRINT_RESERVED_IF_NOT_ZERO_2(reserved) \ + if (GET_BE_U_2(reserved)) \ + ND_PRINT(" [ERROR: reserved=%u must be zero]", \ + GET_BE_U_2(reserved)); + /******************************************/ /* Attribute-specific print out functions */ /******************************************/ @@ -271,11 +282,11 @@ struct pptp_msg_sli { static void pptp_bearer_cap_print(netdissect_options *ndo, - const uint32_t *bearer_cap) + const nd_uint32_t *bearer_cap) { - ND_PRINT((ndo, " BEARER_CAP(%s%s)", - EXTRACT_BE_U_4(bearer_cap) & PPTP_BEARER_CAP_DIGITAL_MASK ? "D" : "", - EXTRACT_BE_U_4(bearer_cap) & PPTP_BEARER_CAP_ANALOG_MASK ? "A" : "")); + ND_PRINT(" BEARER_CAP(%s%s)", + GET_BE_U_4(*bearer_cap) & PPTP_BEARER_CAP_DIGITAL_MASK ? "D" : "", + GET_BE_U_4(*bearer_cap) & PPTP_BEARER_CAP_ANALOG_MASK ? "A" : ""); } static const struct tok pptp_btype_str[] = { @@ -287,38 +298,38 @@ static const struct tok pptp_btype_str[] = { static void pptp_bearer_type_print(netdissect_options *ndo, - const uint32_t *bearer_type) + const nd_uint32_t *bearer_type) { - ND_PRINT((ndo, " BEARER_TYPE(%s)", - tok2str(pptp_btype_str, "?", EXTRACT_BE_U_4(bearer_type)))); + ND_PRINT(" BEARER_TYPE(%s)", + tok2str(pptp_btype_str, "?", GET_BE_U_4(*bearer_type))); } static void pptp_call_id_print(netdissect_options *ndo, - const uint16_t *call_id) + const nd_uint16_t *call_id) { - ND_PRINT((ndo, " CALL_ID(%u)", EXTRACT_BE_U_2(call_id))); + ND_PRINT(" CALL_ID(%u)", GET_BE_U_2(*call_id)); } static void pptp_call_ser_print(netdissect_options *ndo, - const uint16_t *call_ser) + const nd_uint16_t *call_ser) { - ND_PRINT((ndo, " CALL_SER_NUM(%u)", EXTRACT_BE_U_2(call_ser))); + ND_PRINT(" CALL_SER_NUM(%u)", GET_BE_U_2(*call_ser)); } static void pptp_cause_code_print(netdissect_options *ndo, - const uint16_t *cause_code) + const nd_uint16_t *cause_code) { - ND_PRINT((ndo, " CAUSE_CODE(%u)", EXTRACT_BE_U_2(cause_code))); + ND_PRINT(" CAUSE_CODE(%u)", GET_BE_U_2(*cause_code)); } static void pptp_conn_speed_print(netdissect_options *ndo, - const uint32_t *conn_speed) + const nd_uint32_t *conn_speed) { - ND_PRINT((ndo, " CONN_SPEED(%u)", EXTRACT_BE_U_4(conn_speed))); + ND_PRINT(" CONN_SPEED(%u)", GET_BE_U_4(*conn_speed)); } static const struct tok pptp_errcode_str[] = { @@ -334,34 +345,35 @@ static const struct tok pptp_errcode_str[] = { static void pptp_err_code_print(netdissect_options *ndo, - const uint8_t *err_code) + const nd_uint8_t *err_code) { - ND_PRINT((ndo, " ERR_CODE(%u", EXTRACT_U_1(err_code))); + ND_PRINT(" ERR_CODE(%u", GET_U_1(*err_code)); if (ndo->ndo_vflag) { - ND_PRINT((ndo, ":%s", tok2str(pptp_errcode_str, "?", EXTRACT_U_1(err_code)))); + ND_PRINT(":%s", + tok2str(pptp_errcode_str, "?", GET_U_1(*err_code))); } - ND_PRINT((ndo, ")")); + ND_PRINT(")"); } static void pptp_firm_rev_print(netdissect_options *ndo, - const uint16_t *firm_rev) + const nd_uint16_t *firm_rev) { - ND_PRINT((ndo, " FIRM_REV(%u)", EXTRACT_BE_U_2(firm_rev))); + ND_PRINT(" FIRM_REV(%u)", GET_BE_U_2(*firm_rev)); } static void pptp_framing_cap_print(netdissect_options *ndo, - const uint32_t *framing_cap) + const nd_uint32_t *framing_cap) { - ND_PRINT((ndo, " FRAME_CAP(")); - if (EXTRACT_BE_U_4(framing_cap) & PPTP_FRAMING_CAP_ASYNC_MASK) { - ND_PRINT((ndo, "A")); /* Async */ + ND_PRINT(" FRAME_CAP("); + if (GET_BE_U_4(*framing_cap) & PPTP_FRAMING_CAP_ASYNC_MASK) { + ND_PRINT("A"); /* Async */ } - if (EXTRACT_BE_U_4(framing_cap) & PPTP_FRAMING_CAP_SYNC_MASK) { - ND_PRINT((ndo, "S")); /* Sync */ + if (GET_BE_U_4(*framing_cap) & PPTP_FRAMING_CAP_SYNC_MASK) { + ND_PRINT("S"); /* Sync */ } - ND_PRINT((ndo, ")")); + ND_PRINT(")"); } static const struct tok pptp_ftype_str[] = { @@ -373,68 +385,68 @@ static const struct tok pptp_ftype_str[] = { static void pptp_framing_type_print(netdissect_options *ndo, - const uint32_t *framing_type) + const nd_uint32_t *framing_type) { - ND_PRINT((ndo, " FRAME_TYPE(%s)", - tok2str(pptp_ftype_str, "?", EXTRACT_BE_U_4(framing_type)))); + ND_PRINT(" FRAME_TYPE(%s)", + tok2str(pptp_ftype_str, "?", GET_BE_U_4(*framing_type))); } static void pptp_hostname_print(netdissect_options *ndo, const u_char *hostname) { - ND_PRINT((ndo, " HOSTNAME(%.64s)", hostname)); + ND_PRINT(" HOSTNAME(%.64s)", hostname); } static void pptp_id_print(netdissect_options *ndo, - const uint32_t *id) + const nd_uint32_t *id) { - ND_PRINT((ndo, " ID(%u)", EXTRACT_BE_U_4(id))); + ND_PRINT(" ID(%u)", GET_BE_U_4(*id)); } static void pptp_max_channel_print(netdissect_options *ndo, - const uint16_t *max_channel) + const nd_uint16_t *max_channel) { - ND_PRINT((ndo, " MAX_CHAN(%u)", EXTRACT_BE_U_2(max_channel))); + ND_PRINT(" MAX_CHAN(%u)", GET_BE_U_2(*max_channel)); } static void pptp_peer_call_id_print(netdissect_options *ndo, - const uint16_t *peer_call_id) + const nd_uint16_t *peer_call_id) { - ND_PRINT((ndo, " PEER_CALL_ID(%u)", EXTRACT_BE_U_2(peer_call_id))); + ND_PRINT(" PEER_CALL_ID(%u)", GET_BE_U_2(*peer_call_id)); } static void pptp_phy_chan_id_print(netdissect_options *ndo, - const uint32_t *phy_chan_id) + const nd_uint32_t *phy_chan_id) { - ND_PRINT((ndo, " PHY_CHAN_ID(%u)", EXTRACT_BE_U_4(phy_chan_id))); + ND_PRINT(" PHY_CHAN_ID(%u)", GET_BE_U_4(*phy_chan_id)); } static void pptp_pkt_proc_delay_print(netdissect_options *ndo, - const uint16_t *pkt_proc_delay) + const nd_uint16_t *pkt_proc_delay) { - ND_PRINT((ndo, " PROC_DELAY(%u)", EXTRACT_BE_U_2(pkt_proc_delay))); + ND_PRINT(" PROC_DELAY(%u)", GET_BE_U_2(*pkt_proc_delay)); } static void pptp_proto_ver_print(netdissect_options *ndo, - const uint16_t *proto_ver) + const nd_uint16_t *proto_ver) { - ND_PRINT((ndo, " PROTO_VER(%u.%u)", /* Version.Revision */ - EXTRACT_BE_U_2(proto_ver) >> 8, - EXTRACT_BE_U_2(proto_ver) & 0xff)); + ND_PRINT(" PROTO_VER(%u.%u)", /* Version.Revision */ + GET_BE_U_2(*proto_ver) >> 8, + GET_BE_U_2(*proto_ver) & 0xff); } static void pptp_recv_winsiz_print(netdissect_options *ndo, - const uint16_t *recv_winsiz) + const nd_uint16_t *recv_winsiz) { - ND_PRINT((ndo, " RECV_WIN(%u)", EXTRACT_BE_U_2(recv_winsiz))); + ND_PRINT(" RECV_WIN(%u)", GET_BE_U_2(*recv_winsiz)); } static const struct tok pptp_scrrp_str[] = { @@ -480,9 +492,9 @@ static const struct tok pptp_cdn_str[] = { static void pptp_result_code_print(netdissect_options *ndo, - const uint8_t *result_code, int ctrl_msg_type) + const nd_uint8_t *result_code, int ctrl_msg_type) { - ND_PRINT((ndo, " RESULT_CODE(%u", EXTRACT_U_1(result_code))); + ND_PRINT(" RESULT_CODE(%u", GET_U_1(*result_code)); if (ndo->ndo_vflag) { const struct tok *dict = ctrl_msg_type == PPTP_CTRL_MSG_TYPE_SCCRP ? pptp_scrrp_str : @@ -493,23 +505,24 @@ pptp_result_code_print(netdissect_options *ndo, ctrl_msg_type == PPTP_CTRL_MSG_TYPE_CDN ? pptp_cdn_str : NULL; /* assertion error */ if (dict != NULL) - ND_PRINT((ndo, ":%s", tok2str(dict, "?", EXTRACT_U_1(result_code)))); + ND_PRINT(":%s", + tok2str(dict, "?", GET_U_1(*result_code))); } - ND_PRINT((ndo, ")")); + ND_PRINT(")"); } static void pptp_subaddr_print(netdissect_options *ndo, const u_char *subaddr) { - ND_PRINT((ndo, " SUB_ADDR(%.64s)", subaddr)); + ND_PRINT(" SUB_ADDR(%.64s)", subaddr); } static void pptp_vendor_print(netdissect_options *ndo, const u_char *vendor) { - ND_PRINT((ndo, " VENDOR(%.64s)", vendor)); + ND_PRINT(" VENDOR(%.64s)", vendor); } /************************************/ @@ -521,26 +534,27 @@ pptp_sccrq_print(netdissect_options *ndo, { const struct pptp_msg_sccrq *ptr = (const struct pptp_msg_sccrq *)dat; - ND_TCHECK(ptr->proto_ver); + ND_TCHECK_2(ptr->proto_ver); pptp_proto_ver_print(ndo, &ptr->proto_ver); - ND_TCHECK(ptr->reserved1); - ND_TCHECK(ptr->framing_cap); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); + ND_TCHECK_4(ptr->framing_cap); pptp_framing_cap_print(ndo, &ptr->framing_cap); - ND_TCHECK(ptr->bearer_cap); + ND_TCHECK_4(ptr->bearer_cap); pptp_bearer_cap_print(ndo, &ptr->bearer_cap); - ND_TCHECK(ptr->max_channel); + ND_TCHECK_2(ptr->max_channel); pptp_max_channel_print(ndo, &ptr->max_channel); - ND_TCHECK(ptr->firm_rev); + ND_TCHECK_2(ptr->firm_rev); pptp_firm_rev_print(ndo, &ptr->firm_rev); - ND_TCHECK(ptr->hostname); + ND_TCHECK_SIZE(&ptr->hostname); pptp_hostname_print(ndo, &ptr->hostname[0]); - ND_TCHECK(ptr->vendor); + ND_TCHECK_SIZE(&ptr->vendor); pptp_vendor_print(ndo, &ptr->vendor[0]); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -549,29 +563,29 @@ pptp_sccrp_print(netdissect_options *ndo, { const struct pptp_msg_sccrp *ptr = (const struct pptp_msg_sccrp *)dat; - ND_TCHECK(ptr->proto_ver); + ND_TCHECK_2(ptr->proto_ver); pptp_proto_ver_print(ndo, &ptr->proto_ver); - ND_TCHECK(ptr->result_code); + ND_TCHECK_1(ptr->result_code); pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_SCCRP); - ND_TCHECK(ptr->err_code); + ND_TCHECK_1(ptr->err_code); pptp_err_code_print(ndo, &ptr->err_code); - ND_TCHECK(ptr->framing_cap); + ND_TCHECK_4(ptr->framing_cap); pptp_framing_cap_print(ndo, &ptr->framing_cap); - ND_TCHECK(ptr->bearer_cap); + ND_TCHECK_4(ptr->bearer_cap); pptp_bearer_cap_print(ndo, &ptr->bearer_cap); - ND_TCHECK(ptr->max_channel); + ND_TCHECK_2(ptr->max_channel); pptp_max_channel_print(ndo, &ptr->max_channel); - ND_TCHECK(ptr->firm_rev); + ND_TCHECK_2(ptr->firm_rev); pptp_firm_rev_print(ndo, &ptr->firm_rev); - ND_TCHECK(ptr->hostname); + ND_TCHECK_SIZE(&ptr->hostname); pptp_hostname_print(ndo, &ptr->hostname[0]); - ND_TCHECK(ptr->vendor); + ND_TCHECK_SIZE(&ptr->vendor); pptp_vendor_print(ndo, &ptr->vendor[0]); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -580,32 +594,33 @@ pptp_stopccrq_print(netdissect_options *ndo, { const struct pptp_msg_stopccrq *ptr = (const struct pptp_msg_stopccrq *)dat; - ND_TCHECK(ptr->reason); - ND_PRINT((ndo, " REASON(%u", ptr->reason)); + ND_PRINT(" REASON(%u", GET_U_1(ptr->reason)); if (ndo->ndo_vflag) { - switch (ptr->reason) { + switch (GET_U_1(ptr->reason)) { case 1: - ND_PRINT((ndo, ":None")); + ND_PRINT(":None"); break; case 2: - ND_PRINT((ndo, ":Stop-Protocol")); + ND_PRINT(":Stop-Protocol"); break; case 3: - ND_PRINT((ndo, ":Stop-Local-Shutdown")); + ND_PRINT(":Stop-Local-Shutdown"); break; default: - ND_PRINT((ndo, ":?")); + ND_PRINT(":?"); break; } } - ND_PRINT((ndo, ")")); - ND_TCHECK(ptr->reserved1); - ND_TCHECK(ptr->reserved2); + ND_PRINT(")"); + ND_TCHECK_1(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_1(ptr->reserved1); + ND_TCHECK_2(ptr->reserved2); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved2); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -614,16 +629,17 @@ pptp_stopccrp_print(netdissect_options *ndo, { const struct pptp_msg_stopccrp *ptr = (const struct pptp_msg_stopccrp *)dat; - ND_TCHECK(ptr->result_code); + ND_TCHECK_1(ptr->result_code); pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_StopCCRP); - ND_TCHECK(ptr->err_code); + ND_TCHECK_1(ptr->err_code); pptp_err_code_print(ndo, &ptr->err_code); - ND_TCHECK(ptr->reserved1); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -632,13 +648,13 @@ pptp_echorq_print(netdissect_options *ndo, { const struct pptp_msg_echorq *ptr = (const struct pptp_msg_echorq *)dat; - ND_TCHECK(ptr->id); + ND_TCHECK_4(ptr->id); pptp_id_print(ndo, &ptr->id); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -647,18 +663,19 @@ pptp_echorp_print(netdissect_options *ndo, { const struct pptp_msg_echorp *ptr = (const struct pptp_msg_echorp *)dat; - ND_TCHECK(ptr->id); + ND_TCHECK_4(ptr->id); pptp_id_print(ndo, &ptr->id); - ND_TCHECK(ptr->result_code); + ND_TCHECK_1(ptr->result_code); pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_ECHORP); - ND_TCHECK(ptr->err_code); + ND_TCHECK_1(ptr->err_code); pptp_err_code_print(ndo, &ptr->err_code); - ND_TCHECK(ptr->reserved1); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -667,34 +684,32 @@ pptp_ocrq_print(netdissect_options *ndo, { const struct pptp_msg_ocrq *ptr = (const struct pptp_msg_ocrq *)dat; - ND_TCHECK(ptr->call_id); + ND_TCHECK_2(ptr->call_id); pptp_call_id_print(ndo, &ptr->call_id); - ND_TCHECK(ptr->call_ser); + ND_TCHECK_2(ptr->call_ser); pptp_call_ser_print(ndo, &ptr->call_ser); - ND_TCHECK(ptr->min_bps); - ND_PRINT((ndo, " MIN_BPS(%u)", EXTRACT_BE_U_4(&ptr->min_bps))); - ND_TCHECK(ptr->max_bps); - ND_PRINT((ndo, " MAX_BPS(%u)", EXTRACT_BE_U_4(&ptr->max_bps))); - ND_TCHECK(ptr->bearer_type); + ND_PRINT(" MIN_BPS(%u)", GET_BE_U_4(ptr->min_bps)); + ND_PRINT(" MAX_BPS(%u)", GET_BE_U_4(ptr->max_bps)); + ND_TCHECK_4(ptr->bearer_type); pptp_bearer_type_print(ndo, &ptr->bearer_type); - ND_TCHECK(ptr->framing_type); + ND_TCHECK_4(ptr->framing_type); pptp_framing_type_print(ndo, &ptr->framing_type); - ND_TCHECK(ptr->recv_winsiz); + ND_TCHECK_2(ptr->recv_winsiz); pptp_recv_winsiz_print(ndo, &ptr->recv_winsiz); - ND_TCHECK(ptr->pkt_proc_delay); + ND_TCHECK_2(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_BE_U_2(&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); + ND_PRINT(" PHONE_NO_LEN(%u)", GET_BE_U_2(ptr->phone_no_len)); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); + ND_TCHECK_SIZE(&ptr->phone_no); + ND_PRINT(" PHONE_NO(%.64s)", ptr->phone_no); + ND_TCHECK_SIZE(&ptr->subaddr); pptp_subaddr_print(ndo, &ptr->subaddr[0]); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -703,29 +718,29 @@ pptp_ocrp_print(netdissect_options *ndo, { const struct pptp_msg_ocrp *ptr = (const struct pptp_msg_ocrp *)dat; - ND_TCHECK(ptr->call_id); + ND_TCHECK_2(ptr->call_id); pptp_call_id_print(ndo, &ptr->call_id); - ND_TCHECK(ptr->peer_call_id); + ND_TCHECK_2(ptr->peer_call_id); pptp_peer_call_id_print(ndo, &ptr->peer_call_id); - ND_TCHECK(ptr->result_code); + ND_TCHECK_1(ptr->result_code); pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_OCRP); - ND_TCHECK(ptr->err_code); + ND_TCHECK_1(ptr->err_code); pptp_err_code_print(ndo, &ptr->err_code); - ND_TCHECK(ptr->cause_code); + ND_TCHECK_2(ptr->cause_code); pptp_cause_code_print(ndo, &ptr->cause_code); - ND_TCHECK(ptr->conn_speed); + ND_TCHECK_4(ptr->conn_speed); pptp_conn_speed_print(ndo, &ptr->conn_speed); - ND_TCHECK(ptr->recv_winsiz); + ND_TCHECK_2(ptr->recv_winsiz); pptp_recv_winsiz_print(ndo, &ptr->recv_winsiz); - ND_TCHECK(ptr->pkt_proc_delay); + ND_TCHECK_2(ptr->pkt_proc_delay); pptp_pkt_proc_delay_print(ndo, &ptr->pkt_proc_delay); - ND_TCHECK(ptr->phy_chan_id); + ND_TCHECK_4(ptr->phy_chan_id); pptp_phy_chan_id_print(ndo, &ptr->phy_chan_id); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -734,29 +749,27 @@ pptp_icrq_print(netdissect_options *ndo, { const struct pptp_msg_icrq *ptr = (const struct pptp_msg_icrq *)dat; - ND_TCHECK(ptr->call_id); + ND_TCHECK_2(ptr->call_id); pptp_call_id_print(ndo, &ptr->call_id); - ND_TCHECK(ptr->call_ser); + ND_TCHECK_2(ptr->call_ser); pptp_call_ser_print(ndo, &ptr->call_ser); - ND_TCHECK(ptr->bearer_type); + ND_TCHECK_4(ptr->bearer_type); pptp_bearer_type_print(ndo, &ptr->bearer_type); - ND_TCHECK(ptr->phy_chan_id); + ND_TCHECK_4(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_BE_U_2(&ptr->dialed_no_len))); - ND_TCHECK(ptr->dialing_no_len); - ND_PRINT((ndo, " DIALING_NO_LEN(%u)", EXTRACT_BE_U_2(&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); + ND_PRINT(" DIALED_NO_LEN(%u)", GET_BE_U_2(ptr->dialed_no_len)); + ND_PRINT(" DIALING_NO_LEN(%u)", GET_BE_U_2(ptr->dialing_no_len)); + ND_TCHECK_SIZE(&ptr->dialed_no); + ND_PRINT(" DIALED_NO(%.64s)", ptr->dialed_no); + ND_TCHECK_SIZE(&ptr->dialing_no); + ND_PRINT(" DIALING_NO(%.64s)", ptr->dialing_no); + ND_TCHECK_SIZE(&ptr->subaddr); pptp_subaddr_print(ndo, &ptr->subaddr[0]); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -765,24 +778,25 @@ pptp_icrp_print(netdissect_options *ndo, { const struct pptp_msg_icrp *ptr = (const struct pptp_msg_icrp *)dat; - ND_TCHECK(ptr->call_id); + ND_TCHECK_2(ptr->call_id); pptp_call_id_print(ndo, &ptr->call_id); - ND_TCHECK(ptr->peer_call_id); + ND_TCHECK_2(ptr->peer_call_id); pptp_peer_call_id_print(ndo, &ptr->peer_call_id); - ND_TCHECK(ptr->result_code); + ND_TCHECK_1(ptr->result_code); pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_ICRP); - ND_TCHECK(ptr->err_code); + ND_TCHECK_1(ptr->err_code); pptp_err_code_print(ndo, &ptr->err_code); - ND_TCHECK(ptr->recv_winsiz); + ND_TCHECK_2(ptr->recv_winsiz); pptp_recv_winsiz_print(ndo, &ptr->recv_winsiz); - ND_TCHECK(ptr->pkt_proc_delay); + ND_TCHECK_2(ptr->pkt_proc_delay); pptp_pkt_proc_delay_print(ndo, &ptr->pkt_proc_delay); - ND_TCHECK(ptr->reserved1); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -791,22 +805,23 @@ pptp_iccn_print(netdissect_options *ndo, { const struct pptp_msg_iccn *ptr = (const struct pptp_msg_iccn *)dat; - ND_TCHECK(ptr->peer_call_id); + ND_TCHECK_2(ptr->peer_call_id); pptp_peer_call_id_print(ndo, &ptr->peer_call_id); - ND_TCHECK(ptr->reserved1); - ND_TCHECK(ptr->conn_speed); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); + ND_TCHECK_4(ptr->conn_speed); pptp_conn_speed_print(ndo, &ptr->conn_speed); - ND_TCHECK(ptr->recv_winsiz); + ND_TCHECK_2(ptr->recv_winsiz); pptp_recv_winsiz_print(ndo, &ptr->recv_winsiz); - ND_TCHECK(ptr->pkt_proc_delay); + ND_TCHECK_2(ptr->pkt_proc_delay); pptp_pkt_proc_delay_print(ndo, &ptr->pkt_proc_delay); - ND_TCHECK(ptr->framing_type); + ND_TCHECK_4(ptr->framing_type); pptp_framing_type_print(ndo, &ptr->framing_type); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -815,14 +830,15 @@ pptp_ccrq_print(netdissect_options *ndo, { const struct pptp_msg_ccrq *ptr = (const struct pptp_msg_ccrq *)dat; - ND_TCHECK(ptr->call_id); + ND_TCHECK_2(ptr->call_id); pptp_call_id_print(ndo, &ptr->call_id); - ND_TCHECK(ptr->reserved1); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -831,22 +847,23 @@ pptp_cdn_print(netdissect_options *ndo, { const struct pptp_msg_cdn *ptr = (const struct pptp_msg_cdn *)dat; - ND_TCHECK(ptr->call_id); + ND_TCHECK_2(ptr->call_id); pptp_call_id_print(ndo, &ptr->call_id); - ND_TCHECK(ptr->result_code); + ND_TCHECK_1(ptr->result_code); pptp_result_code_print(ndo, &ptr->result_code, PPTP_CTRL_MSG_TYPE_CDN); - ND_TCHECK(ptr->err_code); + ND_TCHECK_1(ptr->err_code); pptp_err_code_print(ndo, &ptr->err_code); - ND_TCHECK(ptr->cause_code); + ND_TCHECK_2(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)); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); + ND_TCHECK_SIZE(&ptr->call_stats); + ND_PRINT(" CALL_STATS(%.128s)", ptr->call_stats); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -855,26 +872,21 @@ pptp_wen_print(netdissect_options *ndo, { const struct pptp_msg_wen *ptr = (const struct pptp_msg_wen *)dat; - ND_TCHECK(ptr->peer_call_id); + ND_TCHECK_2(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_BE_U_4(&ptr->crc_err))); - ND_TCHECK(ptr->framing_err); - ND_PRINT((ndo, " FRAMING_ERR(%u)", EXTRACT_BE_U_4(&ptr->framing_err))); - ND_TCHECK(ptr->hardware_overrun); - ND_PRINT((ndo, " HARDWARE_OVERRUN(%u)", EXTRACT_BE_U_4(&ptr->hardware_overrun))); - ND_TCHECK(ptr->buffer_overrun); - ND_PRINT((ndo, " BUFFER_OVERRUN(%u)", EXTRACT_BE_U_4(&ptr->buffer_overrun))); - ND_TCHECK(ptr->timeout_err); - ND_PRINT((ndo, " TIMEOUT_ERR(%u)", EXTRACT_BE_U_4(&ptr->timeout_err))); - ND_TCHECK(ptr->align_err); - ND_PRINT((ndo, " ALIGN_ERR(%u)", EXTRACT_BE_U_4(&ptr->align_err))); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); + ND_PRINT(" CRC_ERR(%u)", GET_BE_U_4(ptr->crc_err)); + ND_PRINT(" FRAMING_ERR(%u)", GET_BE_U_4(ptr->framing_err)); + ND_PRINT(" HARDWARE_OVERRUN(%u)", GET_BE_U_4(ptr->hardware_overrun)); + ND_PRINT(" BUFFER_OVERRUN(%u)", GET_BE_U_4(ptr->buffer_overrun)); + ND_PRINT(" TIMEOUT_ERR(%u)", GET_BE_U_4(ptr->timeout_err)); + ND_PRINT(" ALIGN_ERR(%u)", GET_BE_U_4(ptr->align_err)); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } static void @@ -883,18 +895,17 @@ pptp_sli_print(netdissect_options *ndo, { const struct pptp_msg_sli *ptr = (const struct pptp_msg_sli *)dat; - ND_TCHECK(ptr->peer_call_id); + ND_TCHECK_2(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_BE_U_4(&ptr->send_accm))); - ND_TCHECK(ptr->recv_accm); - ND_PRINT((ndo, " RECV_ACCM(0x%08x)", EXTRACT_BE_U_4(&ptr->recv_accm))); + ND_TCHECK_2(ptr->reserved1); + PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1); + ND_PRINT(" SEND_ACCM(0x%08x)", GET_BE_U_4(ptr->send_accm)); + ND_PRINT(" RECV_ACCM(0x%08x)", GET_BE_U_4(ptr->recv_accm)); return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); } void @@ -905,46 +916,44 @@ pptp_print(netdissect_options *ndo, uint32_t mc; uint16_t ctrl_msg_type; - ND_PRINT((ndo, ": pptp")); + ndo->ndo_protocol = "pptp"; + ND_PRINT(": pptp"); hdr = (const struct pptp_hdr *)dat; - ND_TCHECK(hdr->length); if (ndo->ndo_vflag) { - ND_PRINT((ndo, " Length=%u", EXTRACT_BE_U_2(&hdr->length))); + ND_PRINT(" Length=%u", GET_BE_U_2(hdr->length)); } - ND_TCHECK(hdr->msg_type); if (ndo->ndo_vflag) { - switch(EXTRACT_BE_U_2(&hdr->msg_type)) { + switch(GET_BE_U_2(hdr->msg_type)) { case PPTP_MSG_TYPE_CTRL: - ND_PRINT((ndo, " CTRL-MSG")); + ND_PRINT(" CTRL-MSG"); break; case PPTP_MSG_TYPE_MGMT: - ND_PRINT((ndo, " MGMT-MSG")); + ND_PRINT(" MGMT-MSG"); break; default: - ND_PRINT((ndo, " UNKNOWN-MSG-TYPE")); + ND_PRINT(" UNKNOWN-MSG-TYPE"); break; } } - ND_TCHECK(hdr->magic_cookie); - mc = EXTRACT_BE_U_4(&hdr->magic_cookie); + mc = GET_BE_U_4(hdr->magic_cookie); if (mc != PPTP_MAGIC_COOKIE) { - ND_PRINT((ndo, " UNEXPECTED Magic-Cookie!!(%08x)", mc)); + ND_PRINT(" UNEXPECTED Magic-Cookie!!(%08x)", mc); } if (ndo->ndo_vflag || mc != PPTP_MAGIC_COOKIE) { - ND_PRINT((ndo, " Magic-Cookie=%08x", mc)); + ND_PRINT(" Magic-Cookie=%08x", mc); } - ND_TCHECK(hdr->ctrl_msg_type); - ctrl_msg_type = EXTRACT_BE_U_2(&hdr->ctrl_msg_type); + ctrl_msg_type = GET_BE_U_2(hdr->ctrl_msg_type); if (ctrl_msg_type < PPTP_MAX_MSGTYPE_INDEX) { - ND_PRINT((ndo, " CTRL_MSGTYPE=%s", - pptp_message_type_string[ctrl_msg_type])); + ND_PRINT(" CTRL_MSGTYPE=%s", + pptp_message_type_string[ctrl_msg_type]); } else { - ND_PRINT((ndo, " UNKNOWN_CTRL_MSGTYPE(%u)", ctrl_msg_type)); + ND_PRINT(" UNKNOWN_CTRL_MSGTYPE(%u)", ctrl_msg_type); } - ND_TCHECK(hdr->reserved0); + ND_TCHECK_2(hdr->reserved0); + PRINT_RESERVED_IF_NOT_ZERO_2(hdr->reserved0); dat += 12; @@ -1002,5 +1011,5 @@ pptp_print(netdissect_options *ndo, return; trunc: - ND_PRINT((ndo, "%s", tstr)); + nd_print_trunc(ndo); }