/* packet-spdy.c * Routines for SPDY packet disassembly * For now, the protocol spec can be found at * http://dev.chromium.org/spdy/spdy-protocol * * Copyright 2010, Google Inc. * Hasan Khalil * Chris Bentzel * Eric Shienbrood * * Copyright 2013-2014 * Alexis La Goutte * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * Originally based on packet-http.c * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "config.h" #include #include #include #include #include "packet-tcp.h" #include "packet-ssl.h" #ifdef HAVE_LIBZ #include #endif void proto_register_spdy(void); void proto_reg_handoff_spdy(void); #define MIN_SPDY_VERSION 3 #define SPDY_STREAM_ID_MASK 0x7FFFFFFF /* * Conversation data - used for assembling multi-data-frame * entities and for decompressing request & reply header blocks. */ typedef struct _spdy_conv_t { #ifdef HAVE_LIBZ z_streamp rqst_decompressor; z_streamp rply_decompressor; uLong dictionary_id; #endif wmem_tree_t *streams; } spdy_conv_t; /* The types of SPDY frames */ #define SPDY_DATA 0 #define SPDY_SYN_STREAM 1 #define SPDY_SYN_REPLY 2 #define SPDY_RST_STREAM 3 #define SPDY_SETTINGS 4 #define SPDY_PING 6 #define SPDY_GOAWAY 7 #define SPDY_HEADERS 8 #define SPDY_WINDOW_UPDATE 9 #define SPDY_CREDENTIAL 10 #define SPDY_INVALID 11 #define SPDY_FLAG_FIN 0x01 #define SPDY_FLAG_UNIDIRECTIONAL 0x02 #define SPDY_FLAG_SETTINGS_CLEAR_SETTINGS 0x01 /* Flags for each setting in a SETTINGS frame. */ #define SPDY_FLAG_SETTINGS_PERSIST_VALUE 0x01 #define SPDY_FLAG_SETTINGS_PERSISTED 0x02 #define TCP_PORT_SPDY 6121 static const value_string frame_type_names[] = { { SPDY_DATA, "DATA" }, { SPDY_SYN_STREAM, "SYN_STREAM" }, { SPDY_SYN_REPLY, "SYN_REPLY" }, { SPDY_RST_STREAM, "RST_STREAM" }, { SPDY_SETTINGS, "SETTINGS" }, { SPDY_PING, "PING" }, { SPDY_GOAWAY, "GOAWAY" }, { SPDY_HEADERS, "HEADERS" }, { SPDY_WINDOW_UPDATE, "WINDOW_UPDATE" }, { SPDY_CREDENTIAL, "CREDENTIAL" }, { SPDY_INVALID, "INVALID" }, { 0, NULL } }; static const value_string rst_stream_status_names[] = { { 1, "PROTOCOL_ERROR" }, { 2, "INVALID_STREAM" }, { 3, "REFUSED_STREAM" }, { 4, "UNSUPPORTED_VERSION" }, { 5, "CANCEL" }, { 6, "INTERNAL_ERROR" }, { 7, "FLOW_CONTROL_ERROR" }, { 8, "STREAM_IN_USE" }, { 9, "STREAM_ALREADY_CLOSED" }, { 10, "INVALID_CREDENTIALS" }, { 11, "FRAME_TOO_LARGE" }, { 12, "INVALID" }, { 0, NULL } }; static const value_string setting_id_names[] = { { 1, "UPLOAD_BANDWIDTH" }, { 2, "DOWNLOAD_BANDWIDTH" }, { 3, "ROUND_TRIP_TIME" }, { 4, "MAX_CONCURRENT_STREAMS" }, { 5, "CURRENT_CWND" }, { 6, "DOWNLOAD_RETRANS_RATE" }, { 7, "INITIAL_WINDOW_SIZE" }, { 0, NULL } }; static const value_string goaway_status_names[] = { { 0, "OK" }, { 1, "PROTOCOL_ERROR" }, { 11, "INTERNAL_ERROR" }, { 0, NULL } }; /* * This structure will be tied to each SPDY frame and is used as an argument for * dissect_spdy_*_payload() functions. */ typedef struct _spdy_control_frame_info_t { gboolean control_bit; guint16 version; guint16 type; guint8 flags; guint32 length; /* Actually only 24 bits. */ } spdy_control_frame_info_t; /* * This structure will be tied to each SPDY header frame. * Only applies to frames containing headers: SYN_STREAM, SYN_REPLY, HEADERS * Note that there may be multiple SPDY frames in one packet. */ typedef struct _spdy_header_info_t { guint32 stream_id; guint8 *header_block; guint header_block_len; guint16 frame_type; } spdy_header_info_t; static wmem_list_t *header_info_list; /* * This structures keeps track of all the data frames * associated with a stream, so that they can be * reassembled into a single chunk. */ typedef struct _spdy_data_frame_t { guint8 *data; guint32 length; guint32 framenum; } spdy_data_frame_t; typedef struct _spdy_stream_info_t { gchar *content_type; gchar *content_type_parameters; gchar *content_encoding; wmem_list_t *data_frames; tvbuff_t *assembled_data; guint num_data_frames; } spdy_stream_info_t; /* Handles for metadata population. */ static int spdy_tap = -1; static int spdy_eo_tap = -1; static int proto_spdy = -1; static int hf_spdy_data = -1; static int hf_spdy_control_bit = -1; static int hf_spdy_version = -1; static int hf_spdy_type = -1; static int hf_spdy_flags = -1; static int hf_spdy_flags_fin = -1; static int hf_spdy_flags_unidirectional = -1; static int hf_spdy_flags_clear_settings = -1; static int hf_spdy_flags_persist_value = -1; static int hf_spdy_flags_persisted = -1; static int hf_spdy_length = -1; static int hf_spdy_header_block = -1; static int hf_spdy_header = -1; static int hf_spdy_header_name = -1; static int hf_spdy_header_value = -1; static int hf_spdy_streamid = -1; static int hf_spdy_associated_streamid = -1; static int hf_spdy_priority = -1; static int hf_spdy_unused = -1; static int hf_spdy_slot = -1; static int hf_spdy_num_headers = -1; static int hf_spdy_rst_stream_status = -1; static int hf_spdy_num_settings = -1; static int hf_spdy_setting = -1; static int hf_spdy_setting_id = -1; static int hf_spdy_setting_value = -1; static int hf_spdy_ping_id = -1; static int hf_spdy_goaway_last_good_stream_id = -1; static int hf_spdy_goaway_status = -1; static int hf_spdy_window_update_delta = -1; static gint ett_spdy = -1; static gint ett_spdy_flags = -1; static gint ett_spdy_header_block = -1; static gint ett_spdy_header = -1; static gint ett_spdy_setting = -1; static gint ett_spdy_encoded_entity = -1; static expert_field ei_spdy_inflation_failed = EI_INIT; static expert_field ei_spdy_mal_frame_data = EI_INIT; static expert_field ei_spdy_mal_setting_frame = EI_INIT; static expert_field ei_spdy_invalid_rst_stream = EI_INIT; static expert_field ei_spdy_invalid_go_away = EI_INIT; static expert_field ei_spdy_invalid_frame_type = EI_INIT; static expert_field ei_spdy_reassembly_info = EI_INIT; static dissector_handle_t data_handle; static dissector_handle_t media_handle; static dissector_handle_t spdy_handle; static dissector_table_t media_type_subdissector_table; static dissector_table_t port_subdissector_table; static gboolean spdy_assemble_entity_bodies = TRUE; /* * Decompression of zlib encoded entities. */ #ifdef HAVE_LIBZ static gboolean spdy_decompress_body = TRUE; static gboolean spdy_decompress_headers = TRUE; #else static gboolean spdy_decompress_body = FALSE; static gboolean spdy_decompress_headers = FALSE; #endif static const char spdy_dictionary[] = { 0x00, 0x00, 0x00, 0x07, 0x6f, 0x70, 0x74, 0x69, /* - - - - o p t i */ 0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x04, 0x68, /* o n s - - - - h */ 0x65, 0x61, 0x64, 0x00, 0x00, 0x00, 0x04, 0x70, /* e a d - - - - p */ 0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x03, 0x70, /* o s t - - - - p */ 0x75, 0x74, 0x00, 0x00, 0x00, 0x06, 0x64, 0x65, /* u t - - - - d e */ 0x6c, 0x65, 0x74, 0x65, 0x00, 0x00, 0x00, 0x05, /* l e t e - - - - */ 0x74, 0x72, 0x61, 0x63, 0x65, 0x00, 0x00, 0x00, /* t r a c e - - - */ 0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x00, /* - a c c e p t - */ 0x00, 0x00, 0x0e, 0x61, 0x63, 0x63, 0x65, 0x70, /* - - - a c c e p */ 0x74, 0x2d, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, /* t - c h a r s e */ 0x74, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x63, 0x63, /* t - - - - a c c */ 0x65, 0x70, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, /* e p t - e n c o */ 0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x0f, /* d i n g - - - - */ 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x6c, /* a c c e p t - l */ 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x00, /* a n g u a g e - */ 0x00, 0x00, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70, /* - - - a c c e p */ 0x74, 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, /* t - r a n g e s */ 0x00, 0x00, 0x00, 0x03, 0x61, 0x67, 0x65, 0x00, /* - - - - a g e - */ 0x00, 0x00, 0x05, 0x61, 0x6c, 0x6c, 0x6f, 0x77, /* - - - a l l o w */ 0x00, 0x00, 0x00, 0x0d, 0x61, 0x75, 0x74, 0x68, /* - - - - a u t h */ 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, /* o r i z a t i o */ 0x6e, 0x00, 0x00, 0x00, 0x0d, 0x63, 0x61, 0x63, /* n - - - - c a c */ 0x68, 0x65, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, /* h e - c o n t r */ 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x0a, 0x63, 0x6f, /* o l - - - - c o */ 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, /* n n e c t i o n */ 0x00, 0x00, 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, /* - - - - c o n t */ 0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65, /* e n t - b a s e */ 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, 0x6e, 0x74, /* - - - - c o n t */ 0x65, 0x6e, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, /* e n t - e n c o */ 0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, /* d i n g - - - - */ 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, /* c o n t e n t - */ 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, /* l a n g u a g e */ 0x00, 0x00, 0x00, 0x0e, 0x63, 0x6f, 0x6e, 0x74, /* - - - - c o n t */ 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x65, 0x6e, 0x67, /* e n t - l e n g */ 0x74, 0x68, 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, /* t h - - - - c o */ 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x6f, /* n t e n t - l o */ 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, /* c a t i o n - - */ 0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, /* - - c o n t e n */ 0x74, 0x2d, 0x6d, 0x64, 0x35, 0x00, 0x00, 0x00, /* t - m d 5 - - - */ 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, /* - c o n t e n t */ 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, /* - r a n g e - - */ 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, /* - - c o n t e n */ 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00, /* t - t y p e - - */ 0x00, 0x04, 0x64, 0x61, 0x74, 0x65, 0x00, 0x00, /* - - d a t e - - */ 0x00, 0x04, 0x65, 0x74, 0x61, 0x67, 0x00, 0x00, /* - - e t a g - - */ 0x00, 0x06, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, /* - - e x p e c t */ 0x00, 0x00, 0x00, 0x07, 0x65, 0x78, 0x70, 0x69, /* - - - - e x p i */ 0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x04, 0x66, /* r e s - - - - f */ 0x72, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x04, 0x68, /* r o m - - - - h */ 0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x69, /* o s t - - - - i */ 0x66, 0x2d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, /* f - m a t c h - */ 0x00, 0x00, 0x11, 0x69, 0x66, 0x2d, 0x6d, 0x6f, /* - - - i f - m o */ 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2d, 0x73, /* d i f i e d - s */ 0x69, 0x6e, 0x63, 0x65, 0x00, 0x00, 0x00, 0x0d, /* i n c e - - - - */ 0x69, 0x66, 0x2d, 0x6e, 0x6f, 0x6e, 0x65, 0x2d, /* i f - n o n e - */ 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, 0x00, 0x00, /* m a t c h - - - */ 0x08, 0x69, 0x66, 0x2d, 0x72, 0x61, 0x6e, 0x67, /* - i f - r a n g */ 0x65, 0x00, 0x00, 0x00, 0x13, 0x69, 0x66, 0x2d, /* e - - - - i f - */ 0x75, 0x6e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, /* u n m o d i f i */ 0x65, 0x64, 0x2d, 0x73, 0x69, 0x6e, 0x63, 0x65, /* e d - s i n c e */ 0x00, 0x00, 0x00, 0x0d, 0x6c, 0x61, 0x73, 0x74, /* - - - - l a s t */ 0x2d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, /* - m o d i f i e */ 0x64, 0x00, 0x00, 0x00, 0x08, 0x6c, 0x6f, 0x63, /* d - - - - l o c */ 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, /* a t i o n - - - */ 0x0c, 0x6d, 0x61, 0x78, 0x2d, 0x66, 0x6f, 0x72, /* - m a x - f o r */ 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x00, 0x00, /* w a r d s - - - */ 0x06, 0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x00, /* - p r a g m a - */ 0x00, 0x00, 0x12, 0x70, 0x72, 0x6f, 0x78, 0x79, /* - - - p r o x y */ 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, /* - a u t h e n t */ 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00, /* i c a t e - - - */ 0x13, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2d, 0x61, /* - p r o x y - a */ 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, /* u t h o r i z a */ 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x05, /* t i o n - - - - */ 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, 0x00, /* r a n g e - - - */ 0x07, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x72, /* - r e f e r e r */ 0x00, 0x00, 0x00, 0x0b, 0x72, 0x65, 0x74, 0x72, /* - - - - r e t r */ 0x79, 0x2d, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00, /* y - a f t e r - */ 0x00, 0x00, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, /* - - - s e r v e */ 0x72, 0x00, 0x00, 0x00, 0x02, 0x74, 0x65, 0x00, /* r - - - - t e - */ 0x00, 0x00, 0x07, 0x74, 0x72, 0x61, 0x69, 0x6c, /* - - - t r a i l */ 0x65, 0x72, 0x00, 0x00, 0x00, 0x11, 0x74, 0x72, /* e r - - - - t r */ 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2d, 0x65, /* a n s f e r - e */ 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00, /* n c o d i n g - */ 0x00, 0x00, 0x07, 0x75, 0x70, 0x67, 0x72, 0x61, /* - - - u p g r a */ 0x64, 0x65, 0x00, 0x00, 0x00, 0x0a, 0x75, 0x73, /* d e - - - - u s */ 0x65, 0x72, 0x2d, 0x61, 0x67, 0x65, 0x6e, 0x74, /* e r - a g e n t */ 0x00, 0x00, 0x00, 0x04, 0x76, 0x61, 0x72, 0x79, /* - - - - v a r y */ 0x00, 0x00, 0x00, 0x03, 0x76, 0x69, 0x61, 0x00, /* - - - - v i a - */ 0x00, 0x00, 0x07, 0x77, 0x61, 0x72, 0x6e, 0x69, /* - - - w a r n i */ 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, 0x77, 0x77, /* n g - - - - w w */ 0x77, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, /* w - a u t h e n */ 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, /* t i c a t e - - */ 0x00, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, /* - - m e t h o d */ 0x00, 0x00, 0x00, 0x03, 0x67, 0x65, 0x74, 0x00, /* - - - - g e t - */ 0x00, 0x00, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, /* - - - s t a t u */ 0x73, 0x00, 0x00, 0x00, 0x06, 0x32, 0x30, 0x30, /* s - - - - 2 0 0 */ 0x20, 0x4f, 0x4b, 0x00, 0x00, 0x00, 0x07, 0x76, /* - O K - - - - v */ 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00, /* e r s i o n - - */ 0x00, 0x08, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, /* - - H T T P - 1 */ 0x2e, 0x31, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72, /* - 1 - - - - u r */ 0x6c, 0x00, 0x00, 0x00, 0x06, 0x70, 0x75, 0x62, /* l - - - - p u b */ 0x6c, 0x69, 0x63, 0x00, 0x00, 0x00, 0x0a, 0x73, /* l i c - - - - s */ 0x65, 0x74, 0x2d, 0x63, 0x6f, 0x6f, 0x6b, 0x69, /* e t - c o o k i */ 0x65, 0x00, 0x00, 0x00, 0x0a, 0x6b, 0x65, 0x65, /* e - - - - k e e */ 0x70, 0x2d, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x00, /* p - a l i v e - */ 0x00, 0x00, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, /* - - - o r i g i */ 0x6e, 0x31, 0x30, 0x30, 0x31, 0x30, 0x31, 0x32, /* n 1 0 0 1 0 1 2 */ 0x30, 0x31, 0x32, 0x30, 0x32, 0x32, 0x30, 0x35, /* 0 1 2 0 2 2 0 5 */ 0x32, 0x30, 0x36, 0x33, 0x30, 0x30, 0x33, 0x30, /* 2 0 6 3 0 0 3 0 */ 0x32, 0x33, 0x30, 0x33, 0x33, 0x30, 0x34, 0x33, /* 2 3 0 3 3 0 4 3 */ 0x30, 0x35, 0x33, 0x30, 0x36, 0x33, 0x30, 0x37, /* 0 5 3 0 6 3 0 7 */ 0x34, 0x30, 0x32, 0x34, 0x30, 0x35, 0x34, 0x30, /* 4 0 2 4 0 5 4 0 */ 0x36, 0x34, 0x30, 0x37, 0x34, 0x30, 0x38, 0x34, /* 6 4 0 7 4 0 8 4 */ 0x30, 0x39, 0x34, 0x31, 0x30, 0x34, 0x31, 0x31, /* 0 9 4 1 0 4 1 1 */ 0x34, 0x31, 0x32, 0x34, 0x31, 0x33, 0x34, 0x31, /* 4 1 2 4 1 3 4 1 */ 0x34, 0x34, 0x31, 0x35, 0x34, 0x31, 0x36, 0x34, /* 4 4 1 5 4 1 6 4 */ 0x31, 0x37, 0x35, 0x30, 0x32, 0x35, 0x30, 0x34, /* 1 7 5 0 2 5 0 4 */ 0x35, 0x30, 0x35, 0x32, 0x30, 0x33, 0x20, 0x4e, /* 5 0 5 2 0 3 - N */ 0x6f, 0x6e, 0x2d, 0x41, 0x75, 0x74, 0x68, 0x6f, /* o n - A u t h o */ 0x72, 0x69, 0x74, 0x61, 0x74, 0x69, 0x76, 0x65, /* r i t a t i v e */ 0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, /* - I n f o r m a */ 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x30, 0x34, 0x20, /* t i o n 2 0 4 - */ 0x4e, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65, /* N o - C o n t e */ 0x6e, 0x74, 0x33, 0x30, 0x31, 0x20, 0x4d, 0x6f, /* n t 3 0 1 - M o */ 0x76, 0x65, 0x64, 0x20, 0x50, 0x65, 0x72, 0x6d, /* v e d - P e r m */ 0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x34, /* a n e n t l y 4 */ 0x30, 0x30, 0x20, 0x42, 0x61, 0x64, 0x20, 0x52, /* 0 0 - B a d - R */ 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x34, 0x30, /* e q u e s t 4 0 */ 0x31, 0x20, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, /* 1 - U n a u t h */ 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x34, 0x30, /* o r i z e d 4 0 */ 0x33, 0x20, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64, /* 3 - F o r b i d */ 0x64, 0x65, 0x6e, 0x34, 0x30, 0x34, 0x20, 0x4e, /* d e n 4 0 4 - N */ 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, /* o t - F o u n d */ 0x35, 0x30, 0x30, 0x20, 0x49, 0x6e, 0x74, 0x65, /* 5 0 0 - I n t e */ 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x53, 0x65, 0x72, /* r n a l - S e r */ 0x76, 0x65, 0x72, 0x20, 0x45, 0x72, 0x72, 0x6f, /* v e r - E r r o */ 0x72, 0x35, 0x30, 0x31, 0x20, 0x4e, 0x6f, 0x74, /* r 5 0 1 - N o t */ 0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, /* - I m p l e m e */ 0x6e, 0x74, 0x65, 0x64, 0x35, 0x30, 0x33, 0x20, /* n t e d 5 0 3 - */ 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, /* S e r v i c e - */ 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, /* U n a v a i l a */ 0x62, 0x6c, 0x65, 0x4a, 0x61, 0x6e, 0x20, 0x46, /* b l e J a n - F */ 0x65, 0x62, 0x20, 0x4d, 0x61, 0x72, 0x20, 0x41, /* e b - M a r - A */ 0x70, 0x72, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x4a, /* p r - M a y - J */ 0x75, 0x6e, 0x20, 0x4a, 0x75, 0x6c, 0x20, 0x41, /* u n - J u l - A */ 0x75, 0x67, 0x20, 0x53, 0x65, 0x70, 0x74, 0x20, /* u g - S e p t - */ 0x4f, 0x63, 0x74, 0x20, 0x4e, 0x6f, 0x76, 0x20, /* O c t - N o v - */ 0x44, 0x65, 0x63, 0x20, 0x30, 0x30, 0x3a, 0x30, /* D e c - 0 0 - 0 */ 0x30, 0x3a, 0x30, 0x30, 0x20, 0x4d, 0x6f, 0x6e, /* 0 - 0 0 - M o n */ 0x2c, 0x20, 0x54, 0x75, 0x65, 0x2c, 0x20, 0x57, /* - - T u e - - W */ 0x65, 0x64, 0x2c, 0x20, 0x54, 0x68, 0x75, 0x2c, /* e d - - T h u - */ 0x20, 0x46, 0x72, 0x69, 0x2c, 0x20, 0x53, 0x61, /* - F r i - - S a */ 0x74, 0x2c, 0x20, 0x53, 0x75, 0x6e, 0x2c, 0x20, /* t - - S u n - - */ 0x47, 0x4d, 0x54, 0x63, 0x68, 0x75, 0x6e, 0x6b, /* G M T c h u n k */ 0x65, 0x64, 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, /* e d - t e x t - */ 0x68, 0x74, 0x6d, 0x6c, 0x2c, 0x69, 0x6d, 0x61, /* h t m l - i m a */ 0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x2c, 0x69, /* g e - p n g - i */ 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x6a, 0x70, 0x67, /* m a g e - j p g */ 0x2c, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x67, /* - i m a g e - g */ 0x69, 0x66, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69, /* i f - a p p l i */ 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, /* c a t i o n - x */ 0x6d, 0x6c, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69, /* m l - a p p l i */ 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, /* c a t i o n - x */ 0x68, 0x74, 0x6d, 0x6c, 0x2b, 0x78, 0x6d, 0x6c, /* h t m l - x m l */ 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c, /* - t e x t - p l */ 0x61, 0x69, 0x6e, 0x2c, 0x74, 0x65, 0x78, 0x74, /* a i n - t e x t */ 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, /* - j a v a s c r */ 0x69, 0x70, 0x74, 0x2c, 0x70, 0x75, 0x62, 0x6c, /* i p t - p u b l */ 0x69, 0x63, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, /* i c p r i v a t */ 0x65, 0x6d, 0x61, 0x78, 0x2d, 0x61, 0x67, 0x65, /* e m a x - a g e */ 0x3d, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x64, 0x65, /* - g z i p - d e */ 0x66, 0x6c, 0x61, 0x74, 0x65, 0x2c, 0x73, 0x64, /* f l a t e - s d */ 0x63, 0x68, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, /* c h c h a r s e */ 0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x63, /* t - u t f - 8 c */ 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x69, /* h a r s e t - i */ 0x73, 0x6f, 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d, /* s o - 8 8 5 9 - */ 0x31, 0x2c, 0x75, 0x74, 0x66, 0x2d, 0x2c, 0x2a, /* 1 - u t f - - - */ 0x2c, 0x65, 0x6e, 0x71, 0x3d, 0x30, 0x2e /* - e n q - 0 - */ }; #ifdef HAVE_LIBZ /* callback function used at the end of file-scope to cleanup zlib's inflate * streams to avoid memory leaks. * XXX: can we be more aggressive and call this sooner for finished streams? */ static gboolean inflate_end_cb (wmem_allocator_t *allocator _U_, wmem_cb_event_t event _U_, void *user_data) { inflateEnd((z_streamp)user_data); return FALSE; } #endif /* * Protocol initialization */ static void spdy_init_protocol(void) { header_info_list = NULL; } /* * Returns conversation data for a given packet. If conversation data can't be * found, creates and returns new conversation data. */ static spdy_conv_t * get_or_create_spdy_conversation_data(packet_info *pinfo) { conversation_t *conversation; spdy_conv_t *conv_data; #ifdef HAVE_LIBZ int retcode; #endif conversation = find_or_create_conversation(pinfo); /* Retrieve information from conversation */ conv_data = (spdy_conv_t *)conversation_get_proto_data(conversation, proto_spdy); if (!conv_data) { /* Set up the conversation structure itself */ conv_data = wmem_new0(wmem_file_scope(), spdy_conv_t); conv_data->streams = NULL; if (spdy_decompress_headers) { #ifdef HAVE_LIBZ conv_data->rqst_decompressor = wmem_new0(wmem_file_scope(), z_stream); conv_data->rply_decompressor = wmem_new0(wmem_file_scope(), z_stream); retcode = inflateInit(conv_data->rqst_decompressor); if (retcode == Z_OK) { wmem_register_callback(wmem_file_scope(), inflate_end_cb, conv_data->rqst_decompressor); retcode = inflateInit(conv_data->rply_decompressor); if (retcode == Z_OK) { wmem_register_callback(wmem_file_scope(), inflate_end_cb, conv_data->rply_decompressor); } } /* XXX - use wsutil/adler32.h? */ conv_data->dictionary_id = adler32(0L, Z_NULL, 0); conv_data->dictionary_id = adler32(conv_data->dictionary_id, spdy_dictionary, (uInt)sizeof(spdy_dictionary)); #endif } conversation_add_proto_data(conversation, proto_spdy, conv_data); } return conv_data; } /* * Retains state on a given stream. */ static void spdy_save_stream_info(spdy_conv_t *conv_data, guint32 stream_id, gchar *content_type, gchar *content_type_params, gchar *content_encoding) { spdy_stream_info_t *si; if (conv_data->streams == NULL) { conv_data->streams = wmem_tree_new(wmem_file_scope()); } si = (spdy_stream_info_t *)wmem_alloc(wmem_file_scope(), sizeof(spdy_stream_info_t)); si->content_type = content_type; si->content_type_parameters = content_type_params; si->content_encoding = content_encoding; si->data_frames = wmem_list_new(wmem_file_scope()); si->num_data_frames = 0; si->assembled_data = NULL; wmem_tree_insert32(conv_data->streams, stream_id, si); } /* * Retrieves previously saved state on a given stream. */ static spdy_stream_info_t* spdy_get_stream_info(spdy_conv_t *conv_data, guint32 stream_id) { if (conv_data->streams == NULL) return NULL; return (spdy_stream_info_t*)wmem_tree_lookup32(conv_data->streams, stream_id); } /* * Adds a data chunk to a given SPDY converstaion/stream. */ static void spdy_add_data_chunk(spdy_conv_t *conv_data, guint32 stream_id, guint32 frame, guint8 *data, guint32 length) { spdy_stream_info_t *si = spdy_get_stream_info(conv_data, stream_id); if (si != NULL) { spdy_data_frame_t *df = (spdy_data_frame_t *)wmem_new(wmem_file_scope(), spdy_data_frame_t); df->data = data; df->length = length; df->framenum = frame; wmem_list_append(si->data_frames, df); ++si->num_data_frames; } } /* * Increment the count of DATA frames found on a given stream. */ static void spdy_increment_data_chunk_count(spdy_conv_t *conv_data, guint32 stream_id) { spdy_stream_info_t *si = spdy_get_stream_info(conv_data, stream_id); if (si != NULL) { ++si->num_data_frames; } } /* * Return the number of data frames saved so far for the specified stream. */ static guint spdy_get_num_data_frames(spdy_conv_t *conv_data, guint32 stream_id) { spdy_stream_info_t *si = spdy_get_stream_info(conv_data, stream_id); return si == NULL ? 0 : si->num_data_frames; } /* * Reassembles DATA frames for a given stream into one tvb. */ static spdy_stream_info_t* spdy_assemble_data_frames(spdy_conv_t *conv_data, guint32 stream_id) { spdy_stream_info_t *si = spdy_get_stream_info(conv_data, stream_id); tvbuff_t *tvb; if (si == NULL) { return NULL; } /* * Compute the total amount of data and concatenate the * data chunks, if it hasn't already been done. */ if (si->assembled_data == NULL) { spdy_data_frame_t *df; guint8 *data; guint32 datalen; guint32 offset; wmem_list_t *dflist = si->data_frames; wmem_list_frame_t *frame; if (wmem_list_count(dflist) == 0) { return si; } datalen = 0; /* * It'd be nice to use a composite tvbuff here, but since * only a real-data tvbuff can be the child of another * tvb, we can't. It would be nice if this limitation * could be fixed. */ frame = wmem_list_frame_next(wmem_list_head(dflist)); while (frame != NULL) { df = (spdy_data_frame_t *)wmem_list_frame_data(frame); datalen += df->length; frame = wmem_list_frame_next(frame); } if (datalen != 0) { data = (guint8 *)wmem_alloc(wmem_file_scope(), datalen); dflist = si->data_frames; offset = 0; frame = wmem_list_frame_next(wmem_list_head(dflist)); while (frame != NULL) { df = (spdy_data_frame_t *)wmem_list_frame_data(frame); memcpy(data+offset, df->data, df->length); offset += df->length; frame = wmem_list_frame_next(frame); } tvb = tvb_new_real_data(data, datalen, datalen); si->assembled_data = tvb; } } return si; } /* * Same as dissect_spdy_stream_id below, except with explicit field index. */ static void dissect_spdy_stream_id_field(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *frame_tree, const int hfindex) { guint32 stream_id = tvb_get_ntohl(tvb, offset) & SPDY_STREAM_ID_MASK; /* Add stream id to tree. */ proto_tree_add_item(frame_tree, hfindex, tvb, offset, 4, ENC_BIG_ENDIAN); if (hfindex == hf_spdy_streamid) { proto_item_append_text(frame_tree, ", Stream: %u", stream_id); } } /* * Adds flag details to proto tree. */ static void dissect_spdy_flags(tvbuff_t *tvb, int offset, proto_tree *frame_tree, const spdy_control_frame_info_t *frame) { proto_item *flags_ti; proto_tree *flags_tree; /* Create flags substree. */ flags_ti = proto_tree_add_item(frame_tree, hf_spdy_flags, tvb, offset, 1, ENC_BIG_ENDIAN); flags_tree = proto_item_add_subtree(flags_ti, ett_spdy_flags); /* Add FIN flag for appropriate frames. */ if (frame->type == SPDY_DATA || frame->type == SPDY_SYN_STREAM || frame->type == SPDY_SYN_REPLY || frame->type == SPDY_HEADERS) { /* Add FIN flag. */ proto_tree_add_item(flags_tree, hf_spdy_flags_fin, tvb, offset, 1, ENC_BIG_ENDIAN); if (frame->flags & SPDY_FLAG_FIN) { proto_item_append_text(frame_tree, " (FIN)"); proto_item_append_text(flags_ti, " (FIN)"); } } /* Add UNIDIRECTIONAL flag, only applicable for SYN_STREAM. */ if (frame->type == SPDY_SYN_STREAM) { proto_tree_add_item(flags_tree, hf_spdy_flags_unidirectional, tvb, offset, 1, ENC_BIG_ENDIAN); if (frame->flags & SPDY_FLAG_UNIDIRECTIONAL) { proto_item_append_text(flags_ti, " (UNIDIRECTIONAL)"); } } /* Add CLEAR_SETTINGS flag, only applicable for SETTINGS. */ if (frame->type == SPDY_SETTINGS) { proto_tree_add_item(flags_tree, hf_spdy_flags_clear_settings, tvb, offset, 1, ENC_BIG_ENDIAN); if (frame->flags & SPDY_FLAG_SETTINGS_CLEAR_SETTINGS) { proto_item_append_text(flags_ti, " (CLEAR)"); } } } /* * Performs DATA frame payload dissection. */ static int dissect_spdy_data_payload(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *top_level_tree _U_, proto_tree *spdy_tree, proto_item *spdy_proto, spdy_conv_t *conv_data, guint32 stream_id, const spdy_control_frame_info_t *frame) { dissector_handle_t handle; guint num_data_frames; gboolean dissected; /* Add frame description. */ proto_item_append_text(spdy_proto, ", Stream: %d, Length: %d", stream_id, frame->length); /* Add data. */ proto_tree_add_item(spdy_tree, hf_spdy_data, tvb, offset, frame->length, ENC_NA); num_data_frames = spdy_get_num_data_frames(conv_data, stream_id); if (frame->length != 0 || num_data_frames != 0) { /* * There's stuff left over; process it. */ tvbuff_t *next_tvb = NULL; tvbuff_t *data_tvb = NULL; spdy_stream_info_t *si = NULL; guint8 *copied_data; gboolean is_single_chunk = FALSE; gboolean have_entire_body; char *media_str = NULL; /* * Create a tvbuff for the payload. */ if (frame->length != 0) { next_tvb = tvb_new_subset_length(tvb, offset, frame->length); is_single_chunk = num_data_frames == 0 && (frame->flags & SPDY_FLAG_FIN) != 0; if (!pinfo->fd->flags.visited) { if (!is_single_chunk) { if (spdy_assemble_entity_bodies) { copied_data = (guint8 *)tvb_memdup(wmem_file_scope(),next_tvb, 0, frame->length); spdy_add_data_chunk(conv_data, stream_id, pinfo->fd->num, copied_data, frame->length); } else { spdy_increment_data_chunk_count(conv_data, stream_id); } } } } else { is_single_chunk = (num_data_frames == 1); } if (!(frame->flags & SPDY_FLAG_FIN)) { col_set_fence(pinfo->cinfo, COL_INFO); proto_item_append_text(spdy_proto, " (partial entity body)"); /* would like the proto item to say */ /* " (entity body fragment N of M)" */ goto body_dissected; } have_entire_body = is_single_chunk; /* * On seeing the last data frame in a stream, we can * reassemble the frames into one data block. */ si = spdy_assemble_data_frames(conv_data, stream_id); if (si == NULL) { goto body_dissected; } data_tvb = si->assembled_data; if (spdy_assemble_entity_bodies) { have_entire_body = TRUE; } if (!have_entire_body) { goto body_dissected; } if (data_tvb == NULL) { if (next_tvb == NULL) goto body_dissected; data_tvb = next_tvb; } else { add_new_data_source(pinfo, data_tvb, "Assembled entity body"); } if (have_entire_body && si->content_encoding != NULL && g_ascii_strcasecmp(si->content_encoding, "identity") != 0) { /* * We currently can't handle, for example, "compress"; * just handle them as data for now. * * After July 7, 2004 the LZW patent expires, so support * might be added then. However, I don't think that * anybody ever really implemented "compress", due to * the aforementioned patent. */ tvbuff_t *uncomp_tvb = NULL; proto_item *e_ti = NULL; proto_tree *e_tree = NULL; if (spdy_decompress_body && (g_ascii_strcasecmp(si->content_encoding, "gzip") == 0 || g_ascii_strcasecmp(si->content_encoding, "deflate") == 0)) { uncomp_tvb = tvb_child_uncompress(tvb, data_tvb, 0, tvb_reported_length(data_tvb)); } /* * Add the encoded entity to the protocol tree */ e_tree = proto_tree_add_subtree_format(spdy_tree, data_tvb, 0, tvb_reported_length(data_tvb), ett_spdy_encoded_entity, &e_ti, "Content-encoded entity body (%s): %u bytes", si->content_encoding, tvb_reported_length(data_tvb)); if (si->num_data_frames > 1) { wmem_list_t *dflist = si->data_frames; wmem_list_frame_t *frame_item; spdy_data_frame_t *df; guint32 framenum = 0; wmem_strbuf_t *str_frames = wmem_strbuf_new(wmem_packet_scope(), ""); frame_item = wmem_list_frame_next(wmem_list_head(dflist)); while (frame_item != NULL) { df = (spdy_data_frame_t *)wmem_list_frame_data(frame_item); if (framenum != df->framenum) { wmem_strbuf_append_printf(str_frames, " #%u", df->framenum); framenum = df->framenum; } frame_item = wmem_list_frame_next(frame_item); } proto_tree_add_expert_format(e_tree, pinfo, &ei_spdy_reassembly_info, data_tvb, 0, tvb_reported_length(data_tvb), "Assembled from %d frames in packet(s)%s", si->num_data_frames, wmem_strbuf_get_str(str_frames)); } if (uncomp_tvb != NULL) { /* * Decompression worked */ /* XXX - Don't free this, since it's possible * that the data was only partially * decompressed, such as when desegmentation * isn't enabled. * tvb_free(next_tvb); */ proto_item_append_text(e_ti, " -> %u bytes", tvb_reported_length(uncomp_tvb)); data_tvb = uncomp_tvb; add_new_data_source(pinfo, data_tvb, "Uncompressed entity body"); } else { if (spdy_decompress_body) { proto_item_append_text(e_ti, " [Error: Decompression failed]"); } call_dissector(data_handle, data_tvb, pinfo, e_tree); goto body_dissected; } } /* * Do subdissector checks. * * First, check whether some subdissector asked that they * be called if something was on some particular port. */ if (have_entire_body && port_subdissector_table != NULL) { handle = dissector_get_uint_handle(port_subdissector_table, pinfo->match_uint); } else { handle = NULL; } if (handle == NULL && have_entire_body && si->content_type != NULL && media_type_subdissector_table != NULL) { /* * We didn't find any subdissector that * registered for the port, and we have a * Content-Type value. Is there any subdissector * for that content type? */ if (si->content_type_parameters) { media_str = wmem_strdup(wmem_packet_scope(), si->content_type_parameters); } /* * Calling the string handle for the media type * dissector table will set pinfo->match_string * to si->content_type for us. */ pinfo->match_string = si->content_type; handle = dissector_get_string_handle(media_type_subdissector_table, si->content_type); } if (handle != NULL) { /* * We have a subdissector - call it. */ dissected = call_dissector_with_data(handle, data_tvb, pinfo, spdy_tree, media_str); } else { dissected = FALSE; } if (!dissected && have_entire_body && si->content_type != NULL) { /* * Calling the default media handle if there is a content-type that * wasn't handled above. */ call_dissector_with_data(media_handle, next_tvb, pinfo, spdy_tree, media_str); } else { /* Call the default data dissector */ call_dissector(data_handle, next_tvb, pinfo, spdy_tree); } body_dissected: /* * We've processed frame->length bytes worth of data * (which may be no data at all); advance the * offset past whatever data we've processed. */ ; } return frame->length; } #ifdef HAVE_LIBZ /* * Performs header decompression. * * The returned buffer is automatically scoped to the lifetime of the capture * (via wmem_memdup() with file scope). */ #define DECOMPRESS_BUFSIZE 16384 static guint8* spdy_decompress_header_block(tvbuff_t *tvb, z_streamp decomp, uLong dictionary_id, int offset, guint32 length, guint *uncomp_length) { int retcode; const guint8 *hptr = tvb_get_ptr(tvb, offset, length); guint8 *uncomp_block = (guint8 *)wmem_alloc(wmem_packet_scope(), DECOMPRESS_BUFSIZE); decomp->next_in = (Bytef *)hptr; decomp->avail_in = length; decomp->next_out = uncomp_block; decomp->avail_out = DECOMPRESS_BUFSIZE; retcode = inflate(decomp, Z_SYNC_FLUSH); if (retcode == Z_NEED_DICT) { if (decomp->adler == dictionary_id) { retcode = inflateSetDictionary(decomp, spdy_dictionary, sizeof(spdy_dictionary)); if (retcode == Z_OK) { retcode = inflate(decomp, Z_SYNC_FLUSH); } } } /* Handle errors. */ if (retcode != Z_OK) { return NULL; } /* Handle successful inflation. */ *uncomp_length = DECOMPRESS_BUFSIZE - decomp->avail_out; return (guint8 *)wmem_memdup(wmem_file_scope(), uncomp_block, *uncomp_length); } #endif /* * Saves state on header data for a given stream. */ static spdy_header_info_t* spdy_save_header_block(packet_info *pinfo _U_, guint32 stream_id, guint16 frame_type, guint8 *header, guint length) { spdy_header_info_t *header_info; if (header_info_list == NULL) header_info_list = wmem_list_new(wmem_file_scope()); header_info = wmem_new(wmem_file_scope(), spdy_header_info_t); header_info->stream_id = stream_id; header_info->header_block = header; header_info->header_block_len = length; header_info->frame_type = frame_type; wmem_list_append(header_info_list, header_info); return header_info; } /* * Retrieves saved state for a given stream. */ static spdy_header_info_t* spdy_find_saved_header_block(packet_info *pinfo _U_, guint32 stream_id, guint16 frame_type) { wmem_list_frame_t *frame; if ((header_info_list == NULL) || (wmem_list_head(header_info_list) == NULL)) return NULL; frame = wmem_list_frame_next(wmem_list_head(header_info_list)); while (frame != NULL) { spdy_header_info_t *hi = (spdy_header_info_t *)wmem_list_frame_data(frame); if (hi->stream_id == stream_id && hi->frame_type == frame_type) return hi; frame = wmem_list_frame_next(frame); } return NULL; } /* * Given a content type string that may contain optional parameters, * return the parameter string, if any, otherwise return NULL. This * also has the side effect of null terminating the content type * part of the original string. */ static gchar* spdy_parse_content_type(gchar *content_type) { gchar *cp = content_type; while (*cp != '\0' && *cp != ';' && !g_ascii_isspace(*cp)) { *cp = g_ascii_tolower(*cp); ++cp; } if (*cp == '\0') { cp = NULL; } if (cp != NULL) { *cp++ = '\0'; while (*cp == ';' || g_ascii_isspace(*cp)) { ++cp; } if (*cp != '\0') { return cp; } } return NULL; } static int dissect_spdy_header_payload( tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *frame_tree, const spdy_control_frame_info_t *frame, spdy_conv_t *conv_data) { guint32 stream_id; int header_block_length = frame->length; int hdr_offset = 0; tvbuff_t *header_tvb = NULL; const gchar *hdr_method = NULL; const gchar *hdr_path = NULL; const gchar *hdr_version = NULL; const gchar *hdr_host = NULL; const gchar *hdr_scheme = NULL; const gchar *hdr_status = NULL; gchar *content_type = NULL; gchar *content_encoding = NULL; guint32 num_headers = 0; proto_item *header_block_item; proto_tree *header_block_tree; /* Get stream id, which is present in all types of header frames. */ stream_id = tvb_get_ntohl(tvb, offset) & SPDY_STREAM_ID_MASK; dissect_spdy_stream_id_field(tvb, offset, pinfo, frame_tree, hf_spdy_streamid); offset += 4; /* Get SYN_STREAM-only fields. */ if (frame->type == SPDY_SYN_STREAM) { /* Get associated stream ID. */ dissect_spdy_stream_id_field(tvb, offset, pinfo, frame_tree, hf_spdy_associated_streamid); offset += 4; /* Get priority */ proto_tree_add_item(frame_tree, hf_spdy_priority, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(frame_tree, hf_spdy_unused, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(frame_tree, hf_spdy_slot, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; } /* Get our header block length. */ switch (frame->type) { case SPDY_SYN_STREAM: header_block_length -= 10; break; case SPDY_SYN_REPLY: case SPDY_HEADERS: header_block_length -= 4; break; default: /* Unhandled case. This should never happen. */ DISSECTOR_ASSERT_NOT_REACHED(); } /* Add the header block. */ header_block_item = proto_tree_add_item(frame_tree, hf_spdy_header_block, tvb, offset, header_block_length, ENC_NA); header_block_tree = proto_item_add_subtree(header_block_item, ett_spdy_header_block); /* Decompress header block as necessary. */ if (!spdy_decompress_headers) { header_tvb = tvb; hdr_offset = offset; } else { spdy_header_info_t *header_info; /* First attempt to find previously decompressed data. * This will not work correctly for lower-level frames that contain more * than one SPDY frame of the same type. We assume this to never be the * case, though. */ header_info = spdy_find_saved_header_block(pinfo, stream_id, frame->type); /* Generate decompressed data and store it, since none was found. */ if (header_info == NULL) { guint8 *uncomp_ptr = NULL; guint uncomp_length = 0; #ifdef HAVE_LIBZ z_streamp decomp; /* Get our decompressor. */ if (stream_id % 2 == 0) { /* Even streams are server-initiated and should never get a * client-initiated header block. Use reply decompressor. */ decomp = conv_data->rply_decompressor; } else if (frame->type == SPDY_HEADERS) { /* Odd streams are client-initiated, but may have HEADERS from either * side. Currently, no known clients send HEADERS so we assume they are * all from the server. */ decomp = conv_data->rply_decompressor; } else if (frame->type == SPDY_SYN_STREAM) { decomp = conv_data->rqst_decompressor; } else if (frame->type == SPDY_SYN_REPLY) { decomp = conv_data->rply_decompressor; } else { /* Unhandled case. This should never happen. */ DISSECTOR_ASSERT_NOT_REACHED(); } /* Decompress. */ uncomp_ptr = spdy_decompress_header_block(tvb, decomp, conv_data->dictionary_id, offset, header_block_length, &uncomp_length); /* Catch decompression failures. */ if (uncomp_ptr == NULL) { expert_add_info(pinfo, frame_tree, &ei_spdy_inflation_failed); proto_item_append_text(frame_tree, " [Error: Header decompression failed]"); return -1; } #endif /* Store decompressed data. */ header_info = spdy_save_header_block(pinfo, stream_id, frame->type, uncomp_ptr, uncomp_length); } /* Create a tvb containing the uncompressed data. */ header_tvb = tvb_new_child_real_data(tvb, header_info->header_block, header_info->header_block_len, header_info->header_block_len); add_new_data_source(pinfo, header_tvb, "Uncompressed headers"); hdr_offset = 0; } /* Get header block details. */ if (header_tvb == NULL || !spdy_decompress_headers) { num_headers = 0; } else { num_headers = tvb_get_ntohl(header_tvb, hdr_offset); /*ti = */ proto_tree_add_item(header_block_tree, hf_spdy_num_headers, header_tvb, hdr_offset, 4, ENC_BIG_ENDIAN); } hdr_offset += 4; /* Process headers. */ while (num_headers--) { gchar *header_name; const gchar *header_value; proto_tree *header_tree; proto_item *header; int header_name_offset; int header_value_offset; int header_name_length; int header_value_length; /* Get header name details. */ if (tvb_reported_length_remaining(header_tvb, hdr_offset) < 4) { expert_add_info_format(pinfo, frame_tree, &ei_spdy_mal_frame_data, "Not enough frame data for header name size."); break; } header_name_offset = hdr_offset; header_name_length = tvb_get_ntohl(header_tvb, hdr_offset); hdr_offset += 4; if (tvb_reported_length_remaining(header_tvb, hdr_offset) < header_name_length) { expert_add_info_format(pinfo, frame_tree, &ei_spdy_mal_frame_data, "Not enough frame data for header name."); break; } header_name = (gchar *)tvb_get_string_enc(wmem_packet_scope(), header_tvb, hdr_offset, header_name_length, ENC_ASCII|ENC_NA); hdr_offset += header_name_length; /* Get header value details. */ if (tvb_reported_length_remaining(header_tvb, hdr_offset) < 4) { expert_add_info_format(pinfo, frame_tree, &ei_spdy_mal_frame_data, "Not enough frame data for header value size."); break; } header_value_offset = hdr_offset; header_value_length = tvb_get_ntohl(header_tvb, hdr_offset); hdr_offset += 4; if (tvb_reported_length_remaining(header_tvb, hdr_offset) < header_value_length) { expert_add_info_format(pinfo, frame_tree, &ei_spdy_mal_frame_data, "Not enough frame data for header value."); break; } header_value = (gchar *)tvb_get_string_enc(wmem_packet_scope(),header_tvb, hdr_offset, header_value_length, ENC_ASCII|ENC_NA); hdr_offset += header_value_length; /* Populate tree with header name/value details. */ if (frame_tree) { /* Add 'Header' subtree with description. */ header = proto_tree_add_item(frame_tree, hf_spdy_header, header_tvb, header_name_offset, hdr_offset - header_name_offset, ENC_NA); proto_item_append_text(header, ": %s: %s", header_name, header_value); header_tree = proto_item_add_subtree(header, ett_spdy_header); /* Add header name. */ proto_tree_add_item(header_tree, hf_spdy_header_name, header_tvb, header_name_offset, 4, ENC_ASCII|ENC_BIG_ENDIAN); /* Add header value. */ proto_tree_add_item(header_tree, hf_spdy_header_value, header_tvb, header_value_offset, 4, ENC_ASCII|ENC_BIG_ENDIAN); } /* * TODO(ers) check that the header name contains only legal characters. */ /* TODO(hkhalil): Make sure that prohibited headers aren't sent. */ if (g_strcmp0(header_name, ":method") == 0) { hdr_method = header_value; } else if (g_strcmp0(header_name, ":path") == 0) { hdr_path = header_value; } else if (g_strcmp0(header_name, ":version") == 0) { hdr_version = header_value; } else if (g_strcmp0(header_name, ":host") == 0) { hdr_host = header_value; } else if (g_strcmp0(header_name, ":scheme") == 0) { hdr_scheme = header_value; } else if (g_strcmp0(header_name, ":status") == 0) { hdr_status = header_value; } else if (g_strcmp0(header_name, "content-type") == 0) { content_type = wmem_strdup(wmem_file_scope(), header_value); } else if (g_strcmp0(header_name, "content-encoding") == 0) { content_encoding = wmem_strdup(wmem_file_scope(), header_value); } } /* Set Info column. */ if (hdr_version != NULL) { if (hdr_status == NULL) { proto_item_append_text(frame_tree, ", Request: %s %s://%s%s %s", hdr_method, hdr_scheme, hdr_host, hdr_path, hdr_version); } else { proto_item_append_text(frame_tree, ", Response: %s %s", hdr_status, hdr_version); } } /* * If we expect data on this stream, we need to remember the content * type and content encoding. */ if (content_type != NULL && !pinfo->fd->flags.visited) { gchar *content_type_params = spdy_parse_content_type(content_type); spdy_save_stream_info(conv_data, stream_id, content_type, content_type_params, content_encoding); } return frame->length; } static int dissect_spdy_rst_stream_payload( tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *frame_tree, const spdy_control_frame_info_t *frame) { guint32 rst_status; proto_item *ti; const char* str; /* Get stream ID and add to info column and tree. */ dissect_spdy_stream_id_field(tvb, offset, pinfo, frame_tree, hf_spdy_streamid); offset += 4; /* Get status. */ ti = proto_tree_add_item(frame_tree, hf_spdy_rst_stream_status, tvb, offset, 4, ENC_BIG_ENDIAN); rst_status = tvb_get_ntohl(tvb, offset); if (try_val_to_str(rst_status, rst_stream_status_names) == NULL) { /* Handle boundary conditions. */ expert_add_info_format(pinfo, ti, &ei_spdy_invalid_rst_stream, "Invalid status code for RST_STREAM: %u", rst_status); } str = val_to_str(rst_status, rst_stream_status_names, "Unknown (%d)"); proto_item_append_text(frame_tree, ", Status: %s", str); return frame->length; } static int dissect_spdy_settings_payload( tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *frame_tree, const spdy_control_frame_info_t *frame) { guint32 num_entries; proto_item *ti, *ti_setting; proto_tree *setting_tree; proto_tree *flags_tree; /* Make sure that we have enough room for our number of entries field. */ if (frame->length < 4) { expert_add_info(pinfo, frame_tree, &ei_spdy_mal_setting_frame); return -1; } /* Get number of entries, and make sure we have enough room for them. */ num_entries = tvb_get_ntohl(tvb, offset); if (frame->length < num_entries * 8) { expert_add_info_format(pinfo, frame_tree, &ei_spdy_mal_setting_frame, "SETTINGS frame too small [num_entries=%d]", num_entries); return -1; } proto_tree_add_item(frame_tree, hf_spdy_num_settings, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; /* Dissect each entry. */ while (num_entries > 0) { const gchar *setting_id_str; guint32 setting_value; /* Create key/value pair subtree. */ ti_setting = proto_tree_add_item(frame_tree, hf_spdy_setting, tvb, offset, 8, ENC_NA); setting_tree = proto_item_add_subtree(ti_setting, ett_spdy_setting); /* Set flags. */ if (setting_tree) { ti = proto_tree_add_item(setting_tree, hf_spdy_flags, tvb, offset, 1, ENC_BIG_ENDIAN); /* TODO(hkhalil): Prettier output for flags sub-tree description. */ flags_tree = proto_item_add_subtree(ti, ett_spdy_flags); proto_tree_add_item(flags_tree, hf_spdy_flags_persist_value, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(flags_tree, hf_spdy_flags_persisted, tvb, offset, 1, ENC_BIG_ENDIAN); } offset += 1; /* Set ID. */ setting_id_str = val_to_str(tvb_get_ntoh24(tvb, offset), setting_id_names, "Unknown(%d)"); proto_tree_add_item(setting_tree, hf_spdy_setting_id, tvb, offset, 3, ENC_BIG_ENDIAN); offset += 3; /* Set Value. */ setting_value = tvb_get_ntohl(tvb, offset); proto_tree_add_item(setting_tree, hf_spdy_setting_value, tvb, offset, 4, ENC_BIG_ENDIAN); proto_item_append_text(ti_setting, ", %s: %u", setting_id_str, setting_value); proto_item_append_text(frame_tree, ", %s: %u", setting_id_str, setting_value); offset += 4; /* Increment. */ --num_entries; } return frame->length; } static int dissect_spdy_ping_payload(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *frame_tree, const spdy_control_frame_info_t *frame) { /* Get ping ID. */ guint32 ping_id = tvb_get_ntohl(tvb, offset); /* Add proto item for ping ID. */ proto_tree_add_item(frame_tree, hf_spdy_ping_id, tvb, offset, 4, ENC_BIG_ENDIAN); proto_item_append_text(frame_tree, ", ID: %u", ping_id); return frame->length; } static int dissect_spdy_goaway_payload(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *frame_tree, const spdy_control_frame_info_t *frame) { guint32 goaway_status; proto_item* ti; /* Get last good stream ID and add to info column and tree. */ dissect_spdy_stream_id_field(tvb, offset, pinfo, frame_tree, hf_spdy_goaway_last_good_stream_id); offset += 4; /* Add proto item for goaway_status. */ ti = proto_tree_add_item(frame_tree, hf_spdy_goaway_status, tvb, offset, 4, ENC_BIG_ENDIAN); goaway_status = tvb_get_ntohl(tvb, offset); if (try_val_to_str(goaway_status, goaway_status_names) == NULL) { /* Handle boundary conditions. */ expert_add_info_format(pinfo, ti, &ei_spdy_invalid_go_away, "Invalid status code for GOAWAY: %u", goaway_status); } /* Add status to info column. */ proto_item_append_text(frame_tree, " Status=%s)", val_to_str(goaway_status, rst_stream_status_names, "Unknown (%d)")); return frame->length; } static int dissect_spdy_window_update_payload( tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *frame_tree, const spdy_control_frame_info_t *frame) { guint32 window_update_delta; /* Get stream ID. */ dissect_spdy_stream_id_field(tvb, offset, pinfo, frame_tree, hf_spdy_streamid); offset += 4; /* Get window update delta. */ window_update_delta = tvb_get_ntohl(tvb, offset) & 0x7FFFFFFF; /* Add proto item for window update delta. */ proto_tree_add_item(frame_tree, hf_spdy_window_update_delta, tvb, offset, 4, ENC_BIG_ENDIAN); proto_item_append_text(frame_tree, ", Delta: %u", window_update_delta); return frame->length; } /* * Performs SPDY frame dissection. */ static int dissect_spdy_frame(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { guint8 control_bit; spdy_control_frame_info_t frame; guint32 stream_id = 0; const gchar *frame_type_name; proto_tree *spdy_tree; proto_item *spdy_item, *type_item = NULL; int offset = 0; spdy_conv_t *conv_data; conv_data = get_or_create_spdy_conversation_data(pinfo); col_set_str(pinfo->cinfo, COL_PROTOCOL, "SPDY"); /* Create frame root. */ spdy_item = proto_tree_add_item(tree, proto_spdy, tvb, offset, -1, ENC_NA); spdy_tree = proto_item_add_subtree(spdy_item, ett_spdy); /* Add control bit. */ control_bit = tvb_get_guint8(tvb, offset) & 0x80; proto_tree_add_item(spdy_tree, hf_spdy_control_bit, tvb, offset, 2, ENC_NA); /* Process first four bytes of frame, formatted depending on control bit. */ if (control_bit) { /* Add version. */ frame.version = tvb_get_ntohs(tvb, offset) & 0x7FFF; proto_tree_add_item(spdy_tree, hf_spdy_version, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; /* Add control frame type. */ type_item = proto_tree_add_item(spdy_tree, hf_spdy_type, tvb, offset, 2, ENC_BIG_ENDIAN); frame.type = tvb_get_ntohs(tvb, offset); if (frame.type >= SPDY_INVALID) { expert_add_info_format(pinfo, type_item, &ei_spdy_invalid_frame_type, "Invalid SPDY control frame type: %d", frame.type); return -1; } offset += 2; } else { frame.type = SPDY_DATA; frame.version = 0; /* Version doesn't apply to DATA. */ /* Add stream ID. */ stream_id = tvb_get_ntohl(tvb, offset) & SPDY_STREAM_ID_MASK; proto_tree_add_item(spdy_tree, hf_spdy_streamid, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; } /* Add frame info. */ frame_type_name = val_to_str(frame.type, frame_type_names, "Unknown(%d)"); col_append_sep_str(pinfo->cinfo, COL_INFO, ", ", frame_type_name); proto_item_append_text(spdy_tree, ": %s", frame_type_name); /* Add flags. */ frame.flags = tvb_get_guint8(tvb, offset); if (spdy_tree) { dissect_spdy_flags(tvb, offset, spdy_tree, &frame); } offset += 1; /* Add length. */ frame.length = tvb_get_ntoh24(tvb, offset); proto_item_set_len(spdy_item, frame.length + 8); proto_tree_add_item(spdy_tree, hf_spdy_length, tvb, offset, 3, ENC_BIG_ENDIAN); offset += 3; /* * Make sure there's as much data as the frame header says there is. */ if ((guint)tvb_reported_length_remaining(tvb, offset) < frame.length) { expert_add_info_format(pinfo, tree, &ei_spdy_mal_frame_data, "Not enough frame data: %d vs. %d", frame.length, tvb_reported_length_remaining(tvb, offset)); return -1; } /* Dissect DATA payload as necessary. */ if (!control_bit) { return offset + dissect_spdy_data_payload(tvb, offset, pinfo, tree, spdy_tree, spdy_item, conv_data, stream_id, &frame); } /* Abort here if the version is too low. */ if (frame.version < MIN_SPDY_VERSION) { proto_item_append_text(spdy_item, " [Unsupported Version]"); return frame.length + 8; } switch (frame.type) { case SPDY_SYN_STREAM: case SPDY_SYN_REPLY: case SPDY_HEADERS: dissect_spdy_header_payload(tvb, offset, pinfo, spdy_tree, &frame, conv_data); break; case SPDY_RST_STREAM: dissect_spdy_rst_stream_payload(tvb, offset, pinfo, spdy_tree, &frame); break; case SPDY_SETTINGS: dissect_spdy_settings_payload(tvb, offset, pinfo, spdy_tree, &frame); break; case SPDY_PING: dissect_spdy_ping_payload(tvb, offset, pinfo, spdy_tree, &frame); break; case SPDY_GOAWAY: dissect_spdy_goaway_payload(tvb, offset, pinfo, spdy_tree, &frame); break; case SPDY_WINDOW_UPDATE: dissect_spdy_window_update_payload(tvb, offset, pinfo, spdy_tree, &frame); break; case SPDY_CREDENTIAL: /* TODO(hkhalil): Show something meaningful. */ break; default: expert_add_info_format(pinfo, type_item, &ei_spdy_invalid_frame_type, "Unhandled SPDY frame type: %d", frame.type); break; } /* * OK, we've set the Protocol and Info columns for the * first SPDY message; set a fence so that subsequent * SPDY messages don't overwrite the Info column. */ col_set_fence(pinfo->cinfo, COL_INFO); /* Assume that we've consumed the whole frame. */ return 8 + frame.length; } static guint get_spdy_message_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_) { return (guint)tvb_get_ntoh24(tvb, offset + 5) + 8; } /* * Wrapper for dissect_spdy_frame, sets fencing and desegments as necessary. */ static int dissect_spdy(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) { col_clear(pinfo->cinfo, COL_INFO); tcp_dissect_pdus(tvb, pinfo, tree, TRUE, 8, get_spdy_message_len, dissect_spdy_frame, data); return tvb_captured_length(tvb); } /* * Looks for SPDY frame at tvb start. * If not enough data for either, requests more via desegment struct. */ static gboolean dissect_spdy_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) { /* * The first byte of a SPDY frame must be either 0 or * 0x80. If it's not, assume that this is not SPDY. * (In theory, a data frame could have a stream ID * >= 2^24, in which case it won't have 0 for a first * byte, but this is a pretty reliable heuristic for * now.) */ guint8 first_byte = tvb_get_guint8(tvb, 0); if (first_byte != 0x80 && first_byte != 0x0) { return FALSE; } /* Attempt dissection. */ if (dissect_spdy(tvb, pinfo, tree, NULL) != 0) { return TRUE; } return FALSE; } /* * Performs plugin registration. */ void proto_register_spdy(void) { static hf_register_info hf[] = { { &hf_spdy_data, { "Data", "spdy.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_control_bit, { "Control frame", "spdy.control_bit", FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x8000, "TRUE if SPDY control frame", HFILL } }, { &hf_spdy_version, { "Version", "spdy.version", FT_UINT16, BASE_DEC, NULL, 0x7FFF, NULL, HFILL } }, { &hf_spdy_type, { "Type", "spdy.type", FT_UINT16, BASE_DEC, VALS(frame_type_names), 0x0, NULL, HFILL } }, { &hf_spdy_flags, { "Flags", "spdy.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_flags_fin, { "FIN", "spdy.flags.fin", FT_BOOLEAN, 8, TFS(&tfs_set_notset), SPDY_FLAG_FIN, NULL, HFILL } }, { &hf_spdy_flags_unidirectional, { "Unidirectional", "spdy.flags.fin", FT_BOOLEAN, 8, TFS(&tfs_set_notset), SPDY_FLAG_UNIDIRECTIONAL, NULL, HFILL } }, { &hf_spdy_flags_clear_settings, { "Persist Value", "spdy.flags.clear_settings", FT_BOOLEAN, 8, TFS(&tfs_set_notset), SPDY_FLAG_SETTINGS_CLEAR_SETTINGS, NULL, HFILL } }, { &hf_spdy_flags_persist_value, { "Persist Value", "spdy.flags.persist_value", FT_BOOLEAN, 8, TFS(&tfs_set_notset), SPDY_FLAG_SETTINGS_PERSIST_VALUE, NULL, HFILL } }, { &hf_spdy_flags_persisted, { "Persisted", "spdy.flags.persisted", FT_BOOLEAN, 8, TFS(&tfs_set_notset), SPDY_FLAG_SETTINGS_PERSISTED, NULL, HFILL } }, { &hf_spdy_length, { "Length", "spdy.length", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_header_block, { "Header block", "spdy.header_block", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_header, { "Header", "spdy.header", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_header_name, { "Name", "spdy.header.name", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_header_value, { "Value", "spdy.header.value", FT_UINT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_streamid, { "Stream ID", "spdy.streamid", FT_UINT32, BASE_DEC, NULL, SPDY_STREAM_ID_MASK, NULL, HFILL } }, { &hf_spdy_associated_streamid, { "Associated Stream ID", "spdy.associated.streamid", FT_UINT32, BASE_DEC, NULL, SPDY_STREAM_ID_MASK, NULL, HFILL } }, { &hf_spdy_priority, { "Priority", "spdy.priority", FT_UINT16, BASE_DEC, NULL, 0xE000, NULL, HFILL } }, { &hf_spdy_unused, { "Unused", "spdy.unused", FT_UINT16, BASE_HEX, NULL, 0x1F00, "Reserved for future use", HFILL } }, { &hf_spdy_slot, { "Slot", "spdy.slot", FT_UINT16, BASE_DEC, NULL, 0x00FF, "Specifying the index in the server's CREDENTIAL vector of the client certificate to be used for this reques", HFILL } }, { &hf_spdy_num_headers, { "Number of headers", "spdy.numheaders", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_rst_stream_status, { "Reset Status", "spdy.rst_stream_status", FT_UINT32, BASE_DEC, VALS(rst_stream_status_names), 0x0, NULL, HFILL } }, { &hf_spdy_num_settings, { "Number of Settings", "spdy.num_settings", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_setting, { "Setting", "spdy.setting", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_setting_id, { "ID", "spdy.setting.id", FT_UINT24, BASE_DEC, VALS(setting_id_names), 0x0, NULL, HFILL } }, { &hf_spdy_setting_value, { "Value", "spdy.setting.value", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_ping_id, { "Ping ID", "spdy.ping_id", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_spdy_goaway_last_good_stream_id, { "Last Good Stream ID", "spdy.goaway_last_good_stream_id", FT_UINT32, BASE_DEC, NULL, SPDY_STREAM_ID_MASK, NULL, HFILL } }, { &hf_spdy_goaway_status, { "Go Away Status", "spdy.goaway_status", FT_UINT32, BASE_DEC, VALS(goaway_status_names), 0x0, NULL, HFILL } }, { &hf_spdy_window_update_delta, { "Window Update Delta", "spdy.window_update_delta", FT_UINT32, BASE_DEC, NULL, 0x7FFFFFFF, NULL, HFILL } }, }; static gint *ett[] = { &ett_spdy, &ett_spdy_flags, &ett_spdy_header_block, &ett_spdy_header, &ett_spdy_setting, &ett_spdy_encoded_entity, }; static ei_register_info ei[] = { { &ei_spdy_inflation_failed, { "spdy.inflation_failed", PI_UNDECODED, PI_ERROR, "Inflation failed. Aborting.", EXPFILL }}, { &ei_spdy_mal_frame_data, { "spdy.malformed.frame_data", PI_MALFORMED, PI_ERROR, "Not enough frame data", EXPFILL }}, { &ei_spdy_mal_setting_frame, { "spdy.malformed.setting_frame", PI_MALFORMED, PI_ERROR, "SETTINGS frame too small for number of entries field.", EXPFILL }}, { &ei_spdy_invalid_rst_stream, { "spdy.rst_stream.invalid", PI_PROTOCOL, PI_WARN, "Invalid status code for RST_STREAM", EXPFILL }}, { &ei_spdy_invalid_go_away, { "spdy.goaway.invalid", PI_PROTOCOL, PI_WARN, "Invalid status code for GOAWAY", EXPFILL }}, { &ei_spdy_invalid_frame_type, { "spdy.type.invalid", PI_PROTOCOL, PI_WARN, "Invalid SPDY frame type", EXPFILL }}, { &ei_spdy_reassembly_info, { "spdy.reassembly_info", PI_REASSEMBLE, PI_CHAT, "Assembled from frames in packet(s)", EXPFILL }}, }; module_t *spdy_module; expert_module_t* expert_spdy; proto_spdy = proto_register_protocol("SPDY", "SPDY", "spdy"); proto_register_field_array(proto_spdy, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); expert_spdy = expert_register_protocol(proto_spdy); expert_register_field_array(expert_spdy, ei, array_length(ei)); register_dissector("spdy", dissect_spdy, proto_spdy); spdy_module = prefs_register_protocol(proto_spdy, NULL); prefs_register_bool_preference(spdy_module, "assemble_data_frames", "Assemble SPDY bodies that consist of multiple DATA frames", "Whether the SPDY dissector should reassemble multiple " "data frames into an entity body.", &spdy_assemble_entity_bodies); prefs_register_bool_preference(spdy_module, "decompress_headers", "Uncompress SPDY headers", "Whether to uncompress SPDY headers.", &spdy_decompress_headers); prefs_register_bool_preference(spdy_module, "decompress_body", "Uncompress entity bodies", "Whether to uncompress entity bodies that are compressed " "using \"Content-Encoding: \"", &spdy_decompress_body); /** Create dissector handle and register for dissection. */ spdy_handle = create_dissector_handle(dissect_spdy, proto_spdy); register_init_routine(&spdy_init_protocol); /* * Register for tapping */ spdy_tap = register_tap("spdy"); /* SPDY statistics tap */ spdy_eo_tap = register_tap("spdy_eo"); /* SPDY Export Object tap */ } void proto_reg_handoff_spdy(void) { dissector_add_uint("tcp.port", TCP_PORT_SPDY, spdy_handle); /* Use "0" to avoid overwriting HTTPS port and still offer support over SSL */ ssl_dissector_add(0, spdy_handle); data_handle = find_dissector("data"); media_handle = find_dissector("media"); port_subdissector_table = find_dissector_table("http.port"); media_type_subdissector_table = find_dissector_table("media_type"); /* Weak heuristic, so disabled by default */ heur_dissector_add("tcp", dissect_spdy_heur, "SPDY over TCP", "spdy_tcp", proto_spdy, HEURISTIC_DISABLE); } /* * Editor modelines * * Local Variables: * c-basic-offset: 2 * tab-width: 8 * indent-tabs-mode: nil * End: * * ex: set shiftwidth=2 tabstop=8 expandtab: * :indentSize=4:tabSize=8:noTabs=true: */