From 4cc4315793630e5ddb42892012c130ed52e8f2c2 Mon Sep 17 00:00:00 2001 From: Sven Eckelmann Date: Wed, 1 Oct 2014 18:26:12 +0200 Subject: batadv: Add dissector support for batadv v15 The packet format for batman-adv v15 supports: * Complete reordered packet type ids * reordered flags * type-version-length-value data containers * new types for coding packets and unicast transfer of TVLVs * dropped packet types for vis, translation table query and roaming * reordered packet formats * transparent fragmentation of batadv packets Change-Id: I9e6733f9dd6b54eeecda19cf570599161d28b46e Signed-off-by: Sven Eckelmann Signed-off-by: Simon Wunderlich Reviewed-on: https://code.wireshark.org/review/5175 Petri-Dish: Michael Mann Tested-by: Petri Dish Buildbot Reviewed-by: Michael Mann --- epan/dissectors/packet-batadv.c | 1635 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 1622 insertions(+), 13 deletions(-) (limited to 'epan/dissectors/packet-batadv.c') diff --git a/epan/dissectors/packet-batadv.c b/epan/dissectors/packet-batadv.c index 43515e0707..dff0747858 100644 --- a/epan/dissectors/packet-batadv.c +++ b/epan/dissectors/packet-batadv.c @@ -29,6 +29,7 @@ #include #include #include +#include /* Start content from packet-batadv.h */ #define ETH_P_BATMAN 0x4305 @@ -44,6 +45,22 @@ #define BATADV_ROAM_ADV_V14 0x08 #define BATADV_UNICAST_4ADDR_V14 0x09 +#define BATADV_IV_OGM_V15 0x00 +#define BATADV_BCAST_V15 0x01 +#define BATADV_CODED_V15 0x02 +#define BATADV_UNICAST_V15 0x40 +#define BATADV_UNICAST_FRAG_V15 0x41 +#define BATADV_UNICAST_4ADDR_V15 0x42 +#define BATADV_ICMP_V15 0x43 +#define BATADV_UNICAST_TVLV_V15 0x44 + +#define BATADV_TVLV_V15_GW 0x01 +#define BATADV_TVLV_V15_DAT 0x02 +#define BATADV_TVLV_V15_NC 0x03 +#define BATADV_TVLV_V15_TT 0x04 +#define BATADV_TVLV_V15_ROAM 0x05 +#define BATADV_TVLV_V15_MCAST 0x06 + #define ECHO_REPLY 0 #define DESTINATION_UNREACHABLE 3 #define ECHO_REQUEST 8 @@ -65,6 +82,17 @@ #define UNICAST_4ADDR_DAT_DHT_PUT 0x03 #define UNICAST_4ADDR_DAT_CACHE_REPLY 0x04 +#define BATADV_TVLVL_TT_TYPE_MASK 0x0F +#define BATADV_TVLVL_TT_OGM_DIFF 0x01 +#define BATADV_TVLVL_TT_REQUEST 0x02 +#define BATADV_TVLVL_TT_RESPONSE 0x04 +#define BATADV_TVLVL_TT_FULL_TABLE 0x10 + +#define BATADV_TVLVL_TT_CHANGE_DEL 0x01 +#define BATADV_TVLVL_TT_CHANGE_ROAM 0x02 +#define BATADV_TVLVL_TT_CHANGE_WIFI 0x10 +#define BATADV_TVLVL_TT_CHANGE_ISOLATE 0x20 + struct batman_packet_v5 { guint8 packet_type; guint8 version; /* batman version field */ @@ -152,6 +180,20 @@ struct batman_packet_v14 { }; #define BATMAN_PACKET_V14_SIZE 26 +struct iv_ogm_packet_v15 { + guint8 packet_type; + guint8 version; /* batman version field */ + guint8 ttl; + guint8 flags; + guint32 seqno; + address orig; + address prev_sender; + guint8 reserved; + guint8 tq; + guint16 tvlv_len; +}; +#define IV_OGM_PACKET_V15_SIZE 24 + struct icmp_packet_v6 { guint8 packet_type; guint8 version; /* batman version field */ @@ -189,6 +231,19 @@ struct icmp_packet_v14 { }; #define ICMP_PACKET_V14_SIZE 20 +struct icmp_packet_v15 { + guint8 packet_type; + guint8 version; /* batman version field */ + guint8 ttl; + guint8 msg_type; /* see ICMP message types above */ + address dst; + address orig; + guint8 uid; + guint8 rr_ptr; + guint16 seqno; +}; +#define ICMP_PACKET_V15_SIZE 20 + struct unicast_packet_v6 { guint8 packet_type; guint8 version; @@ -242,6 +297,18 @@ struct unicast_frag_packet_v14 { }; #define UNICAST_FRAG_PACKET_V14_SIZE 20 +struct unicast_frag_packet_v15 { + guint8 packet_type; + guint8 version; /* batman version field */ + guint8 ttl; + guint8 no; /* only upper 4 bit are used */ + address dest; + address orig; + guint16 seqno; + guint16 total_size; +}; +#define UNICAST_FRAG_PACKET_V15_SIZE 20 + struct bcast_packet_v6 { guint8 packet_type; guint8 version; /* batman version field */ @@ -339,6 +406,36 @@ struct roam_adv_packet_v14 { address client; }; #define ROAM_ADV_PACKET_V14_SIZE 22 + +struct coded_packet_v15 { + guint8 packet_type; + guint8 version; /* batman version field */ + guint8 ttl; + guint8 first_ttvn; + address first_source; + address first_orig_dest; + guint32 first_crc; + guint8 second_ttl; + guint8 second_ttvn; + address second_dest; + address second_source; + address second_orig_dest; + guint32 second_crc; + guint16 coded_len; +}; +#define CODED_PACKET_V15_SIZE 46 + +struct unicast_tvlv_packet_v15 { + guint8 packet_type; + guint8 version; /* batman version field */ + guint8 ttl; + guint8 reserved; + address dest; + address src; + guint16 tvlv_len; + guint16 align; +}; +#define UNICAST_TVLV_PACKET_V15_SIZE 20 /* End content from packet-batadv.h */ /* trees */ @@ -346,12 +443,15 @@ static gint ett_batadv_batman = -1; static gint ett_batadv_batman_flags = -1; static gint ett_batadv_batman_gwflags = -1; static gint ett_batadv_batman_tt = -1; +static gint ett_batadv_iv_ogm = -1; +static gint ett_batadv_iv_ogm_flags = -1; static gint ett_batadv_bcast = -1; static gint ett_batadv_icmp = -1; static gint ett_batadv_icmp_rr = -1; static gint ett_batadv_unicast = -1; static gint ett_batadv_unicast_4addr = -1; static gint ett_batadv_unicast_frag = -1; +static gint ett_batadv_unicast_tvlv = -1; static gint ett_batadv_vis = -1; static gint ett_batadv_vis_entry = -1; static gint ett_batadv_tt_query = -1; @@ -359,9 +459,18 @@ static gint ett_batadv_tt_query_flags = -1; static gint ett_batadv_tt_entry = -1; static gint ett_batadv_tt_entry_flags = -1; static gint ett_batadv_roam_adv = -1; +static gint ett_batadv_coded = -1; +static gint ett_batadv_tvlv = -1; +static gint ett_batadv_tvlv_mcast_flags = -1; +static gint ett_batadv_tvlv_vid = -1; +static gint ett_batadv_tvlv_tt_flags = -1; +static gint ett_batadv_tvlv_tt_vlan = -1; +static gint ett_batadv_tvlv_tt_change = -1; static gint ett_msg_fragment = -1; static gint ett_msg_fragments = -1; +static expert_field ei_batadv_tvlv_unknown_version = EI_INIT; + /* hfs */ static int hf_batadv_packet_type = -1; @@ -382,6 +491,15 @@ static int hf_batadv_batman_ttvn = -1; static int hf_batadv_batman_tt_crc = -1; static int hf_batadv_batman_tt = -1; +static int hf_batadv_iv_ogm_version = -1; +static int hf_batadv_iv_ogm_ttl = -1; +static int hf_batadv_iv_ogm_flags = -1; +static int hf_batadv_iv_ogm_seqno = -1; +static int hf_batadv_iv_ogm_orig = -1; +static int hf_batadv_iv_ogm_prev_sender = -1; +static int hf_batadv_iv_ogm_tq = -1; +static int hf_batadv_iv_ogm_tvlv_len = -1; + static int hf_batadv_bcast_version = -1; static int hf_batadv_bcast_orig = -1; static int hf_batadv_bcast_seqno = -1; @@ -418,6 +536,14 @@ static int hf_batadv_unicast_frag_ttvn = -1; static int hf_batadv_unicast_frag_flags = -1; static int hf_batadv_unicast_frag_orig = -1; static int hf_batadv_unicast_frag_seqno = -1; +static int hf_batadv_unicast_frag_no = -1; +static int hf_batadv_unicast_frag_total_size = -1; + +static int hf_batadv_unicast_tvlv_version = -1; +static int hf_batadv_unicast_tvlv_ttl = -1; +static int hf_batadv_unicast_tvlv_dst = -1; +static int hf_batadv_unicast_tvlv_src = -1; +static int hf_batadv_unicast_tvlv_len = -1; static int hf_batadv_vis_version = -1; static int hf_batadv_vis_type = -1; @@ -453,6 +579,20 @@ static int hf_batadv_roam_adv_dst = -1; static int hf_batadv_roam_adv_src = -1; static int hf_batadv_roam_adv_client = -1; +static int hf_batadv_coded_version = -1; +static int hf_batadv_coded_ttl = -1; +static int hf_batadv_coded_first_ttvn = -1; +static int hf_batadv_coded_first_source = -1; +static int hf_batadv_coded_first_orig_dest = -1; +static int hf_batadv_coded_first_crc = -1; +static int hf_batadv_coded_second_ttl = -1; +static int hf_batadv_coded_second_ttvn = -1; +static int hf_batadv_coded_second_dest = -1; +static int hf_batadv_coded_second_source = -1; +static int hf_batadv_coded_second_orig_dest = -1; +static int hf_batadv_coded_second_crc = -1; +static int hf_batadv_coded_coded_len = -1; + static int hf_msg_fragments = -1; static int hf_msg_fragment = -1; static int hf_msg_fragment_overlap = -1; @@ -464,6 +604,29 @@ static int hf_msg_fragment_count = -1; static int hf_msg_reassembled_in = -1; static int hf_msg_reassembled_length = -1; +static int hf_batadv_tvlv_type = -1; +static int hf_batadv_tvlv_version = -1; +static int hf_batadv_tvlv_len = -1; + +static int hf_batadv_tvlv_gw_download = -1; +static int hf_batadv_tvlv_gw_upload = -1; + +static int hf_batadv_tvlv_roam_addr = -1; +static int hf_batadv_tvlv_roam_vid = -1; +static int hf_batadv_tvlv_vid_vlan = -1; +static int hf_batadv_tvlv_vid_tagged = -1; + +static int hf_batadv_tvlv_tt_flags = -1; +static int hf_batadv_tvlv_tt_flags_type = -1; +static int hf_batadv_tvlv_tt_flags_full_table = -1; +static int hf_batadv_tvlv_tt_ttvn = -1; +static int hf_batadv_tvlv_tt_num_vlan = -1; +static int hf_batadv_tvlv_tt_vlan_crc = -1; +static int hf_batadv_tvlv_tt_vlan_vid = -1; +static int hf_batadv_tvlv_tt_change_flags = -1; +static int hf_batadv_tvlv_tt_change_vid = -1; +static int hf_batadv_tvlv_tt_change_addr = -1; + /* flags */ static int hf_batadv_batman_flags_directlink = -1; static int hf_batadv_batman_flags_vis_server = -1; @@ -471,6 +634,16 @@ static int hf_batadv_batman_flags_not_best_next_hop = -1; static int hf_batadv_batman_flags_primaries_first_hop = -1; static int hf_batadv_unicast_frag_flags_head = -1; static int hf_batadv_unicast_frag_flags_largetail = -1; +static int hf_batadv_iv_ogm_flags_not_best_next_hop = -1; +static int hf_batadv_iv_ogm_flags_primaries_first_hop = -1; +static int hf_batadv_iv_ogm_flags_directlink = -1; +static int hf_batadv_tvlv_mcast_flags_unsnoopables = -1; +static int hf_batadv_tvlv_mcast_flags_ipv4 = -1; +static int hf_batadv_tvlv_mcast_flags_ipv6 = -1; +static int hf_batadv_tvlv_tt_change_flags_del = -1; +static int hf_batadv_tvlv_tt_change_flags_roam = -1; +static int hf_batadv_tvlv_tt_change_flags_wifi = -1; +static int hf_batadv_tvlv_tt_change_flags_isolate = -1; static const value_string unicast_4addr_typenames[] = { { UNICAST_4ADDR_DATA, "Data" }, @@ -480,6 +653,16 @@ static const value_string unicast_4addr_typenames[] = { { 0, NULL } }; +static const value_string tvlv_v15_typenames[] = { + { BATADV_TVLV_V15_GW, "Gateway information" }, + { BATADV_TVLV_V15_DAT, "Distributed ARP Table" }, + { BATADV_TVLV_V15_NC, "Network Coding" }, + { BATADV_TVLV_V15_TT, "Translation Table" }, + { BATADV_TVLV_V15_ROAM, "Roaming" }, + { BATADV_TVLV_V15_MCAST, "Multicast" }, + { 0, NULL } +}; + static const value_string icmp_packettypenames[] = { { ECHO_REPLY, "ECHO_REPLY" }, { DESTINATION_UNREACHABLE, "DESTINATION UNREACHABLE" }, @@ -500,6 +683,13 @@ static const value_string tt_query_type_v14[] = { {0, NULL} }; +static const value_string tvlv_tt_typenames[] = { + {BATADV_TVLVL_TT_OGM_DIFF, "OGM Diff"}, + {BATADV_TVLVL_TT_REQUEST, "Request"}, + {BATADV_TVLVL_TT_RESPONSE, "Response"}, + {0, NULL} +}; + static const fragment_items msg_frag_items = { /* Fragment subtrees */ &ett_msg_fragment, @@ -530,6 +720,8 @@ void proto_reg_handoff_batadv(void); static dissector_handle_t batman_handle; /* supported packet dissectors */ +static void dissect_batadv_v5(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static void dissect_batadv_v15(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_batman(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static int dissect_batadv_batman_v5(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree); static int dissect_batadv_batman_v7(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree); @@ -538,6 +730,9 @@ static int dissect_batadv_batman_v10(tvbuff_t *tvb, int offset, packet_info *pin static int dissect_batadv_batman_v11(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree); static int dissect_batadv_batman_v14(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree); +static void dissect_batadv_iv_ogm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static int dissect_batadv_iv_ogm_v15(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree); + static void dissect_batadv_bcast(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_bcast_v6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_bcast_v10(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); @@ -547,6 +742,7 @@ static void dissect_batadv_icmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t static void dissect_batadv_icmp_v6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_icmp_v7(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_icmp_v14(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static void dissect_batadv_icmp_v15(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_unicast(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_unicast_v6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); @@ -558,6 +754,7 @@ static void dissect_batadv_unicast_4addr_v14(tvbuff_t *tvb, packet_info *pinfo, static void dissect_batadv_unicast_frag(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_unicast_frag_v12(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_unicast_frag_v14(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static void dissect_batadv_unicast_frag_v15(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_vis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_vis_v6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); @@ -575,6 +772,24 @@ static void dissect_tt_entry_v14(tvbuff_t *tvb, packet_info *pinfo, proto_tree * static void dissect_batadv_roam_adv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); static void dissect_batadv_roam_adv_v14(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static void dissect_batadv_coded(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static void dissect_batadv_coded_v15(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); + +static void dissect_batadv_unicast_tvlv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static void dissect_batadv_unicast_tvlv_v15(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); + +static void dissect_batadv_tvlv_v15(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree); +static void dissect_batadv_tvlv_v15_header(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint8 type); +static void dissect_batadv_tvlv_v15_dat(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, guint8 version); +static void dissect_batadv_tvlv_v15_nc(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, guint8 version); +static void dissect_batadv_tvlv_v15_mcast(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, guint8 version); +static void dissect_batadv_tvlv_v15_gw(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, guint8 version); +static void dissect_batadv_tvlv_v15_roam(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, guint8 version); +static void dissect_batadv_tvlv_v15_tt(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, guint8 version); +static int dissect_batadv_tvlv_v15_tt_vlan(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset); +static int dissect_batadv_tvlv_v15_tt_change(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset); + + /* other dissectors */ static dissector_handle_t data_handle; static dissector_handle_t eth_handle; @@ -590,12 +805,23 @@ static reassembly_table msg_reassembly_table; static unsigned int batadv_ethertype = ETH_P_BATMAN; -static void dissect_batman_plugin(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +static void dissect_batadv_plugin(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { - guint8 type; + guint8 version; col_clear(pinfo->cinfo, COL_INFO); + version = tvb_get_guint8(tvb, 1); + if (version < 15) + dissect_batadv_v5(tvb, pinfo, tree); + else + dissect_batadv_v15(tvb, pinfo, tree); +} + +static void dissect_batadv_v5(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + guint8 type; + type = tvb_get_guint8(tvb, 0); switch (type) { @@ -644,6 +870,56 @@ static void dissect_batman_plugin(tvbuff_t *tvb, packet_info *pinfo, proto_tree } } +static void dissect_batadv_v15(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree) +{ + guint8 type; + + type = tvb_get_guint8(tvb, 0); + + switch (type) { + case BATADV_IV_OGM_V15: + dissect_batadv_iv_ogm(tvb, pinfo, tree); + break; + case BATADV_BCAST_V15: + dissect_batadv_bcast(tvb, pinfo, tree); + break; + case BATADV_CODED_V15: + dissect_batadv_coded(tvb, pinfo, tree); + break; + case BATADV_UNICAST_V15: + dissect_batadv_unicast(tvb, pinfo, tree); + break; + case BATADV_UNICAST_FRAG_V15: + dissect_batadv_unicast_frag(tvb, pinfo, tree); + break; + case BATADV_UNICAST_4ADDR_V15: + dissect_batadv_unicast_4addr(tvb, pinfo, tree); + break; + case BATADV_ICMP_V15: + dissect_batadv_icmp(tvb, pinfo, tree); + break; + case BATADV_UNICAST_TVLV_V15: + dissect_batadv_unicast_tvlv(tvb, pinfo, tree); + break; + default: + /* dunno */ + { + tvbuff_t *next_tvb; + gint length_remaining; + + col_set_str(pinfo->cinfo, COL_PROTOCOL, "BATADV_???"); + + length_remaining = tvb_captured_length_remaining(tvb, 0); + if (length_remaining > 0) { + next_tvb = tvb_new_subset_remaining(tvb, 0); + call_dissector(data_handle, next_tvb, pinfo, tree); + } + break; + } + } +} + static void dissect_batadv_batman(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { guint8 version; @@ -1372,6 +1648,147 @@ static int dissect_batadv_batman_v14(tvbuff_t *tvb, int offset, packet_info *pin return offset; } +static void dissect_batadv_iv_ogm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + guint8 version; + int offset = 0; + + /* set protocol name */ + col_set_str(pinfo->cinfo, COL_PROTOCOL, "BATADV_IV_OGM"); + + version = tvb_get_guint8(tvb, 1); + switch (version) { + case 15: + while (offset != -1 && + tvb_captured_length_remaining(tvb, offset) >= IV_OGM_PACKET_V15_SIZE) { + offset = dissect_batadv_iv_ogm_v15(tvb, offset, pinfo, tree); + } + break; + default: + col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version); + call_dissector(data_handle, tvb, pinfo, tree); + break; + } +} + +static int dissect_batadv_iv_ogm_v15(tvbuff_t *tvb, int offset, + packet_info *pinfo, proto_tree *tree) +{ + proto_tree *batadv_iv_ogm_tree = NULL; + guint8 type, version; + struct iv_ogm_packet_v15 *iv_ogm_packeth; + const guint8 *prev_sender_addr, *orig_addr; + tvbuff_t *next_tvb; + static const int * flags[] = { + &hf_batadv_iv_ogm_flags_directlink, + &hf_batadv_iv_ogm_flags_primaries_first_hop, + &hf_batadv_iv_ogm_flags_not_best_next_hop, + NULL + }; + + type = tvb_get_guint8(tvb, offset+0); + version = tvb_get_guint8(tvb, offset+1); + + /* don't interpret padding as B.A.T.M.A.N. advanced packet */ + if (version == 0 || type != BATADV_IV_OGM_V15) + return -1; + + iv_ogm_packeth = (struct iv_ogm_packet_v15 *)wmem_alloc(wmem_packet_scope(), + sizeof(struct iv_ogm_packet_v15)); + + /* Set info column */ + col_add_fstr(pinfo->cinfo, COL_INFO, "Seq=%u", iv_ogm_packeth->seqno); + + /* Set tree info */ + if (tree) { + proto_item *ti; + + orig_addr = tvb_get_ptr(tvb, offset + 8, 6); + ti = proto_tree_add_protocol_format(tree, proto_batadv_plugin, + tvb, offset, + IV_OGM_PACKET_V15_SIZE + iv_ogm_packeth->tvlv_len, + "B.A.T.M.A.N. IV OGM, Orig: %s (%s)", + get_ether_name(orig_addr), + ether_to_str(orig_addr)); + batadv_iv_ogm_tree = proto_item_add_subtree(ti, ett_batadv_iv_ogm); + } + + /* items */ + iv_ogm_packeth->packet_type = tvb_get_guint8(tvb, offset); + proto_tree_add_uint_format_value(batadv_iv_ogm_tree, + hf_batadv_packet_type, + tvb, offset, 1, BATADV_IV_OGM_V15, + "%s (%u)", "BATADV_IV_OGM", + BATADV_IV_OGM_V15); + offset += 1; + + iv_ogm_packeth->version = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_iv_ogm_tree, hf_batadv_iv_ogm_version, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + iv_ogm_packeth->ttl = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_iv_ogm_tree, hf_batadv_iv_ogm_ttl, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + iv_ogm_packeth->flags = tvb_get_guint8(tvb, offset); + proto_tree_add_bitmask(batadv_iv_ogm_tree, tvb, offset, + hf_batadv_iv_ogm_flags, ett_batadv_iv_ogm_flags, + flags, ENC_NA); + offset += 1; + + iv_ogm_packeth->seqno = tvb_get_ntohl(tvb, offset); + proto_tree_add_item(batadv_iv_ogm_tree, hf_batadv_iv_ogm_seqno, tvb, + offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + orig_addr = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&iv_ogm_packeth->orig, AT_ETHER, 6, orig_addr); + proto_tree_add_item(batadv_iv_ogm_tree, hf_batadv_iv_ogm_orig, tvb, + offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + prev_sender_addr = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&iv_ogm_packeth->prev_sender, AT_ETHER, 6, prev_sender_addr); + proto_tree_add_item(batadv_iv_ogm_tree, hf_batadv_iv_ogm_prev_sender, tvb, + offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + /* Skip 1 byte of padding. */ + iv_ogm_packeth->reserved = tvb_get_guint8(tvb, offset); + offset += 1; + + iv_ogm_packeth->tq = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_iv_ogm_tree, hf_batadv_iv_ogm_tq, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + iv_ogm_packeth->tvlv_len = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(batadv_iv_ogm_tree, hf_batadv_iv_ogm_tvlv_len, tvb, + offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + SET_ADDRESS(&pinfo->dl_src, AT_ETHER, 6, orig_addr); + SET_ADDRESS(&pinfo->src, AT_ETHER, 6, orig_addr); + + tap_queue_packet(batadv_tap, pinfo, iv_ogm_packeth); + + if (iv_ogm_packeth->tvlv_len > 0) { + next_tvb = tvb_new_subset_length(tvb, offset, + iv_ogm_packeth->tvlv_len); + + if (have_tap_listener(batadv_follow_tap)) { + tap_queue_packet(batadv_follow_tap, pinfo, next_tvb); + } + + dissect_batadv_tvlv_v15(next_tvb, pinfo, batadv_iv_ogm_tree); + offset += iv_ogm_packeth->tvlv_len; + } + + return offset; +} + static void dissect_batadv_tt(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree) { const guint8 *tt; @@ -1418,6 +1835,7 @@ static void dissect_batadv_bcast(tvbuff_t *tvb, packet_info *pinfo, proto_tree * dissect_batadv_bcast_v10(tvb, pinfo, tree); break; case 14: + case 15: dissect_batadv_bcast_v14(tvb, pinfo, tree); break; default: @@ -1572,6 +1990,7 @@ static void dissect_batadv_bcast_v14(tvbuff_t *tvb, packet_info *pinfo, proto_tr bcast_packeth = (struct bcast_packet_v14 *)wmem_alloc(wmem_packet_scope(), sizeof(struct bcast_packet_v14)); + bcast_packeth->packet_type = tvb_get_guint8(tvb, 0); bcast_packeth->version = tvb_get_guint8(tvb, 1); bcast_packeth->ttl = tvb_get_guint8(tvb, 2); bcast_packeth->reserved = tvb_get_guint8(tvb, 3); @@ -1597,8 +2016,11 @@ static void dissect_batadv_bcast_v14(tvbuff_t *tvb, packet_info *pinfo, proto_tr } /* items */ - proto_tree_add_uint_format(batadv_bcast_tree, hf_batadv_packet_type, tvb, offset, 1, BATADV_BCAST_V5, - "Packet Type: %s (%u)", "BATADV_BCAST", BATADV_BCAST_V5); + proto_tree_add_uint_format_value(batadv_bcast_tree, + hf_batadv_packet_type, tvb, offset, 1, + bcast_packeth->packet_type, + "%s (%u)", "BATADV_BCAST", + bcast_packeth->packet_type); offset += 1; proto_tree_add_item(batadv_bcast_tree, hf_batadv_bcast_version, tvb, offset, 1, ENC_BIG_ENDIAN); @@ -1657,6 +2079,9 @@ static void dissect_batadv_icmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t case 14: dissect_batadv_icmp_v14(tvb, pinfo, tree); break; + case 15: + dissect_batadv_icmp_v15(tvb, pinfo, tree); + break; default: col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version); call_dissector(data_handle, tvb, pinfo, tree); @@ -1771,6 +2196,31 @@ dissect_batadv_icmp_rr(proto_tree *batadv_icmp_tree, tvbuff_t *tvb, int offset) } } +static void +dissect_batadv_icmp_rr_v15(proto_tree *batadv_icmp_tree, tvbuff_t *tvb, + int offset, int ptr) +{ + proto_tree *field_tree; + int i; + + field_tree = proto_tree_add_subtree(batadv_icmp_tree, tvb, offset, + 6 * BAT_RR_LEN, + ett_batadv_icmp_rr, NULL, + "ICMP RR"); + ptr--; + + for (i = 0; i < BAT_RR_LEN; i++) { + proto_tree_add_ether_format(field_tree, hf_batadv_icmp_rr_ether, + tvb, offset, 6, + tvb_get_ptr(tvb, offset, 6), + "%s%s", + (i > ptr) ? "-" : tvb_ether_to_str(tvb, offset), + (i == ptr) ? " <- (current)" : ""); + + offset += 6; + } +} + static void dissect_batadv_icmp_v7(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { struct icmp_packet_v7 *icmp_packeth; @@ -1951,6 +2401,117 @@ static void dissect_batadv_icmp_v14(tvbuff_t *tvb, packet_info *pinfo, proto_tre } } +static void dissect_batadv_icmp_v15(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree) +{ + struct icmp_packet_v15 *icmp_packeth; + const guint8 *dst_addr, *orig_addr; + proto_item *ti; + proto_tree *batadv_icmp_tree = NULL; + + tvbuff_t *next_tvb; + gint length_remaining; + int offset = 0; + + icmp_packeth = (struct icmp_packet_v15 *)wmem_alloc(wmem_packet_scope(), + sizeof(struct icmp_packet_v15)); + + icmp_packeth->msg_type = tvb_get_guint8(tvb, offset + 4); + + /* Set info column */ + col_add_fstr(pinfo->cinfo, COL_INFO, "[%s] Seq=%u", + val_to_str(icmp_packeth->msg_type, icmp_packettypenames, + "Unknown (0x%02x)"), + icmp_packeth->seqno); + + /* Set tree info */ + if (tree) { + dst_addr = tvb_get_ptr(tvb, 4, 6); + orig_addr = tvb_get_ptr(tvb, 10, 6); + ti = proto_tree_add_protocol_format(tree, proto_batadv_plugin, + tvb, 0, ICMP_PACKET_V14_SIZE, + "B.A.T.M.A.N. ICMP, Orig: %s (%s), Dst: %s (%s)", + get_ether_name(orig_addr), + ether_to_str(orig_addr), + get_ether_name(dst_addr), + ether_to_str(dst_addr)); + batadv_icmp_tree = proto_item_add_subtree(ti, ett_batadv_icmp); + } + + /* items */ + icmp_packeth->packet_type = tvb_get_guint8(tvb, offset); + proto_tree_add_uint_format_value(batadv_icmp_tree, + hf_batadv_packet_type, tvb, + offset, 1, icmp_packeth->packet_type, + "%s (%u)", "BATADV_ICMP", + icmp_packeth->packet_type); + offset += 1; + + icmp_packeth->version = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_icmp_tree, hf_batadv_icmp_version, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + icmp_packeth->ttl = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_icmp_tree, hf_batadv_icmp_ttl, tvb, offset, + 1, ENC_BIG_ENDIAN); + offset += 1; + + icmp_packeth->msg_type = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_icmp_tree, hf_batadv_icmp_msg_type, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + dst_addr = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&icmp_packeth->dst, AT_ETHER, 6, dst_addr); + proto_tree_add_item(batadv_icmp_tree, hf_batadv_icmp_dst, tvb, offset, + 6, ENC_BIG_ENDIAN); + offset += 6; + + orig_addr = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&icmp_packeth->orig, AT_ETHER, 6, orig_addr); + proto_tree_add_item(batadv_icmp_tree, hf_batadv_icmp_orig, tvb, offset, + 6, ENC_BIG_ENDIAN); + offset += 6; + + icmp_packeth->uid = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_icmp_tree, hf_batadv_icmp_uid, tvb, offset, + 1, ENC_BIG_ENDIAN); + offset += 1; + + icmp_packeth->rr_ptr = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_icmp_tree, hf_batadv_icmp_rr_pointer, tvb, + offset, 1, ENC_NA); + offset += 1; + + icmp_packeth->seqno = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(batadv_icmp_tree, hf_batadv_icmp_seqno, tvb, offset, + 2, ENC_BIG_ENDIAN); + offset += 2; + + /* rr data available? */ + length_remaining = tvb_captured_length_remaining(tvb, offset); + if (length_remaining >= BAT_RR_LEN * 6) { + dissect_batadv_icmp_rr_v15(batadv_icmp_tree, tvb, offset, + icmp_packeth->rr_ptr); + offset += BAT_RR_LEN * 6; + } + + SET_ADDRESS(&pinfo->dl_src, AT_ETHER, 6, orig_addr); + SET_ADDRESS(&pinfo->src, AT_ETHER, 6, orig_addr); + + SET_ADDRESS(&pinfo->dl_dst, AT_ETHER, 6, dst_addr); + SET_ADDRESS(&pinfo->dst, AT_ETHER, 6, dst_addr); + + tap_queue_packet(batadv_tap, pinfo, icmp_packeth); + + length_remaining = tvb_captured_length_remaining(tvb, offset); + if (length_remaining > 0) { + next_tvb = tvb_new_subset(tvb, offset, length_remaining, -1); + call_dissector(data_handle, next_tvb, pinfo, tree); + } +} + static void dissect_batadv_unicast(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { guint8 version; @@ -1971,6 +2532,7 @@ static void dissect_batadv_unicast(tvbuff_t *tvb, packet_info *pinfo, proto_tree dissect_batadv_unicast_v6(tvb, pinfo, tree); break; case 14: + case 15: dissect_batadv_unicast_v14(tvb, pinfo, tree); break; default: @@ -2057,6 +2619,7 @@ static void dissect_batadv_unicast_v14(tvbuff_t *tvb, packet_info *pinfo, proto_ unicast_packeth = (struct unicast_packet_v14 *)wmem_alloc(wmem_packet_scope(), sizeof(struct unicast_packet_v14)); + unicast_packeth->packet_type = tvb_get_guint8(tvb, 0); unicast_packeth->version = tvb_get_guint8(tvb, 1); unicast_packeth->ttl = tvb_get_guint8(tvb, 2); unicast_packeth->ttvn = tvb_get_guint8(tvb, 3); @@ -2081,8 +2644,12 @@ static void dissect_batadv_unicast_v14(tvbuff_t *tvb, packet_info *pinfo, proto_ } /* items */ - proto_tree_add_uint_format(batadv_unicast_tree, hf_batadv_packet_type, tvb, offset, 1, BATADV_UNICAST_V5, - "Packet Type: %s (%u)", "BATADV_UNICAST", BATADV_UNICAST_V5); + proto_tree_add_uint_format_value(batadv_unicast_tree, + hf_batadv_packet_type, tvb, offset, 1, + unicast_packeth->packet_type, + "%s (%u)", + "BATADV_UNICAST", + unicast_packeth->packet_type); offset += 1; proto_tree_add_item(batadv_unicast_tree, hf_batadv_unicast_version, tvb, offset, 1, ENC_BIG_ENDIAN); @@ -2124,6 +2691,7 @@ static void dissect_batadv_unicast_4addr(tvbuff_t *tvb, packet_info *pinfo, prot version = tvb_get_guint8(tvb, 1); switch (version) { case 14: + case 15: dissect_batadv_unicast_4addr_v14(tvb, pinfo, tree); break; default: @@ -2145,6 +2713,7 @@ static void dissect_batadv_unicast_4addr_v14(tvbuff_t *tvb, packet_info *pinfo, unicast_4addr_packeth = (struct unicast_4addr_packet_v14 *)wmem_alloc(wmem_packet_scope(), sizeof(struct unicast_4addr_packet_v14)); + unicast_4addr_packeth->packet_type = tvb_get_guint8(tvb, 0); unicast_4addr_packeth->version = tvb_get_guint8(tvb, 1); unicast_4addr_packeth->ttl = tvb_get_guint8(tvb, 2); unicast_4addr_packeth->ttvn = tvb_get_guint8(tvb, 3); @@ -2174,8 +2743,11 @@ static void dissect_batadv_unicast_4addr_v14(tvbuff_t *tvb, packet_info *pinfo, } /* items */ - proto_tree_add_uint_format(batadv_unicast_4addr_tree, hf_batadv_packet_type, tvb, offset, 1, BATADV_UNICAST_4ADDR_V14, - "Packet Type: %s (%u)", "BATADV_UNICAST_4ADDR", BATADV_UNICAST_4ADDR_V14); + proto_tree_add_uint_format_value(batadv_unicast_4addr_tree, + hf_batadv_packet_type, tvb, offset, 1, + unicast_4addr_packeth->packet_type, + "%s (%u)", "BATADV_UNICAST_4ADDR", + unicast_4addr_packeth->packet_type); offset += 1; proto_tree_add_item(batadv_unicast_4addr_tree, hf_batadv_unicast_4addr_version, tvb, offset, 1, ENC_BIG_ENDIAN); @@ -2234,6 +2806,9 @@ static void dissect_batadv_unicast_frag(tvbuff_t *tvb, packet_info *pinfo, proto case 14: dissect_batadv_unicast_frag_v14(tvb, pinfo, tree); break; + case 15: + dissect_batadv_unicast_frag_v15(tvb, pinfo, tree); + break; default: col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version); call_dissector(data_handle, tvb, pinfo, tree); @@ -2461,10 +3036,137 @@ static void dissect_batadv_unicast_frag_v14(tvbuff_t *tvb, packet_info *pinfo, p pinfo->fragmented = save_fragmented; } -static void dissect_batadv_vis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +static void dissect_batadv_unicast_frag_v15(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree) { - guint8 version; - + struct unicast_frag_packet_v15 *unicast_frag_packeth; + const guint8 *dest_addr, *orig_addr; + gboolean save_fragmented; + fragment_head *frag_msg = NULL; + proto_tree *batadv_unicast_frag_tree = NULL; + + tvbuff_t *new_tvb; + int offset = 0; + int frag_no = 0; + gint length_remaining; + + unicast_frag_packeth = (struct unicast_frag_packet_v15 *)wmem_alloc(wmem_packet_scope(), + sizeof(struct unicast_frag_packet_v15)); + + save_fragmented = pinfo->fragmented; + pinfo->fragmented = TRUE; + + /* Set info column */ + col_clear(pinfo->cinfo, COL_INFO); + + /* Set tree info */ + if (tree) { + proto_item *ti; + + dest_addr = tvb_get_ptr(tvb, 4, 6); + ti = proto_tree_add_protocol_format(tree, proto_batadv_plugin, + tvb, 0, + UNICAST_FRAG_PACKET_V15_SIZE, + "B.A.T.M.A.N. Unicast Fragment, Dst: %s (%s)", + get_ether_name(dest_addr), + ether_to_str(dest_addr)); + batadv_unicast_frag_tree = proto_item_add_subtree(ti, + ett_batadv_unicast_frag); + } + + /* items */ + unicast_frag_packeth->packet_type = tvb_get_guint8(tvb, offset); + proto_tree_add_uint_format_value(batadv_unicast_frag_tree, + hf_batadv_packet_type, tvb, offset, 1, + unicast_frag_packeth->packet_type, + "%s (%u)", "BATADV_UNICAST", + unicast_frag_packeth->packet_type); + offset += 1; + + unicast_frag_packeth->version = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_unicast_frag_tree, + hf_batadv_unicast_frag_version, tvb, offset, 1, + ENC_BIG_ENDIAN); + offset += 1; + + unicast_frag_packeth->ttl = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_unicast_frag_tree, + hf_batadv_unicast_frag_ttl, tvb, offset, 1, + ENC_BIG_ENDIAN); + offset += 1; + + unicast_frag_packeth->no = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_unicast_frag_tree, hf_batadv_unicast_frag_no, + tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + dest_addr = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&unicast_frag_packeth->dest, AT_ETHER, 6, dest_addr); + proto_tree_add_item(batadv_unicast_frag_tree, hf_batadv_unicast_frag_dst, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + orig_addr = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&unicast_frag_packeth->orig, AT_ETHER, 6, orig_addr); + proto_tree_add_item(batadv_unicast_frag_tree, hf_batadv_unicast_frag_orig, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + unicast_frag_packeth->seqno = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(batadv_unicast_frag_tree, + hf_batadv_unicast_frag_seqno, tvb, offset, 2, + ENC_BIG_ENDIAN); + offset += 2; + + unicast_frag_packeth->total_size = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(batadv_unicast_frag_tree, + hf_batadv_unicast_frag_total_size, tvb, offset, 2, + ENC_BIG_ENDIAN); + offset += 2; + + SET_ADDRESS(&pinfo->dl_src, AT_ETHER, 6, orig_addr); + SET_ADDRESS(&pinfo->src, AT_ETHER, 6, orig_addr); + + SET_ADDRESS(&pinfo->dl_dst, AT_ETHER, 6, dest_addr); + SET_ADDRESS(&pinfo->dst, AT_ETHER, 6, dest_addr); + + tap_queue_packet(batadv_tap, pinfo, unicast_frag_packeth); + + frag_no = unicast_frag_packeth->no >> 4; + /* only support 2 fragments */ + if (frag_no > 1) + return; + + length_remaining = tvb_captured_length_remaining(tvb, offset); + if (length_remaining < 0) + length_remaining = 0; + frag_msg = fragment_add_seq_check(&msg_reassembly_table, + tvb, offset, pinfo, + unicast_frag_packeth->seqno, NULL, + 1 - frag_no, length_remaining, TRUE); + + /* Assemble 2 fragments */ + fragment_set_tot_len(&msg_reassembly_table, pinfo, + unicast_frag_packeth->seqno, NULL, 1); + + new_tvb = process_reassembled_data(tvb, offset, pinfo, + "Reassembled Message", frag_msg, &msg_frag_items, + NULL, batadv_unicast_frag_tree); + if (new_tvb) { + if (have_tap_listener(batadv_follow_tap)) { + tap_queue_packet(batadv_follow_tap, pinfo, new_tvb); + } + + call_dissector(batman_handle, new_tvb, pinfo, tree); + } + + pinfo->fragmented = save_fragmented; +} + +static void dissect_batadv_vis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + guint8 version; + /* set protocol name */ col_set_str(pinfo->cinfo, COL_PROTOCOL, "BATADV_VIS"); @@ -3161,6 +3863,604 @@ static void dissect_batadv_roam_adv_v14(tvbuff_t *tvb, packet_info *pinfo, proto } } +static void dissect_batadv_coded(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + guint8 version; + + /* set protocol name */ + col_set_str(pinfo->cinfo, COL_PROTOCOL, "BATADV_CODED"); + + version = tvb_get_guint8(tvb, 1); + switch (version) { + case 15: + dissect_batadv_coded_v15(tvb, pinfo, tree); + break; + default: + col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version); + call_dissector(data_handle, tvb, pinfo, tree); + break; + } +} + +static void dissect_batadv_coded_v15(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree) +{ + struct coded_packet_v15 *coded_packeth; + const guint8 *first_source, *first_orig_dest; + const guint8 *second_dest, *second_source, *second_orig_dest; + proto_tree *batadv_coded_tree = NULL; + + tvbuff_t *next_tvb; + gint length_remaining; + int offset = 0; + + coded_packeth = (struct coded_packet_v15 *)wmem_alloc(wmem_packet_scope(), + sizeof(struct coded_packet_v15)); + + /* Set tree info */ + if (tree) { + proto_item *ti; + + ti = proto_tree_add_protocol_format(tree, proto_batadv_plugin, + tvb, 0, + CODED_PACKET_V15_SIZE, + "B.A.T.M.A.N. Coded"); + batadv_coded_tree = proto_item_add_subtree(ti, ett_batadv_coded); + } + + /* items */ + coded_packeth->packet_type = tvb_get_guint8(tvb, offset); + proto_tree_add_uint_format_value(batadv_coded_tree, + hf_batadv_packet_type, + tvb, offset, 1, + coded_packeth->packet_type, + "%s (%u)", "BATADV_CODED", + coded_packeth->packet_type); + offset += 1; + + coded_packeth->version = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_version, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + coded_packeth->ttl = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_ttl, tvb, offset, + 1, ENC_BIG_ENDIAN); + offset += 1; + + coded_packeth->first_ttvn = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_first_ttvn, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + first_source = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&coded_packeth->first_source, AT_ETHER, 6, first_source); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_first_source, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + first_orig_dest = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&coded_packeth->first_orig_dest, AT_ETHER, 6, + first_orig_dest); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_first_orig_dest, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + coded_packeth->first_crc = tvb_get_ntohl(tvb, offset); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_first_crc, tvb, + offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + coded_packeth->second_ttl = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_second_ttl, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + coded_packeth->second_ttvn = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_second_ttvn, tvb, + offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + second_dest = tvb_get_ptr(tvb, 4, offset); + SET_ADDRESS(&coded_packeth->second_dest, AT_ETHER, 6, second_dest); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_second_dest, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + second_source = tvb_get_ptr(tvb, 4, offset); + SET_ADDRESS(&coded_packeth->second_source, AT_ETHER, 6, second_source); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_second_source, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + second_orig_dest = tvb_get_ptr(tvb, 4, offset); + SET_ADDRESS(&coded_packeth->second_orig_dest, AT_ETHER, 6, + second_orig_dest); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_second_orig_dest, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + coded_packeth->second_crc = tvb_get_ntohl(tvb, offset); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_second_crc, tvb, + offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + coded_packeth->coded_len = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(batadv_coded_tree, hf_batadv_coded_coded_len, tvb, + offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + SET_ADDRESS(&pinfo->dl_src, AT_ETHER, 6, first_source); + SET_ADDRESS(&pinfo->src, AT_ETHER, 6, first_source); + + SET_ADDRESS(&pinfo->dl_dst, AT_ETHER, 6, first_orig_dest); + SET_ADDRESS(&pinfo->dst, AT_ETHER, 6, first_orig_dest); + + tap_queue_packet(batadv_tap, pinfo, coded_packeth); + + length_remaining = tvb_captured_length_remaining(tvb, offset); + if (length_remaining > 0) { + next_tvb = tvb_new_subset_remaining(tvb, offset); + + if (have_tap_listener(batadv_follow_tap)) { + tap_queue_packet(batadv_follow_tap, pinfo, next_tvb); + } + + call_dissector(data_handle, next_tvb, pinfo, tree); + } +} + +static void dissect_batadv_unicast_tvlv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + guint8 version; + + /* set protocol name */ + col_set_str(pinfo->cinfo, COL_PROTOCOL, "BATADV_UNICAST_TVLV"); + + version = tvb_get_guint8(tvb, 1); + switch (version) { + case 15: + dissect_batadv_unicast_tvlv_v15(tvb, pinfo, tree); + break; + default: + col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", + version); + call_dissector(data_handle, tvb, pinfo, tree); + break; + } +} + +static void dissect_batadv_unicast_tvlv_v15(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree) +{ + struct unicast_tvlv_packet_v15 *unicast_tvlv_packeth; + const guint8 *dest_addr; + const guint8 *src_addr; + + tvbuff_t *next_tvb; + int offset = 0; + proto_tree *batadv_unicast_tvlv_tree = NULL; + + unicast_tvlv_packeth = (struct unicast_tvlv_packet_v15 *)wmem_alloc(wmem_packet_scope(), + sizeof(struct unicast_tvlv_packet_v15)); + + /* Set info column */ + col_clear(pinfo->cinfo, COL_INFO); + + /* Set tree info */ + if (tree) { + proto_item *ti; + + dest_addr = tvb_get_ptr(tvb, 4, 6); + src_addr = tvb_get_ptr(tvb, 10, 6); + unicast_tvlv_packeth->tvlv_len = tvb_get_ntohs(tvb, 16); + ti = proto_tree_add_protocol_format(tree, proto_batadv_plugin, + tvb, 0, + UNICAST_TVLV_PACKET_V15_SIZE + unicast_tvlv_packeth->tvlv_len, + "B.A.T.M.A.N. Unicast TVLV, Src: %s (%s) Dst: %s (%s)", + get_ether_name(src_addr), + ether_to_str(src_addr), + get_ether_name(dest_addr), + ether_to_str(dest_addr)); + batadv_unicast_tvlv_tree = proto_item_add_subtree(ti, ett_batadv_unicast_tvlv); + } + + /* items */ + unicast_tvlv_packeth->packet_type = tvb_get_guint8(tvb, offset); + proto_tree_add_uint_format_value(batadv_unicast_tvlv_tree, + hf_batadv_packet_type, tvb, offset, 1, + unicast_tvlv_packeth->packet_type, + "%s (%u)", "BATADV_UNICAST_TVLV", + unicast_tvlv_packeth->packet_type); + offset += 1; + + unicast_tvlv_packeth->version = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_unicast_tvlv_tree, + hf_batadv_unicast_tvlv_version, tvb, offset, 1, + ENC_BIG_ENDIAN); + offset += 1; + + unicast_tvlv_packeth->ttl = tvb_get_guint8(tvb, offset); + proto_tree_add_item(batadv_unicast_tvlv_tree, + hf_batadv_unicast_tvlv_ttl, tvb, offset, 1, + ENC_BIG_ENDIAN); + offset += 1; + + /* Skip 1 byte of padding. */ + offset += 1; + + dest_addr = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&unicast_tvlv_packeth->dest, AT_ETHER, 6, dest_addr); + proto_tree_add_item(batadv_unicast_tvlv_tree, hf_batadv_unicast_tvlv_dst, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + src_addr = tvb_get_ptr(tvb, offset, 6); + SET_ADDRESS(&unicast_tvlv_packeth->src, AT_ETHER, offset, src_addr); + proto_tree_add_item(batadv_unicast_tvlv_tree, hf_batadv_unicast_tvlv_src, + tvb, offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + unicast_tvlv_packeth->tvlv_len = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(batadv_unicast_tvlv_tree, + hf_batadv_unicast_tvlv_len, tvb, offset, 2, + ENC_BIG_ENDIAN); + offset += 2; + + /* Skip 2 byte of padding. */ + offset += 2; + + SET_ADDRESS(&pinfo->dl_dst, AT_ETHER, 6, dest_addr); + SET_ADDRESS(&pinfo->dst, AT_ETHER, 6, dest_addr); + + SET_ADDRESS(&pinfo->dl_src, AT_ETHER, 6, src_addr); + SET_ADDRESS(&pinfo->src, AT_ETHER, 6, src_addr); + + tap_queue_packet(batadv_tap, pinfo, unicast_tvlv_packeth); + + if (unicast_tvlv_packeth->tvlv_len > 0) { + next_tvb = tvb_new_subset_length(tvb, offset, + unicast_tvlv_packeth->tvlv_len); + + if (have_tap_listener(batadv_follow_tap)) { + tap_queue_packet(batadv_follow_tap, pinfo, next_tvb); + } + + dissect_batadv_tvlv_v15(next_tvb, pinfo, + batadv_unicast_tvlv_tree); + offset += unicast_tvlv_packeth->tvlv_len; + } +} + +static void dissect_batadv_tvlv_v15(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree) +{ + guint8 type, version; + guint16 length; + int offset = 0; + tvbuff_t *next_tvb; + proto_tree *batadv_tvlv_tree = NULL; + + while (offset != -1 && tvb_captured_length_remaining(tvb, offset) >= 4) { + + type = tvb_get_guint8(tvb, offset + 0); + version = tvb_get_guint8(tvb, offset + 1); + length = tvb_get_ntohs(tvb, offset + 2) + 4; + next_tvb = tvb_new_subset_length(tvb, offset, length); + + /* Set tree info */ + if (tree) { + proto_item *ti; + + ti = proto_tree_add_protocol_format(tree, + proto_batadv_plugin, + next_tvb, 0, length, + "TVLV, %s", + val_to_str(type, + tvlv_v15_typenames, + "Unknown (0x%02x)")); + batadv_tvlv_tree = proto_item_add_subtree(ti, ett_batadv_tvlv); + } + + dissect_batadv_tvlv_v15_header(next_tvb, pinfo, + batadv_tvlv_tree, type); + + switch (type) { + case BATADV_TVLV_V15_GW: + dissect_batadv_tvlv_v15_gw(next_tvb, pinfo, + batadv_tvlv_tree, 4, + version); + break; + case BATADV_TVLV_V15_DAT: + dissect_batadv_tvlv_v15_dat(next_tvb, pinfo, + batadv_tvlv_tree, 4, + version); + break; + case BATADV_TVLV_V15_NC: + dissect_batadv_tvlv_v15_nc(next_tvb, pinfo, + batadv_tvlv_tree, 4, + version); + break; + case BATADV_TVLV_V15_TT: + dissect_batadv_tvlv_v15_tt(next_tvb, pinfo, + batadv_tvlv_tree, 4, + version); + break; + case BATADV_TVLV_V15_ROAM: + dissect_batadv_tvlv_v15_roam(next_tvb, pinfo, + batadv_tvlv_tree, 4, + version); + break; + case BATADV_TVLV_V15_MCAST: + dissect_batadv_tvlv_v15_mcast(next_tvb, pinfo, + batadv_tvlv_tree, 4, + version); + break; + default: + call_dissector(data_handle, next_tvb, pinfo, + batadv_tvlv_tree); + break; + } + offset += length; + } +} + +static void dissect_batadv_tvlv_v15_header(tvbuff_t *tvb, + packet_info *pinfo _U_, + proto_tree *tree, guint8 type) +{ + int offset = 0; + + /* items */ + proto_tree_add_uint_format_value(tree, hf_batadv_tvlv_type, tvb, offset, + 1, type, "%s", + val_to_str(type, tvlv_v15_typenames, + "Unknown (0x%02x)")); + offset += 1; + + proto_tree_add_item(tree, hf_batadv_tvlv_version, tvb, offset, 1, + ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_batadv_tvlv_len, tvb, offset, 2, + ENC_BIG_ENDIAN); +} + +static void dissect_batadv_tvlv_v15_dat(tvbuff_t *tvb, packet_info *pinfo _U_, + proto_tree *tree, int offset, + guint8 version) +{ + if (version != 0x01) { + proto_tree_add_expert_format( + tree, pinfo, &ei_batadv_tvlv_unknown_version, tvb, + offset, 0, "Unknown version (0x%02x)", version); + return; + } +} + +static void dissect_batadv_tvlv_v15_nc(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, int offset, + guint8 version) +{ + if (version != 0x01) { + proto_tree_add_expert_format( + tree, pinfo, &ei_batadv_tvlv_unknown_version, tvb, + offset, 0, "Unknown version (0x%02x)", version); + return; + } +} + +static void dissect_batadv_tvlv_v15_mcast(tvbuff_t *tvb, packet_info *pinfo _U_, + proto_tree *tree, int offset, + guint8 version) +{ + static const int * flags[] = { + &hf_batadv_tvlv_mcast_flags_unsnoopables, + &hf_batadv_tvlv_mcast_flags_ipv4, + &hf_batadv_tvlv_mcast_flags_ipv6, + NULL + }; + + if (version != 0x01) { + proto_tree_add_expert_format( + tree, pinfo, &ei_batadv_tvlv_unknown_version, tvb, + offset, 0, "Unknown version (0x%02x)", version); + return; + } + + proto_tree_add_bitmask(tree, tvb, offset, hf_batadv_iv_ogm_flags, + ett_batadv_tvlv_mcast_flags, flags, ENC_NA); + + /* 3 byte of padding. */ +} + +static void dissect_batadv_tvlv_v15_gw(tvbuff_t *tvb, packet_info *pinfo _U_, + proto_tree *tree, int offset, + guint8 version) +{ + guint32 down, up; + + if (version != 0x01) { + proto_tree_add_expert_format( + tree, pinfo, &ei_batadv_tvlv_unknown_version, tvb, + offset, 0, "Unknown version (0x%02x)", version); + return; + } + + down = tvb_get_ntohl(tvb, offset); + proto_tree_add_uint_format_value(tree, hf_batadv_tvlv_gw_download, + tvb, offset, 4, down, "%u.%uMbit", + down / 10, down % 10); + offset += 4; + + up = tvb_get_ntohl(tvb, offset); + proto_tree_add_uint_format_value(tree, hf_batadv_tvlv_gw_upload, tvb, + offset, 4, up, "%u.%uMbit", + up / 10, up % 10); +} + +static void dissect_batadv_tvlv_v15_roam(tvbuff_t *tvb, packet_info *pinfo _U_, + proto_tree *tree, int offset, + guint8 version) +{ + static const int * flags[] = { + &hf_batadv_tvlv_vid_vlan, + &hf_batadv_tvlv_vid_tagged, + NULL + }; + + if (version != 0x01) { + proto_tree_add_expert_format( + tree, pinfo, &ei_batadv_tvlv_unknown_version, tvb, + offset, 0, "Unknown version (0x%02x)", version); + return; + } + + proto_tree_add_item(tree, hf_batadv_tvlv_roam_addr, tvb, offset, 6, + ENC_BIG_ENDIAN); + offset += 6; + + proto_tree_add_bitmask(tree, tvb, offset, hf_batadv_tvlv_roam_vid, + ett_batadv_tvlv_vid, flags, ENC_NA); +} + +static void dissect_batadv_tvlv_v15_tt(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, int offset, + guint8 version) +{ + guint16 num_vlan; + int i; + gint length_remaining; + static const int * flags[] = { + &hf_batadv_tvlv_tt_flags_type, + &hf_batadv_tvlv_tt_flags_full_table, + NULL + }; + + if (version != 0x01) { + proto_tree_add_expert_format( + tree, pinfo, &ei_batadv_tvlv_unknown_version, tvb, + offset, 0, "Unknown version (0x%02x)", version); + return; + } + + proto_tree_add_bitmask(tree, tvb, offset, hf_batadv_tvlv_tt_flags, + ett_batadv_tvlv_tt_flags, flags, ENC_NA); + offset += 1; + + proto_tree_add_item(tree, hf_batadv_tvlv_tt_ttvn, tvb, offset, 1, + ENC_BIG_ENDIAN); + offset += 1; + + num_vlan = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_batadv_tvlv_tt_num_vlan, tvb, offset, 2, + ENC_BIG_ENDIAN); + offset += 2; + + for (i = 0; i < num_vlan; i++) + offset = dissect_batadv_tvlv_v15_tt_vlan(tvb, pinfo, tree, + offset); + + length_remaining = tvb_captured_length_remaining(tvb, offset); + while (length_remaining > 0) { + offset = dissect_batadv_tvlv_v15_tt_change(tvb, pinfo, tree, + offset); + length_remaining = tvb_captured_length_remaining(tvb, offset); + } +} + +static int dissect_batadv_tvlv_v15_tt_vlan(tvbuff_t *tvb, + packet_info *pinfo _U_, + proto_tree *tree, int offset) +{ + proto_tree *vlan_tree = NULL; + guint16 vid; + static const int * flags[] = { + &hf_batadv_tvlv_vid_vlan, + &hf_batadv_tvlv_vid_tagged, + NULL + }; + + vid = tvb_get_ntohs(tvb, offset + 4); + + /* Set tree info */ + if (tree) { + proto_item *ti; + + ti = proto_tree_add_protocol_format(tree, proto_batadv_plugin, + tvb, offset, 8, + "VLAN, %04x", vid); + vlan_tree = proto_item_add_subtree(ti, ett_batadv_tvlv_tt_vlan); + } + + proto_tree_add_item(vlan_tree, hf_batadv_tvlv_tt_vlan_crc, tvb, offset, + 4, ENC_BIG_ENDIAN); + offset += 4; + + proto_tree_add_bitmask(vlan_tree, tvb, offset, + hf_batadv_tvlv_tt_vlan_vid, + ett_batadv_tvlv_vid, flags, ENC_NA); + offset += 2; + + /* Skip 2 byte of padding. */ + offset += 2; + + return offset; +} + +static int dissect_batadv_tvlv_v15_tt_change(tvbuff_t *tvb, + packet_info *pinfo _U_, + proto_tree *tree, int offset) +{ + proto_tree *change_tree = NULL; + const guint8 *addr; + static const int * flags[] = { + &hf_batadv_tvlv_tt_change_flags_del, + &hf_batadv_tvlv_tt_change_flags_roam, + &hf_batadv_tvlv_tt_change_flags_wifi, + &hf_batadv_tvlv_tt_change_flags_isolate, + NULL + }; + static const int * flags_vlan[] = { + &hf_batadv_tvlv_vid_vlan, + &hf_batadv_tvlv_vid_tagged, + NULL + }; + + addr = tvb_get_ptr(tvb, offset + 4, 6); + + /* Set tree info */ + if (tree) { + proto_item *ti; + + ti = proto_tree_add_protocol_format(tree, proto_batadv_plugin, + tvb, offset, 12, + "Entry, %s (%s)", + get_ether_name(addr), + ether_to_str(addr)); + change_tree = proto_item_add_subtree(ti, ett_batadv_tvlv_tt_change); + } + + proto_tree_add_bitmask(change_tree, tvb, offset, + hf_batadv_tvlv_tt_change_flags, + ett_batadv_batman_flags, flags, ENC_NA); + offset += 1; + + /* Skip 3 byte of padding. */ + offset += 3; + + proto_tree_add_item(change_tree, hf_batadv_tvlv_tt_change_addr, tvb, + offset, 6, ENC_BIG_ENDIAN); + offset += 6; + + proto_tree_add_bitmask(change_tree, tvb, offset, + hf_batadv_tvlv_tt_change_vid, + ett_batadv_tvlv_vid, flags_vlan, ENC_NA); + offset += 2; + + return offset; +} + static void batadv_init_routine(void) { reassembly_table_init(&msg_reassembly_table, @@ -3170,6 +4470,7 @@ static void batadv_init_routine(void) void proto_register_batadv(void) { module_t *batadv_module; + expert_module_t* expert_batadv; static hf_register_info hf[] = { { &hf_batadv_packet_type, @@ -3272,6 +4573,61 @@ void proto_register_batadv(void) FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x8, NULL, HFILL } }, + { &hf_batadv_iv_ogm_version, + { "Version", "batadv.iv_ogm.version", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_ttl, + { "Time to Live", "batadv.iv_ogm.ttl", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_flags, + { "Flags", "batadv.iv_ogm.flags", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_seqno, + { "Sequence number", "batadv.iv_ogm.seq", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_orig, + { "Originator", "batadv.iv_ogm.orig", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_prev_sender, + { "Received from", "batadv.iv_ogm.prev_sender", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_tq, + { "Transmission Quality", "batadv.iv_ogm.tq", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_tvlv_len, + { "Length of TVLV", "batadv.iv_ogm.tvlv_len", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_flags_not_best_next_hop, + { "NOT_BEST_NEXT_HOP", "batadv.iv_ogm.flags.not_best_next_hop", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x1, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_flags_primaries_first_hop, + { "PRIMARIES_FIRST_HOP", "batadv.iv_ogm.flags.primaries_first_hop", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x2, + NULL, HFILL } + }, + { &hf_batadv_iv_ogm_flags_directlink, + { "DirectLink", "batadv.iv_ogm.flags.directlink", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x4, + NULL, HFILL } + }, { &hf_batadv_batman_tt, { "Translation Table", "batadv.batman.tt", FT_ETHER, BASE_NONE, NULL, 0x0, @@ -3442,6 +4798,41 @@ void proto_register_batadv(void) FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, + { &hf_batadv_unicast_frag_no, + { "Fragment number", "batadv.unicast_frag.no", + FT_UINT8, BASE_DEC, NULL, 0xF0, + NULL, HFILL } + }, + { &hf_batadv_unicast_frag_total_size, + { "Complete Size", "batadv.unicast_frag.total_size", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_unicast_tvlv_version, + { "Version", "batadv.unicast_tvlv.version", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_unicast_tvlv_ttl, + { "Time to Live", "batadv.unicast_tvlv.ttl", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_unicast_tvlv_dst, + { "Destination", "batadv.unicast_tvlv.dst", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_unicast_tvlv_src, + { "Destination", "batadv.unicast_tvlv.src", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_unicast_tvlv_len, + { "Length of TVLV", "batadv.unicast_tvlv.len", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, { &hf_batadv_vis_version, { "Version", "batadv.vis.version", FT_UINT8, BASE_DEC, NULL, 0x0, @@ -3577,6 +4968,71 @@ void proto_register_batadv(void) FT_ETHER, BASE_NONE, NULL, 0x0, NULL, HFILL } }, + { &hf_batadv_coded_version, + { "Version", "batadv.coded.version", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_coded_ttl, + { "Time to Live", "batadv.coded.ttl", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL} + }, + { &hf_batadv_coded_first_ttvn, + { "TT Version (First)", "batadv.coded.first_ttvn", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL} + }, + { &hf_batadv_coded_first_source, + { "Source (First)", "batadv.coded.first_src", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_coded_first_orig_dest, + { "Original Destination (First)", "batadv.coded.first_orig_dst", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_coded_first_crc, + { "CRC (First)", "batadv.coded.first_crc", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_coded_second_ttl, + { "Time to Live (Second)", "batadv.coded.second_ttl", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL} + }, + { &hf_batadv_coded_second_ttvn, + { "TT Version (Second)", "batadv.coded.second_ttvn", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL} + }, + { &hf_batadv_coded_second_dest, + { "Destination (Second)", "batadv.coded.second_dst", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_coded_second_source, + { "Source (Second)", "batadv.coded.second_src", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_coded_second_orig_dest, + { "Original Destination (Second)", "batadv.coded.second_orig_dst", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_coded_second_crc, + { "CRC (Second)", "batadv.coded.second_crc", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_coded_coded_len, + { "Length", "batadv.coded.length", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, { &hf_msg_fragments, {"Message fragments", "batadv.unicast_frag.fragments", FT_NONE, BASE_NONE, NULL, 0x00, @@ -3648,7 +5104,143 @@ void proto_register_batadv(void) {"Reassembled length", "batadv.msg.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } - } + }, + { &hf_batadv_tvlv_type, + { "Type", "batadv.tvlv.length", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_version, + { "Version", "batadv.tvlv.length", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_len, + { "Length", "batadv.tvlv.len", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_mcast_flags_unsnoopables, + { "Unsnoopables", "batadv.tvlv.mcast.flags.unsnoopables", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x1, + NULL, HFILL } + }, + { &hf_batadv_tvlv_mcast_flags_ipv4, + { "IPv4", "batadv.tvlv.mcast.flags.ipv4", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x2, + NULL, HFILL } + }, + { &hf_batadv_tvlv_mcast_flags_ipv6, + { "IPv6", "batadv.tvlv.mcast.flags.ipv6", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x4, + NULL, HFILL } + }, + { &hf_batadv_tvlv_gw_download, + { "Download Speed", "batadv.tvlv.gw.dl_speed", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_gw_upload, + { "Upload Speed", "batadv.tvlv.gw.ul_speed", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_roam_addr, + { "Address", "batadv.batman.addr", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_roam_vid, + { "VID", "batadv.tvlv.roam.vid", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_vid_vlan, + { "VLAN ID", "batadv.tvlv.vid_vlan", + FT_UINT16, BASE_DEC, NULL, 0x7fff, + NULL, HFILL } + }, + { &hf_batadv_tvlv_vid_tagged, + { "VLAN Tagged", "batadv.tvlv.vid_tagged", + FT_UINT16, BASE_DEC, NULL, 0x8000, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_flags, + { "Flags", "batadv.tvlv.tt.flags", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_flags_type, + { "Query Type", "batadv.tvlv.tt.flags.type", + FT_UINT8, BASE_HEX, VALS(tvlv_tt_typenames), + BATADV_TVLVL_TT_TYPE_MASK, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_flags_full_table, + { "Full Table", "batadv.tvlv.tt.flags.full_table", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), + BATADV_TVLVL_TT_FULL_TABLE, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_ttvn, + { "TT Version", "batadv.tvlv.tt.ttvn", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_num_vlan, + { "VLAN Entries", "batadv.tvlv.tt.num_vlan", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_vlan_crc, + { "CRC", "batadv.tvlv.tt.vlan.crc", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_vlan_vid, + { "VID", "batadv.tvlv.tt.vlan.vid", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_change_flags, + { "Flags", "batadv.tvlv.tt.change.flags", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_change_flags_del, + { "Delete", "batadv.tvlv.tt.change.flags.del", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), + BATADV_TVLVL_TT_CHANGE_DEL, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_change_flags_roam, + { "Client Roam", "batadv.tvlv.tt.change.flags.roam", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), + BATADV_TVLVL_TT_CHANGE_ROAM, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_change_flags_wifi, + { "Wifi Client", "batadv.tvlv.tt.change.flags.wifi", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), + BATADV_TVLVL_TT_CHANGE_WIFI, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_change_flags_isolate, + { "Isolate", "batadv.tvlv.tt.change.flags.isolate", + FT_BOOLEAN, 8, TFS(&tfs_set_notset), + BATADV_TVLVL_TT_CHANGE_ISOLATE, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_change_addr, + { "Address", "batadv.tvlv.tt.change.addr", + FT_ETHER, BASE_NONE, NULL, 0x0, + NULL, HFILL } + }, + { &hf_batadv_tvlv_tt_change_vid, + { "VID", "batadv.tvlv.tt.change.vid", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, }; /* Setup protocol subtree array */ @@ -3657,12 +5249,15 @@ void proto_register_batadv(void) &ett_batadv_batman_flags, &ett_batadv_batman_tt, &ett_batadv_batman_gwflags, + &ett_batadv_iv_ogm, + &ett_batadv_iv_ogm_flags, &ett_batadv_bcast, &ett_batadv_icmp, &ett_batadv_icmp_rr, &ett_batadv_unicast, &ett_batadv_unicast_4addr, &ett_batadv_unicast_frag, + &ett_batadv_unicast_tvlv, &ett_batadv_vis, &ett_batadv_vis_entry, &ett_batadv_tt_query, @@ -3670,10 +5265,21 @@ void proto_register_batadv(void) &ett_batadv_tt_entry, &ett_batadv_tt_entry_flags, &ett_batadv_roam_adv, + &ett_batadv_coded, + &ett_batadv_tvlv, + &ett_batadv_tvlv_vid, + &ett_batadv_tvlv_mcast_flags, + &ett_batadv_tvlv_tt_flags, + &ett_batadv_tvlv_tt_vlan, + &ett_batadv_tvlv_tt_change, &ett_msg_fragment, &ett_msg_fragments }; + static ei_register_info ei[] = { + { &ei_batadv_tvlv_unknown_version, { "batadv.error.tvlv_version_unknown", PI_UNDECODED, PI_ERROR, "BATADV Error: unknown TVLV version", EXPFILL }}, + }; + proto_batadv_plugin = proto_register_protocol( "B.A.T.M.A.N. Advanced Protocol", "BATADV", /* short name */ @@ -3691,6 +5297,9 @@ void proto_register_batadv(void) proto_register_subtree_array(ett, array_length(ett)); proto_register_field_array(proto_batadv_plugin, hf, array_length(hf)); + expert_batadv = expert_register_protocol(proto_batadv_plugin); + expert_register_field_array(expert_batadv, ei, array_length(ei)); + register_init_routine(&batadv_init_routine); } @@ -3700,7 +5309,7 @@ void proto_reg_handoff_batadv(void) static unsigned int old_batadv_ethertype; if (!inited) { - batman_handle = create_dissector_handle(dissect_batman_plugin, proto_batadv_plugin); + batman_handle = create_dissector_handle(dissect_batadv_plugin, proto_batadv_plugin); data_handle = find_dissector("data"); eth_handle = find_dissector("eth"); -- cgit v1.2.3