print-pptp.c revision 98524
198524Sfenner/* 298524Sfenner * Copyright (c) 1991, 1993, 1994, 1995, 1996, 1997 398524Sfenner * The Regents of the University of California. All rights reserved. 498524Sfenner * 598524Sfenner * Redistribution and use in source and binary forms, with or without 698524Sfenner * modification, are permitted provided that: (1) source code distributions 798524Sfenner * retain the above copyright notice and this paragraph in its entirety, (2) 898524Sfenner * distributions including binary code include the above copyright notice and 998524Sfenner * this paragraph in its entirety in the documentation or other materials 1098524Sfenner * provided with the distribution, and (3) all advertising materials mentioning 1198524Sfenner * features or use of this software display the following acknowledgement: 1298524Sfenner * ``This product includes software developed by the University of California, 1398524Sfenner * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of 1498524Sfenner * the University nor the names of its contributors may be used to endorse 1598524Sfenner * or promote products derived from this software without specific prior 1698524Sfenner * written permission. 1798524Sfenner * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 1898524Sfenner * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 1998524Sfenner * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 2098524Sfenner * 2198524Sfenner * PPTP support contributed by Motonori Shindo (mshindo@mshindo.net) 2298524Sfenner */ 2398524Sfenner 2498524Sfenner 2598524Sfenner#ifndef lint 2698524Sfennerstatic const char rcsid[] = 2798524Sfenner "@(#) $Header: /tcpdump/master/tcpdump/print-pptp.c,v 1.3 2001/10/31 08:54:31 guy Exp $"; 2898524Sfenner#endif 2998524Sfenner 3098524Sfenner#ifdef HAVE_CONFIG_H 3198524Sfenner#include "config.h" 3298524Sfenner#endif 3398524Sfenner 3498524Sfenner#include <stdio.h> 3598524Sfenner#include <sys/types.h> 3698524Sfenner#include <sys/param.h> 3798524Sfenner#include <netinet/in.h> 3898524Sfenner#include <arpa/inet.h> 3998524Sfenner 4098524Sfenner#include "interface.h" 4198524Sfenner 4298524Sfennerstatic char tstr[] = " [|pptp]"; 4398524Sfenner 4498524Sfenner#ifndef TRUE 4598524Sfenner#define TRUE 1 4698524Sfenner#endif 4798524Sfenner 4898524Sfenner#ifndef FALSE 4998524Sfenner#define FALSE 0 5098524Sfenner#endif 5198524Sfenner 5298524Sfenner#define PPTP_MSG_TYPE_CTRL 1 /* Control Message */ 5398524Sfenner#define PPTP_MSG_TYPE_MGMT 2 /* Management Message (currently not used */ 5498524Sfenner#define PPTP_MAGIC_COOKIE 0x1a2b3c4d /* for sanity check */ 5598524Sfenner 5698524Sfenner#define PPTP_CTRL_MSG_TYPE_SCCRQ 1 5798524Sfenner#define PPTP_CTRL_MSG_TYPE_SCCRP 2 5898524Sfenner#define PPTP_CTRL_MSG_TYPE_StopCCRQ 3 5998524Sfenner#define PPTP_CTRL_MSG_TYPE_StopCCRP 4 6098524Sfenner#define PPTP_CTRL_MSG_TYPE_ECHORQ 5 6198524Sfenner#define PPTP_CTRL_MSG_TYPE_ECHORP 6 6298524Sfenner#define PPTP_CTRL_MSG_TYPE_OCRQ 7 6398524Sfenner#define PPTP_CTRL_MSG_TYPE_OCRP 8 6498524Sfenner#define PPTP_CTRL_MSG_TYPE_ICRQ 9 6598524Sfenner#define PPTP_CTRL_MSG_TYPE_ICRP 10 6698524Sfenner#define PPTP_CTRL_MSG_TYPE_ICCN 11 6798524Sfenner#define PPTP_CTRL_MSG_TYPE_CCRQ 12 6898524Sfenner#define PPTP_CTRL_MSG_TYPE_CDN 13 6998524Sfenner#define PPTP_CTRL_MSG_TYPE_WEN 14 7098524Sfenner#define PPTP_CTRL_MSG_TYPE_SLI 15 7198524Sfenner 7298524Sfenner#define PPTP_FRAMING_CAP_ASYNC_MASK 0x00000001 /* Aynchronous */ 7398524Sfenner#define PPTP_FRAMING_CAP_SYNC_MASK 0x00000002 /* Synchronous */ 7498524Sfenner 7598524Sfenner#define PPTP_BEARER_CAP_ANALOG_MASK 0x00000001 /* Analog */ 7698524Sfenner#define PPTP_BEARER_CAP_DIGITAL_MASK 0x00000002 /* Digital */ 7798524Sfenner 7898524Sfennerstatic char *pptp_message_type_string[] = { 7998524Sfenner "NOT_DEFINED", /* 0 Not defined in the RFC2637 */ 8098524Sfenner "SCCRQ", /* 1 Start-Control-Connection-Request */ 8198524Sfenner "SCCRP", /* 2 Start-Control-Connection-Reply */ 8298524Sfenner "StopCCRQ", /* 3 Stop-Control-Connection-Request */ 8398524Sfenner "StopCCRP", /* 4 Stop-Control-Connection-Reply */ 8498524Sfenner "ECHORQ", /* 5 Echo Request */ 8598524Sfenner "ECHORP", /* 6 Echo Reply */ 8698524Sfenner 8798524Sfenner "OCRQ", /* 7 Outgoing-Call-Request */ 8898524Sfenner "OCRP", /* 8 Outgoing-Call-Reply */ 8998524Sfenner "ICRQ", /* 9 Incoming-Call-Request */ 9098524Sfenner "ICRP", /* 10 Incoming-Call-Reply */ 9198524Sfenner "ICCN", /* 11 Incoming-Call-Connected */ 9298524Sfenner "CCRQ", /* 12 Call-Clear-Request */ 9398524Sfenner "CDN", /* 13 Call-Disconnect-Notify */ 9498524Sfenner 9598524Sfenner "WEN", /* 14 WAN-Error-Notify */ 9698524Sfenner 9798524Sfenner "SLI" /* 15 Set-Link-Info */ 9898524Sfenner#define PPTP_MAX_MSGTYPE_INDEX 16 9998524Sfenner}; 10098524Sfenner 10198524Sfenner/* common for all PPTP control messages */ 10298524Sfennerstruct pptp_hdr { 10398524Sfenner u_int16_t length; 10498524Sfenner u_int16_t msg_type; 10598524Sfenner u_int32_t magic_cookie; 10698524Sfenner u_int16_t ctrl_msg_type; 10798524Sfenner u_int16_t reserved0; 10898524Sfenner}; 10998524Sfenner 11098524Sfennerstruct pptp_msg_sccrq { 11198524Sfenner u_int16_t proto_ver; 11298524Sfenner u_int16_t reserved1; 11398524Sfenner u_int32_t framing_cap; 11498524Sfenner u_int32_t bearer_cap; 11598524Sfenner u_int16_t max_channel; 11698524Sfenner u_int16_t firm_rev; 11798524Sfenner u_char hostname[64]; 11898524Sfenner u_char vendor[64]; 11998524Sfenner}; 12098524Sfenner 12198524Sfennerstruct pptp_msg_sccrp { 12298524Sfenner u_int16_t proto_ver; 12398524Sfenner u_int8_t result_code; 12498524Sfenner u_int8_t err_code; 12598524Sfenner u_int32_t framing_cap; 12698524Sfenner u_int32_t bearer_cap; 12798524Sfenner u_int16_t max_channel; 12898524Sfenner u_int16_t firm_rev; 12998524Sfenner u_char hostname[64]; 13098524Sfenner u_char vendor[64]; 13198524Sfenner}; 13298524Sfenner 13398524Sfennerstruct pptp_msg_stopccrq { 13498524Sfenner u_int8_t reason; 13598524Sfenner u_int8_t reserved1; 13698524Sfenner u_int16_t reserved2; 13798524Sfenner}; 13898524Sfenner 13998524Sfennerstruct pptp_msg_stopccrp { 14098524Sfenner u_int8_t result_code; 14198524Sfenner u_int8_t err_code; 14298524Sfenner u_int16_t reserved1; 14398524Sfenner}; 14498524Sfenner 14598524Sfennerstruct pptp_msg_echorq { 14698524Sfenner u_int32_t id; 14798524Sfenner}; 14898524Sfenner 14998524Sfennerstruct pptp_msg_echorp { 15098524Sfenner u_int32_t id; 15198524Sfenner u_int8_t result_code; 15298524Sfenner u_int8_t err_code; 15398524Sfenner u_int16_t reserved1; 15498524Sfenner}; 15598524Sfenner 15698524Sfennerstruct pptp_msg_ocrq { 15798524Sfenner u_int16_t call_id; 15898524Sfenner u_int16_t call_ser; 15998524Sfenner u_int32_t min_bps; 16098524Sfenner u_int32_t max_bps; 16198524Sfenner u_int32_t bearer_type; 16298524Sfenner u_int32_t framing_type; 16398524Sfenner u_int16_t recv_winsiz; 16498524Sfenner u_int16_t pkt_proc_delay; 16598524Sfenner u_int16_t phone_no_len; 16698524Sfenner u_int16_t reserved1; 16798524Sfenner u_char phone_no[64]; 16898524Sfenner u_char subaddr[64]; 16998524Sfenner}; 17098524Sfenner 17198524Sfennerstruct pptp_msg_ocrp { 17298524Sfenner u_int16_t call_id; 17398524Sfenner u_int16_t peer_call_id; 17498524Sfenner u_int8_t result_code; 17598524Sfenner u_int8_t err_code; 17698524Sfenner u_int16_t cause_code; 17798524Sfenner u_int32_t conn_speed; 17898524Sfenner u_int16_t recv_winsiz; 17998524Sfenner u_int16_t pkt_proc_delay; 18098524Sfenner u_int32_t phy_chan_id; 18198524Sfenner}; 18298524Sfenner 18398524Sfennerstruct pptp_msg_icrq { 18498524Sfenner u_int16_t call_id; 18598524Sfenner u_int16_t call_ser; 18698524Sfenner u_int32_t bearer_type; 18798524Sfenner u_int32_t phy_chan_id; 18898524Sfenner u_int16_t dialed_no_len; 18998524Sfenner u_int16_t dialing_no_len; 19098524Sfenner u_char dialed_no[64]; /* DNIS */ 19198524Sfenner u_char dialing_no[64]; /* CLID */ 19298524Sfenner u_char subaddr[64]; 19398524Sfenner}; 19498524Sfenner 19598524Sfennerstruct pptp_msg_icrp { 19698524Sfenner u_int16_t call_id; 19798524Sfenner u_int16_t peer_call_id; 19898524Sfenner u_int8_t result_code; 19998524Sfenner u_int8_t err_code; 20098524Sfenner u_int16_t recv_winsiz; 20198524Sfenner u_int16_t pkt_proc_delay; 20298524Sfenner u_int16_t reserved1; 20398524Sfenner}; 20498524Sfenner 20598524Sfennerstruct pptp_msg_iccn { 20698524Sfenner u_int16_t peer_call_id; 20798524Sfenner u_int16_t reserved1; 20898524Sfenner u_int32_t conn_speed; 20998524Sfenner u_int16_t recv_winsiz; 21098524Sfenner u_int16_t pkt_proc_delay; 21198524Sfenner u_int32_t framing_type; 21298524Sfenner}; 21398524Sfenner 21498524Sfennerstruct pptp_msg_ccrq { 21598524Sfenner u_int16_t call_id; 21698524Sfenner u_int16_t reserved1; 21798524Sfenner}; 21898524Sfenner 21998524Sfennerstruct pptp_msg_cdn { 22098524Sfenner u_int16_t call_id; 22198524Sfenner u_int8_t result_code; 22298524Sfenner u_int8_t err_code; 22398524Sfenner u_int16_t cause_code; 22498524Sfenner u_int16_t reserved1; 22598524Sfenner u_char call_stats[128]; 22698524Sfenner}; 22798524Sfenner 22898524Sfennerstruct pptp_msg_wen { 22998524Sfenner u_int16_t peer_call_id; 23098524Sfenner u_int16_t reserved1; 23198524Sfenner u_int32_t crc_err; 23298524Sfenner u_int32_t framing_err; 23398524Sfenner u_int32_t hardware_overrun; 23498524Sfenner u_int32_t buffer_overrun; 23598524Sfenner u_int32_t timeout_err; 23698524Sfenner u_int32_t align_err; 23798524Sfenner}; 23898524Sfenner 23998524Sfennerstruct pptp_msg_sli { 24098524Sfenner u_int16_t peer_call_id; 24198524Sfenner u_int16_t reserved1; 24298524Sfenner u_int32_t send_accm; 24398524Sfenner u_int32_t recv_accm; 24498524Sfenner}; 24598524Sfenner 24698524Sfenner/* attributes that appear more than once in above messages: 24798524Sfenner 24898524Sfenner Number of 24998524Sfenner occurence attributes 25098524Sfenner -------------------------------------- 25198524Sfenner 2 u_int32_t bearer_cap; 25298524Sfenner 2 u_int32_t bearer_type; 25398524Sfenner 6 u_int16_t call_id; 25498524Sfenner 2 u_int16_t call_ser; 25598524Sfenner 2 u_int16_t cause_code; 25698524Sfenner 2 u_int32_t conn_speed; 25798524Sfenner 6 u_int8_t err_code; 25898524Sfenner 2 u_int16_t firm_rev; 25998524Sfenner 2 u_int32_t framing_cap; 26098524Sfenner 2 u_int32_t framing_type; 26198524Sfenner 2 u_char hostname[64]; 26298524Sfenner 2 u_int32_t id; 26398524Sfenner 2 u_int16_t max_channel; 26498524Sfenner 5 u_int16_t peer_call_id; 26598524Sfenner 2 u_int32_t phy_chan_id; 26698524Sfenner 4 u_int16_t pkt_proc_delay; 26798524Sfenner 2 u_int16_t proto_ver; 26898524Sfenner 4 u_int16_t recv_winsiz; 26998524Sfenner 2 u_int8_t reserved1; 27098524Sfenner 9 u_int16_t reserved1; 27198524Sfenner 6 u_int8_t result_code; 27298524Sfenner 2 u_char subaddr[64]; 27398524Sfenner 2 u_char vendor[64]; 27498524Sfenner 27598524Sfenner so I will prepare print out functions for these attributes (except for 27698524Sfenner reserved*). 27798524Sfenner*/ 27898524Sfenner 27998524Sfenner/******************************************/ 28098524Sfenner/* Attribute-specific print out functions */ 28198524Sfenner/******************************************/ 28298524Sfenner 28398524Sfenner/* In these attribute-specific print-out functions, it't not necessary 28498524Sfenner to do TCHECK because they are already checked in the caller of 28598524Sfenner these functions. */ 28698524Sfenner 28798524Sfennerstatic void 28898524Sfennerpptp_bearer_cap_print(const u_int32_t *bearer_cap) 28998524Sfenner{ 29098524Sfenner printf(" BEARER_CAP("); 29198524Sfenner if (ntohl(*bearer_cap) & PPTP_BEARER_CAP_DIGITAL_MASK) { 29298524Sfenner printf("D"); 29398524Sfenner } 29498524Sfenner if (ntohl(*bearer_cap) & PPTP_BEARER_CAP_ANALOG_MASK) { 29598524Sfenner printf("A"); 29698524Sfenner } 29798524Sfenner printf(")"); 29898524Sfenner} 29998524Sfenner 30098524Sfennerstatic void 30198524Sfennerpptp_bearer_type_print(const u_int32_t *bearer_type) 30298524Sfenner{ 30398524Sfenner printf(" BEARER_TYPE("); 30498524Sfenner switch (ntohl(*bearer_type)) { 30598524Sfenner case 1: 30698524Sfenner printf("A"); /* Analog */ 30798524Sfenner break; 30898524Sfenner case 2: 30998524Sfenner printf("D"); /* Digital */ 31098524Sfenner break; 31198524Sfenner case 3: 31298524Sfenner printf("Any"); 31398524Sfenner break; 31498524Sfenner default: 31598524Sfenner printf("?"); 31698524Sfenner break; 31798524Sfenner } 31898524Sfenner printf(")"); 31998524Sfenner} 32098524Sfenner 32198524Sfennerstatic void 32298524Sfennerpptp_call_id_print(const u_int16_t *call_id) 32398524Sfenner{ 32498524Sfenner printf(" CALL_ID(%u)", ntohs(*call_id)); 32598524Sfenner} 32698524Sfenner 32798524Sfennerstatic void 32898524Sfennerpptp_call_ser_print(const u_int16_t *call_ser) 32998524Sfenner{ 33098524Sfenner printf(" CALL_SER_NUM(%u)", ntohs(*call_ser)); 33198524Sfenner} 33298524Sfenner 33398524Sfennerstatic void 33498524Sfennerpptp_cause_code_print(const u_int16_t *cause_code) 33598524Sfenner{ 33698524Sfenner printf(" CAUSE_CODE(%u)", ntohs(*cause_code)); 33798524Sfenner} 33898524Sfenner 33998524Sfennerstatic void 34098524Sfennerpptp_conn_speed_print(const u_int32_t *conn_speed) 34198524Sfenner{ 34298524Sfenner printf(" CONN_SPEED(%lu)", (unsigned long)ntohl(*conn_speed)); 34398524Sfenner} 34498524Sfenner 34598524Sfennerstatic void 34698524Sfennerpptp_err_code_print(const u_int8_t *err_code) 34798524Sfenner{ 34898524Sfenner printf(" ERR_CODE(%u", *err_code); 34998524Sfenner if (vflag) { 35098524Sfenner switch (*err_code) { 35198524Sfenner case 0: 35298524Sfenner printf(":None"); 35398524Sfenner break; 35498524Sfenner case 1: 35598524Sfenner printf(":Not-Connected"); 35698524Sfenner break; 35798524Sfenner case 2: 35898524Sfenner printf(":Bad-Format"); 35998524Sfenner break; 36098524Sfenner case 3: 36198524Sfenner printf(":Bad-Valude"); 36298524Sfenner break; 36398524Sfenner case 4: 36498524Sfenner printf(":No-Resource"); 36598524Sfenner break; 36698524Sfenner case 5: 36798524Sfenner printf(":Bad-Call-ID"); 36898524Sfenner break; 36998524Sfenner case 6: 37098524Sfenner printf(":PAC-Error"); 37198524Sfenner break; 37298524Sfenner default: 37398524Sfenner printf(":?"); 37498524Sfenner break; 37598524Sfenner } 37698524Sfenner } 37798524Sfenner printf(")"); 37898524Sfenner} 37998524Sfenner 38098524Sfennerstatic void 38198524Sfennerpptp_firm_rev_print(const u_int16_t *firm_rev) 38298524Sfenner{ 38398524Sfenner printf(" FIRM_REV(%u)", ntohs(*firm_rev)); 38498524Sfenner} 38598524Sfenner 38698524Sfennerstatic void 38798524Sfennerpptp_framing_cap_print(const u_int32_t *framing_cap) 38898524Sfenner{ 38998524Sfenner printf(" FRAME_CAP("); 39098524Sfenner if (ntohl(*framing_cap) & PPTP_FRAMING_CAP_ASYNC_MASK) { 39198524Sfenner printf("A"); /* Async */ 39298524Sfenner } 39398524Sfenner if (ntohl(*framing_cap) & PPTP_FRAMING_CAP_SYNC_MASK) { 39498524Sfenner printf("S"); /* Sync */ 39598524Sfenner } 39698524Sfenner printf(")"); 39798524Sfenner} 39898524Sfenner 39998524Sfennerstatic void 40098524Sfennerpptp_framing_type_print(const u_int32_t *framing_type) 40198524Sfenner{ 40298524Sfenner printf(" FRAME_TYPE("); 40398524Sfenner switch (ntohl(*framing_type)) { 40498524Sfenner case 1: 40598524Sfenner printf("A"); /* Async */ 40698524Sfenner break; 40798524Sfenner case 2: 40898524Sfenner printf("S"); /* Sync */ 40998524Sfenner break; 41098524Sfenner case 3: 41198524Sfenner printf("E"); /* Either */ 41298524Sfenner break; 41398524Sfenner default: 41498524Sfenner printf("?"); 41598524Sfenner break; 41698524Sfenner } 41798524Sfenner printf(")"); 41898524Sfenner} 41998524Sfenner 42098524Sfennerstatic void 42198524Sfennerpptp_hostname_print(const u_char *hostname) 42298524Sfenner{ 42398524Sfenner printf(" HOSTNAME(%.64s)", hostname); 42498524Sfenner} 42598524Sfenner 42698524Sfennerstatic void 42798524Sfennerpptp_id_print(const u_int32_t *id) 42898524Sfenner{ 42998524Sfenner printf(" ID(%lu)", (unsigned long)ntohl(*id)); 43098524Sfenner} 43198524Sfenner 43298524Sfennerstatic void 43398524Sfennerpptp_max_channel_print(const u_int16_t *max_channel) 43498524Sfenner{ 43598524Sfenner printf(" MAX_CHAN(%u)", ntohs(*max_channel)); 43698524Sfenner} 43798524Sfenner 43898524Sfennerstatic void 43998524Sfennerpptp_peer_call_id_print(const u_int16_t *peer_call_id) 44098524Sfenner{ 44198524Sfenner printf(" PEER_CALL_ID(%u)", ntohs(*peer_call_id)); 44298524Sfenner} 44398524Sfenner 44498524Sfennerstatic void 44598524Sfennerpptp_phy_chan_id_print(const u_int32_t *phy_chan_id) 44698524Sfenner{ 44798524Sfenner printf(" PHY_CHAN_ID(%lu)", (unsigned long)ntohl(*phy_chan_id)); 44898524Sfenner} 44998524Sfenner 45098524Sfennerstatic void 45198524Sfennerpptp_pkt_proc_delay_print(const u_int16_t *pkt_proc_delay) 45298524Sfenner{ 45398524Sfenner printf(" PROC_DELAY(%u)", ntohs(*pkt_proc_delay)); 45498524Sfenner} 45598524Sfenner 45698524Sfennerstatic void 45798524Sfennerpptp_proto_ver_print(const u_int16_t *proto_ver) 45898524Sfenner{ 45998524Sfenner printf(" PROTO_VER(%u.%u)", /* Version.Revision */ 46098524Sfenner ntohs(*proto_ver) >> 8, ntohs(*proto_ver) & 0xff); 46198524Sfenner} 46298524Sfenner 46398524Sfennerstatic void 46498524Sfennerpptp_recv_winsiz_print(const u_int16_t *recv_winsiz) 46598524Sfenner{ 46698524Sfenner printf(" RECV_WIN(%u)", ntohs(*recv_winsiz)); 46798524Sfenner} 46898524Sfenner 46998524Sfennerstatic void 47098524Sfennerpptp_result_code_print(const u_int8_t *result_code, int ctrl_msg_type) 47198524Sfenner{ 47298524Sfenner printf(" RESULT_CODE(%u", *result_code); 47398524Sfenner if (vflag) { 47498524Sfenner switch (ctrl_msg_type) { 47598524Sfenner case PPTP_CTRL_MSG_TYPE_SCCRP: 47698524Sfenner switch (*result_code) { 47798524Sfenner case 1: 47898524Sfenner printf(":Successful channel establishment"); 47998524Sfenner break; 48098524Sfenner case 2: 48198524Sfenner printf(":General error"); 48298524Sfenner break; 48398524Sfenner case 3: 48498524Sfenner printf(":Command channel already exists"); 48598524Sfenner break; 48698524Sfenner case 4: 48798524Sfenner printf(":Requester is not authorized to establish a command channel"); 48898524Sfenner break; 48998524Sfenner case 5: 49098524Sfenner printf(":The protocol version of the requester is not supported"); 49198524Sfenner break; 49298524Sfenner default: 49398524Sfenner printf(":?"); 49498524Sfenner break; 49598524Sfenner } 49698524Sfenner break; 49798524Sfenner case PPTP_CTRL_MSG_TYPE_StopCCRP: 49898524Sfenner case PPTP_CTRL_MSG_TYPE_ECHORP: 49998524Sfenner switch (*result_code) { 50098524Sfenner case 1: 50198524Sfenner printf(":OK"); 50298524Sfenner break; 50398524Sfenner case 2: 50498524Sfenner printf(":General Error"); 50598524Sfenner break; 50698524Sfenner default: 50798524Sfenner printf(":?"); 50898524Sfenner break; 50998524Sfenner } 51098524Sfenner break; 51198524Sfenner case PPTP_CTRL_MSG_TYPE_OCRP: 51298524Sfenner switch (*result_code) { 51398524Sfenner case 1: 51498524Sfenner printf(":Connected"); 51598524Sfenner break; 51698524Sfenner case 2: 51798524Sfenner printf(":General Error"); 51898524Sfenner break; 51998524Sfenner case 3: 52098524Sfenner printf(":No Carrier"); 52198524Sfenner break; 52298524Sfenner case 4: 52398524Sfenner printf(":Busy"); 52498524Sfenner break; 52598524Sfenner case 5: 52698524Sfenner printf(":No Dial Tone"); 52798524Sfenner break; 52898524Sfenner case 6: 52998524Sfenner printf(":Time-out"); 53098524Sfenner break; 53198524Sfenner case 7: 53298524Sfenner printf(":Do Not Accept"); 53398524Sfenner break; 53498524Sfenner default: 53598524Sfenner printf(":?"); 53698524Sfenner break; 53798524Sfenner } 53898524Sfenner break; 53998524Sfenner case PPTP_CTRL_MSG_TYPE_ICRP: 54098524Sfenner switch (*result_code) { 54198524Sfenner case 1: 54298524Sfenner printf(":Connect"); 54398524Sfenner break; 54498524Sfenner case 2: 54598524Sfenner printf(":General Error"); 54698524Sfenner break; 54798524Sfenner case 3: 54898524Sfenner printf(":Do Not Accept"); 54998524Sfenner break; 55098524Sfenner default: 55198524Sfenner printf(":?"); 55298524Sfenner break; 55398524Sfenner } 55498524Sfenner break; 55598524Sfenner case PPTP_CTRL_MSG_TYPE_CDN: 55698524Sfenner switch (*result_code) { 55798524Sfenner case 1: 55898524Sfenner printf(":Lost Carrier"); 55998524Sfenner break; 56098524Sfenner case 2: 56198524Sfenner printf(":General Error"); 56298524Sfenner break; 56398524Sfenner case 3: 56498524Sfenner printf(":Admin Shutdown"); 56598524Sfenner break; 56698524Sfenner case 4: 56798524Sfenner printf(":Request"); 56898524Sfenner default: 56998524Sfenner printf(":?"); 57098524Sfenner break; 57198524Sfenner break; 57298524Sfenner } 57398524Sfenner default: 57498524Sfenner /* assertion error */ 57598524Sfenner break; 57698524Sfenner } 57798524Sfenner } 57898524Sfenner printf(")"); 57998524Sfenner} 58098524Sfenner 58198524Sfennerstatic void 58298524Sfennerpptp_subaddr_print(const u_char *subaddr) 58398524Sfenner{ 58498524Sfenner printf(" SUB_ADDR(%.64s)", subaddr); 58598524Sfenner} 58698524Sfenner 58798524Sfennerstatic void 58898524Sfennerpptp_vendor_print(const u_char *vendor) 58998524Sfenner{ 59098524Sfenner printf(" VENDOR(%.64s)", vendor); 59198524Sfenner} 59298524Sfenner 59398524Sfenner/************************************/ 59498524Sfenner/* PPTP message print out functions */ 59598524Sfenner/************************************/ 59698524Sfennerstatic void 59798524Sfennerpptp_sccrq_print(const u_char *dat) 59898524Sfenner{ 59998524Sfenner struct pptp_msg_sccrq *ptr = (struct pptp_msg_sccrq *)dat; 60098524Sfenner 60198524Sfenner TCHECK(ptr->proto_ver); 60298524Sfenner pptp_proto_ver_print(&ptr->proto_ver); 60398524Sfenner TCHECK(ptr->reserved1); 60498524Sfenner TCHECK(ptr->framing_cap); 60598524Sfenner pptp_framing_cap_print(&ptr->framing_cap); 60698524Sfenner TCHECK(ptr->bearer_cap); 60798524Sfenner pptp_bearer_cap_print(&ptr->bearer_cap); 60898524Sfenner TCHECK(ptr->max_channel); 60998524Sfenner pptp_max_channel_print(&ptr->max_channel); 61098524Sfenner TCHECK(ptr->firm_rev); 61198524Sfenner pptp_firm_rev_print(&ptr->firm_rev); 61298524Sfenner TCHECK(ptr->hostname); 61398524Sfenner pptp_hostname_print(&ptr->hostname[0]); 61498524Sfenner TCHECK(ptr->vendor); 61598524Sfenner pptp_vendor_print(&ptr->vendor[0]); 61698524Sfenner 61798524Sfenner return; 61898524Sfenner 61998524Sfennertrunc: 62098524Sfenner printf("%s", tstr); 62198524Sfenner} 62298524Sfenner 62398524Sfennerstatic void 62498524Sfennerpptp_sccrp_print(const u_char *dat) 62598524Sfenner{ 62698524Sfenner struct pptp_msg_sccrp *ptr = (struct pptp_msg_sccrp *)dat; 62798524Sfenner 62898524Sfenner TCHECK(ptr->proto_ver); 62998524Sfenner pptp_proto_ver_print(&ptr->proto_ver); 63098524Sfenner TCHECK(ptr->result_code); 63198524Sfenner pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_SCCRP); 63298524Sfenner TCHECK(ptr->err_code); 63398524Sfenner pptp_err_code_print(&ptr->err_code); 63498524Sfenner TCHECK(ptr->framing_cap); 63598524Sfenner pptp_framing_cap_print(&ptr->framing_cap); 63698524Sfenner TCHECK(ptr->bearer_cap); 63798524Sfenner pptp_bearer_cap_print(&ptr->bearer_cap); 63898524Sfenner TCHECK(ptr->max_channel); 63998524Sfenner pptp_max_channel_print(&ptr->max_channel); 64098524Sfenner TCHECK(ptr->firm_rev); 64198524Sfenner pptp_firm_rev_print(&ptr->firm_rev); 64298524Sfenner TCHECK(ptr->hostname); 64398524Sfenner pptp_hostname_print(&ptr->hostname[0]); 64498524Sfenner TCHECK(ptr->vendor); 64598524Sfenner pptp_vendor_print(&ptr->vendor[0]); 64698524Sfenner 64798524Sfenner return; 64898524Sfenner 64998524Sfennertrunc: 65098524Sfenner printf("%s", tstr); 65198524Sfenner} 65298524Sfenner 65398524Sfennerstatic void 65498524Sfennerpptp_stopccrq_print(const u_char *dat) 65598524Sfenner{ 65698524Sfenner struct pptp_msg_stopccrq *ptr = (struct pptp_msg_stopccrq *)dat; 65798524Sfenner 65898524Sfenner TCHECK(ptr->reason); 65998524Sfenner printf(" REASON(%u", ptr->reason); 66098524Sfenner if (vflag) { 66198524Sfenner switch (ptr->reason) { 66298524Sfenner case 1: 66398524Sfenner printf(":None"); 66498524Sfenner break; 66598524Sfenner case 2: 66698524Sfenner printf(":Stop-Protocol"); 66798524Sfenner break; 66898524Sfenner case 3: 66998524Sfenner printf(":Stop-Local-Shutdown"); 67098524Sfenner break; 67198524Sfenner default: 67298524Sfenner printf(":?"); 67398524Sfenner break; 67498524Sfenner } 67598524Sfenner } 67698524Sfenner printf(")"); 67798524Sfenner TCHECK(ptr->reserved1); 67898524Sfenner TCHECK(ptr->reserved2); 67998524Sfenner 68098524Sfenner return; 68198524Sfenner 68298524Sfennertrunc: 68398524Sfenner printf("%s", tstr); 68498524Sfenner} 68598524Sfenner 68698524Sfennerstatic void 68798524Sfennerpptp_stopccrp_print(const u_char *dat) 68898524Sfenner{ 68998524Sfenner struct pptp_msg_stopccrp *ptr = (struct pptp_msg_stopccrp *)dat; 69098524Sfenner 69198524Sfenner TCHECK(ptr->result_code); 69298524Sfenner pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_StopCCRP); 69398524Sfenner TCHECK(ptr->err_code); 69498524Sfenner pptp_err_code_print(&ptr->err_code); 69598524Sfenner TCHECK(ptr->reserved1); 69698524Sfenner 69798524Sfenner return; 69898524Sfenner 69998524Sfennertrunc: 70098524Sfenner printf("%s", tstr); 70198524Sfenner} 70298524Sfenner 70398524Sfennerstatic void 70498524Sfennerpptp_echorq_print(const u_char *dat) 70598524Sfenner{ 70698524Sfenner struct pptp_msg_echorq *ptr = (struct pptp_msg_echorq *)dat; 70798524Sfenner 70898524Sfenner TCHECK(ptr->id); 70998524Sfenner pptp_id_print(&ptr->id); 71098524Sfenner 71198524Sfenner return; 71298524Sfenner 71398524Sfennertrunc: 71498524Sfenner printf("%s", tstr); 71598524Sfenner} 71698524Sfenner 71798524Sfennerstatic void 71898524Sfennerpptp_echorp_print(const u_char *dat) 71998524Sfenner{ 72098524Sfenner struct pptp_msg_echorp *ptr = (struct pptp_msg_echorp *)dat; 72198524Sfenner 72298524Sfenner TCHECK(ptr->id); 72398524Sfenner pptp_id_print(&ptr->id); 72498524Sfenner TCHECK(ptr->result_code); 72598524Sfenner pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_ECHORP); 72698524Sfenner TCHECK(ptr->err_code); 72798524Sfenner pptp_err_code_print(&ptr->err_code); 72898524Sfenner TCHECK(ptr->reserved1); 72998524Sfenner 73098524Sfenner return; 73198524Sfenner 73298524Sfennertrunc: 73398524Sfenner printf("%s", tstr); 73498524Sfenner} 73598524Sfenner 73698524Sfennerstatic void 73798524Sfennerpptp_ocrq_print(const u_char *dat) 73898524Sfenner{ 73998524Sfenner struct pptp_msg_ocrq *ptr = (struct pptp_msg_ocrq *)dat; 74098524Sfenner 74198524Sfenner TCHECK(ptr->call_id); 74298524Sfenner pptp_call_id_print(&ptr->call_id); 74398524Sfenner TCHECK(ptr->call_ser); 74498524Sfenner pptp_call_ser_print(&ptr->call_ser); 74598524Sfenner TCHECK(ptr->min_bps); 74698524Sfenner printf(" MIN_BPS(%lu)", (unsigned long)ntohl(ptr->min_bps)); 74798524Sfenner TCHECK(ptr->max_bps); 74898524Sfenner printf(" MAX_BPS(%lu)", (unsigned long)ntohl(ptr->max_bps)); 74998524Sfenner TCHECK(ptr->bearer_type); 75098524Sfenner pptp_bearer_type_print(&ptr->bearer_type); 75198524Sfenner TCHECK(ptr->framing_type); 75298524Sfenner pptp_framing_type_print(&ptr->framing_type); 75398524Sfenner TCHECK(ptr->recv_winsiz); 75498524Sfenner pptp_recv_winsiz_print(&ptr->recv_winsiz); 75598524Sfenner TCHECK(ptr->pkt_proc_delay); 75698524Sfenner pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay); 75798524Sfenner TCHECK(ptr->phone_no_len); 75898524Sfenner printf(" PHONE_NO_LEN(%u)", ntohs(ptr->phone_no_len)); 75998524Sfenner TCHECK(ptr->reserved1); 76098524Sfenner TCHECK(ptr->phone_no); 76198524Sfenner printf(" PHONE_NO(%.64s)", ptr->phone_no); 76298524Sfenner TCHECK(ptr->subaddr); 76398524Sfenner pptp_subaddr_print(&ptr->subaddr[0]); 76498524Sfenner 76598524Sfenner return; 76698524Sfenner 76798524Sfennertrunc: 76898524Sfenner printf("%s", tstr); 76998524Sfenner} 77098524Sfenner 77198524Sfennerstatic void 77298524Sfennerpptp_ocrp_print(const u_char *dat) 77398524Sfenner{ 77498524Sfenner struct pptp_msg_ocrp *ptr = (struct pptp_msg_ocrp *)dat; 77598524Sfenner 77698524Sfenner TCHECK(ptr->call_id); 77798524Sfenner pptp_call_id_print(&ptr->call_id); 77898524Sfenner TCHECK(ptr->peer_call_id); 77998524Sfenner pptp_peer_call_id_print(&ptr->peer_call_id); 78098524Sfenner TCHECK(ptr->result_code); 78198524Sfenner pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_OCRP); 78298524Sfenner TCHECK(ptr->err_code); 78398524Sfenner pptp_err_code_print(&ptr->err_code); 78498524Sfenner TCHECK(ptr->cause_code); 78598524Sfenner pptp_cause_code_print(&ptr->cause_code); 78698524Sfenner TCHECK(ptr->conn_speed); 78798524Sfenner pptp_conn_speed_print(&ptr->conn_speed); 78898524Sfenner TCHECK(ptr->recv_winsiz); 78998524Sfenner pptp_recv_winsiz_print(&ptr->recv_winsiz); 79098524Sfenner TCHECK(ptr->pkt_proc_delay); 79198524Sfenner pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay); 79298524Sfenner TCHECK(ptr->phy_chan_id); 79398524Sfenner pptp_phy_chan_id_print(&ptr->phy_chan_id); 79498524Sfenner 79598524Sfenner return; 79698524Sfenner 79798524Sfennertrunc: 79898524Sfenner printf("%s", tstr); 79998524Sfenner} 80098524Sfenner 80198524Sfennerstatic void 80298524Sfennerpptp_icrq_print(const u_char *dat) 80398524Sfenner{ 80498524Sfenner struct pptp_msg_icrq *ptr = (struct pptp_msg_icrq *)dat; 80598524Sfenner 80698524Sfenner TCHECK(ptr->call_id); 80798524Sfenner pptp_call_id_print(&ptr->call_id); 80898524Sfenner TCHECK(ptr->call_ser); 80998524Sfenner pptp_call_ser_print(&ptr->call_ser); 81098524Sfenner TCHECK(ptr->bearer_type); 81198524Sfenner pptp_bearer_type_print(&ptr->bearer_type); 81298524Sfenner TCHECK(ptr->phy_chan_id); 81398524Sfenner pptp_phy_chan_id_print(&ptr->phy_chan_id); 81498524Sfenner TCHECK(ptr->dialed_no_len); 81598524Sfenner printf(" DIALED_NO_LEN(%u)", ntohs(ptr->dialed_no_len)); 81698524Sfenner TCHECK(ptr->dialing_no_len); 81798524Sfenner printf(" DIALING_NO_LEN(%u)", ntohs(ptr->dialing_no_len)); 81898524Sfenner TCHECK(ptr->dialed_no); 81998524Sfenner printf(" DIALED_NO(%.64s)", ptr->dialed_no); 82098524Sfenner TCHECK(ptr->dialing_no); 82198524Sfenner printf(" DIALING_NO(%.64s)", ptr->dialing_no); 82298524Sfenner TCHECK(ptr->subaddr); 82398524Sfenner pptp_subaddr_print(&ptr->subaddr[0]); 82498524Sfenner 82598524Sfenner return; 82698524Sfenner 82798524Sfennertrunc: 82898524Sfenner printf("%s", tstr); 82998524Sfenner} 83098524Sfenner 83198524Sfennerstatic void 83298524Sfennerpptp_icrp_print(const u_char *dat) 83398524Sfenner{ 83498524Sfenner struct pptp_msg_icrp *ptr = (struct pptp_msg_icrp *)dat; 83598524Sfenner 83698524Sfenner TCHECK(ptr->call_id); 83798524Sfenner pptp_call_id_print(&ptr->call_id); 83898524Sfenner TCHECK(ptr->peer_call_id); 83998524Sfenner pptp_peer_call_id_print(&ptr->peer_call_id); 84098524Sfenner TCHECK(ptr->result_code); 84198524Sfenner pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_ICRP); 84298524Sfenner TCHECK(ptr->err_code); 84398524Sfenner pptp_err_code_print(&ptr->err_code); 84498524Sfenner TCHECK(ptr->recv_winsiz); 84598524Sfenner pptp_recv_winsiz_print(&ptr->recv_winsiz); 84698524Sfenner TCHECK(ptr->pkt_proc_delay); 84798524Sfenner pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay); 84898524Sfenner TCHECK(ptr->reserved1); 84998524Sfenner 85098524Sfenner return; 85198524Sfenner 85298524Sfennertrunc: 85398524Sfenner printf("%s", tstr); 85498524Sfenner} 85598524Sfenner 85698524Sfennerstatic void 85798524Sfennerpptp_iccn_print(const u_char *dat) 85898524Sfenner{ 85998524Sfenner struct pptp_msg_iccn *ptr = (struct pptp_msg_iccn *)dat; 86098524Sfenner 86198524Sfenner TCHECK(ptr->peer_call_id); 86298524Sfenner pptp_peer_call_id_print(&ptr->peer_call_id); 86398524Sfenner TCHECK(ptr->reserved1); 86498524Sfenner TCHECK(ptr->conn_speed); 86598524Sfenner pptp_conn_speed_print(&ptr->conn_speed); 86698524Sfenner TCHECK(ptr->recv_winsiz); 86798524Sfenner pptp_recv_winsiz_print(&ptr->recv_winsiz); 86898524Sfenner TCHECK(ptr->pkt_proc_delay); 86998524Sfenner pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay); 87098524Sfenner TCHECK(ptr->framing_type); 87198524Sfenner pptp_framing_type_print(&ptr->framing_type); 87298524Sfenner 87398524Sfenner return; 87498524Sfenner 87598524Sfennertrunc: 87698524Sfenner printf("%s", tstr); 87798524Sfenner} 87898524Sfenner 87998524Sfennerstatic void 88098524Sfennerpptp_ccrq_print(const u_char *dat) 88198524Sfenner{ 88298524Sfenner struct pptp_msg_ccrq *ptr = (struct pptp_msg_ccrq *)dat; 88398524Sfenner 88498524Sfenner TCHECK(ptr->call_id); 88598524Sfenner pptp_call_id_print(&ptr->call_id); 88698524Sfenner TCHECK(ptr->reserved1); 88798524Sfenner 88898524Sfenner return; 88998524Sfenner 89098524Sfennertrunc: 89198524Sfenner printf("%s", tstr); 89298524Sfenner} 89398524Sfenner 89498524Sfennerstatic void 89598524Sfennerpptp_cdn_print(const u_char *dat) 89698524Sfenner{ 89798524Sfenner struct pptp_msg_cdn *ptr = (struct pptp_msg_cdn *)dat; 89898524Sfenner 89998524Sfenner TCHECK(ptr->call_id); 90098524Sfenner pptp_call_id_print(&ptr->call_id); 90198524Sfenner TCHECK(ptr->result_code); 90298524Sfenner pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_CDN); 90398524Sfenner TCHECK(ptr->err_code); 90498524Sfenner pptp_err_code_print(&ptr->err_code); 90598524Sfenner TCHECK(ptr->cause_code); 90698524Sfenner pptp_cause_code_print(&ptr->cause_code); 90798524Sfenner TCHECK(ptr->reserved1); 90898524Sfenner TCHECK(ptr->call_stats); 90998524Sfenner printf(" CALL_STATS(%.128s)", ptr->call_stats); 91098524Sfenner 91198524Sfenner return; 91298524Sfenner 91398524Sfennertrunc: 91498524Sfenner printf("%s", tstr); 91598524Sfenner} 91698524Sfenner 91798524Sfennerstatic void 91898524Sfennerpptp_wen_print(const u_char *dat) 91998524Sfenner{ 92098524Sfenner struct pptp_msg_wen *ptr = (struct pptp_msg_wen *)dat; 92198524Sfenner 92298524Sfenner TCHECK(ptr->peer_call_id); 92398524Sfenner pptp_peer_call_id_print(&ptr->peer_call_id); 92498524Sfenner TCHECK(ptr->reserved1); 92598524Sfenner TCHECK(ptr->crc_err); 92698524Sfenner printf(" CRC_ERR(%lu)", (unsigned long)ntohl(ptr->crc_err)); 92798524Sfenner TCHECK(ptr->framing_err); 92898524Sfenner printf(" FRAMING_ERR(%lu)", (unsigned long)ntohl(ptr->framing_err)); 92998524Sfenner TCHECK(ptr->hardware_overrun); 93098524Sfenner printf(" HARDWARE_OVERRUN(%lu)", 93198524Sfenner (unsigned long)ntohl(ptr->hardware_overrun)); 93298524Sfenner TCHECK(ptr->buffer_overrun); 93398524Sfenner printf(" BUFFER_OVERRUN(%lu)", 93498524Sfenner (unsigned long)ntohl(ptr->buffer_overrun)); 93598524Sfenner TCHECK(ptr->timeout_err); 93698524Sfenner printf(" TIMEOUT_ERR(%lu)", (unsigned long)ntohl(ptr->timeout_err)); 93798524Sfenner TCHECK(ptr->align_err); 93898524Sfenner printf(" ALIGN_ERR(%lu)", (unsigned long)ntohl(ptr->align_err)); 93998524Sfenner 94098524Sfenner return; 94198524Sfenner 94298524Sfennertrunc: 94398524Sfenner printf("%s", tstr); 94498524Sfenner} 94598524Sfenner 94698524Sfennerstatic void 94798524Sfennerpptp_sli_print(const u_char *dat) 94898524Sfenner{ 94998524Sfenner struct pptp_msg_sli *ptr = (struct pptp_msg_sli *)dat; 95098524Sfenner 95198524Sfenner TCHECK(ptr->peer_call_id); 95298524Sfenner pptp_peer_call_id_print(&ptr->peer_call_id); 95398524Sfenner TCHECK(ptr->reserved1); 95498524Sfenner TCHECK(ptr->send_accm); 95598524Sfenner printf(" SEND_ACCM(0x%08lx)", (unsigned long)ntohl(ptr->send_accm)); 95698524Sfenner TCHECK(ptr->recv_accm); 95798524Sfenner printf(" RECV_ACCM(0x%08lx)", (unsigned long)ntohl(ptr->recv_accm)); 95898524Sfenner 95998524Sfenner return; 96098524Sfenner 96198524Sfennertrunc: 96298524Sfenner printf("%s", tstr); 96398524Sfenner} 96498524Sfenner 96598524Sfennervoid 96698524Sfennerpptp_print(const u_char *dat, u_int length) 96798524Sfenner{ 96898524Sfenner const struct pptp_hdr *hdr; 96998524Sfenner u_int32_t mc; 97098524Sfenner u_int16_t ctrl_msg_type; 97198524Sfenner 97298524Sfenner printf(": pptp"); 97398524Sfenner 97498524Sfenner hdr = (struct pptp_hdr *)dat; 97598524Sfenner 97698524Sfenner TCHECK(hdr->length); 97798524Sfenner if (vflag) { 97898524Sfenner printf(" Length=%u", ntohs(hdr->length)); 97998524Sfenner } 98098524Sfenner TCHECK(hdr->msg_type); 98198524Sfenner if (vflag) { 98298524Sfenner switch(ntohs(hdr->msg_type)) { 98398524Sfenner case PPTP_MSG_TYPE_CTRL: 98498524Sfenner printf(" CTRL-MSG"); 98598524Sfenner break; 98698524Sfenner case PPTP_MSG_TYPE_MGMT: 98798524Sfenner printf(" MGMT-MSG"); 98898524Sfenner break; 98998524Sfenner default: 99098524Sfenner printf(" UNKNOWN-MSG-TYPE"); 99198524Sfenner break; 99298524Sfenner } 99398524Sfenner } 99498524Sfenner 99598524Sfenner TCHECK(hdr->magic_cookie); 99698524Sfenner mc = ntohl(hdr->magic_cookie); 99798524Sfenner if (mc != PPTP_MAGIC_COOKIE) { 99898524Sfenner printf(" UNEXPECTED Magic-Cookie!!(%08x)", mc); 99998524Sfenner } 100098524Sfenner if (vflag || mc != PPTP_MAGIC_COOKIE) { 100198524Sfenner printf(" Magic-Cookie=%08x", mc); 100298524Sfenner } 100398524Sfenner TCHECK(hdr->ctrl_msg_type); 100498524Sfenner ctrl_msg_type = ntohs(hdr->ctrl_msg_type); 100598524Sfenner if (ctrl_msg_type < PPTP_MAX_MSGTYPE_INDEX) { 100698524Sfenner printf(" CTRL_MSGTYPE=%s", 100798524Sfenner pptp_message_type_string[ctrl_msg_type]); 100898524Sfenner } else { 100998524Sfenner printf(" UNKNOWN_CTRL_MSGTYPE(%u)", ctrl_msg_type); 101098524Sfenner } 101198524Sfenner TCHECK(hdr->reserved0); 101298524Sfenner 101398524Sfenner dat += 12; 101498524Sfenner 101598524Sfenner switch(ctrl_msg_type) { 101698524Sfenner case PPTP_CTRL_MSG_TYPE_SCCRQ: 101798524Sfenner pptp_sccrq_print(dat); 101898524Sfenner break; 101998524Sfenner case PPTP_CTRL_MSG_TYPE_SCCRP: 102098524Sfenner pptp_sccrp_print(dat); 102198524Sfenner break; 102298524Sfenner case PPTP_CTRL_MSG_TYPE_StopCCRQ: 102398524Sfenner pptp_stopccrq_print(dat); 102498524Sfenner break; 102598524Sfenner case PPTP_CTRL_MSG_TYPE_StopCCRP: 102698524Sfenner pptp_stopccrp_print(dat); 102798524Sfenner break; 102898524Sfenner case PPTP_CTRL_MSG_TYPE_ECHORQ: 102998524Sfenner pptp_echorq_print(dat); 103098524Sfenner break; 103198524Sfenner case PPTP_CTRL_MSG_TYPE_ECHORP: 103298524Sfenner pptp_echorp_print(dat); 103398524Sfenner break; 103498524Sfenner case PPTP_CTRL_MSG_TYPE_OCRQ: 103598524Sfenner pptp_ocrq_print(dat); 103698524Sfenner break; 103798524Sfenner case PPTP_CTRL_MSG_TYPE_OCRP: 103898524Sfenner pptp_ocrp_print(dat); 103998524Sfenner break; 104098524Sfenner case PPTP_CTRL_MSG_TYPE_ICRQ: 104198524Sfenner pptp_icrq_print(dat); 104298524Sfenner break; 104398524Sfenner case PPTP_CTRL_MSG_TYPE_ICRP: 104498524Sfenner pptp_icrp_print(dat); 104598524Sfenner break; 104698524Sfenner case PPTP_CTRL_MSG_TYPE_ICCN: 104798524Sfenner pptp_iccn_print(dat); 104898524Sfenner break; 104998524Sfenner case PPTP_CTRL_MSG_TYPE_CCRQ: 105098524Sfenner pptp_ccrq_print(dat); 105198524Sfenner break; 105298524Sfenner case PPTP_CTRL_MSG_TYPE_CDN: 105398524Sfenner pptp_cdn_print(dat); 105498524Sfenner break; 105598524Sfenner case PPTP_CTRL_MSG_TYPE_WEN: 105698524Sfenner pptp_wen_print(dat); 105798524Sfenner break; 105898524Sfenner case PPTP_CTRL_MSG_TYPE_SLI: 105998524Sfenner pptp_sli_print(dat); 106098524Sfenner break; 106198524Sfenner default: 106298524Sfenner /* do nothing */ 106398524Sfenner break; 106498524Sfenner } 106598524Sfenner 106698524Sfenner return; 106798524Sfenner 106898524Sfennertrunc: 106998524Sfenner printf("%s", tstr); 107098524Sfenner} 1071