osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity
wireshark/epan/dissectors/packet-spdy.c

1968 lines
70 KiB
C
Raw Blame History

/* 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 <hkhalil@google.com>
* Chris Bentzel <cbentzel@google.com>
* Eric Shienbrood <ers@google.com>
*
* Copyright 2013-2014
* Alexis La Goutte <alexis.lagoutte@gmail.com>
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* 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 <epan/packet.h>
#include <epan/prefs.h>
#include <epan/expert.h>
#include <epan/tap.h>
#include "packet-tcp.h"
#include "packet-ssl.h"
#ifdef HAVE_ZLIB
#define ZLIB_CONST
#include <zlib.h>
#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_ZLIB
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 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_ZLIB
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_ZLIB
/* 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_ZLIB
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_ZLIB
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 conversation/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->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_data_dissector(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_data_dissector(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_ZLIB
/*
* 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);
#ifdef z_const
decomp->next_in = (z_const Bytef *)hptr;
#else
DIAG_OFF(cast-qual)
decomp->next_in = (Bytef *)hptr;
DIAG_ON(cast-qual)
#endif
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_ZLIB
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));
spdy_handle = 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);
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);
media_handle = find_dissector_add_dependency("media", proto_spdy);
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:
*/
View Git Blame Copy Permalink