1 /* packet-spdy.c 2 * Routines for SPDY packet disassembly 3 * For now, the protocol spec can be found at 4 * http://dev.chromium.org/spdy/spdy-protocol 5 * 6 * Copyright 2010, Google Inc. 7 * Eric Shienbrood <ers (at) google.com> 8 * 9 * $Id$ 10 * 11 * Wireshark - Network traffic analyzer 12 * By Gerald Combs <gerald (at) wireshark.org> 13 * Copyright 1998 Gerald Combs 14 * 15 * Originally based on packet-http.c 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License 19 * as published by the Free Software Foundation; either version 2 20 * of the License, or (at your option) any later version. 21 * 22 * This program is distributed in the hope that it will be useful, 23 * but WITHOUT ANY WARRANTY; without even the implied warranty of 24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 * GNU General Public License for more details. 26 * 27 * You should have received a copy of the GNU General Public License 28 * along with this program; if not, write to the Free Software 29 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 30 */ 31 32 #ifdef HAVE_CONFIG_H 33 #include "config.h" 34 #endif 35 36 #include <string.h> 37 #include <ctype.h> 38 39 #include <glib.h> 40 #include <epan/conversation.h> 41 #include <epan/packet.h> 42 #include <epan/strutil.h> 43 #include <epan/base64.h> 44 #include <epan/emem.h> 45 #include <epan/stats_tree.h> 46 47 #include <epan/req_resp_hdrs.h> 48 #include "packet-spdy.h" 49 #include <epan/dissectors/packet-tcp.h> 50 #include <epan/dissectors/packet-ssl.h> 51 #include <epan/prefs.h> 52 #include <epan/expert.h> 53 #include <epan/uat.h> 54 55 #define SPDY_FIN 0x01 56 57 /* The types of SPDY control frames */ 58 typedef enum _spdy_type { 59 SPDY_DATA, 60 SPDY_SYN_STREAM, 61 SPDY_SYN_REPLY, 62 SPDY_FIN_STREAM, 63 SPDY_HELLO, 64 SPDY_NOOP, 65 SPDY_PING, 66 SPDY_INVALID 67 } spdy_frame_type_t; 68 69 static const char *frame_type_names[] = { 70 "DATA", "SYN_STREAM", "SYN_REPLY", "FIN_STREAM", "HELLO", "NOOP", 71 "PING", "INVALID" 72 }; 73 74 /* 75 * This structure will be tied to each SPDY frame. 76 * Note that there may be multiple SPDY frames 77 * in one packet. 78 */ 79 typedef struct _spdy_frame_info_t { 80 guint32 stream_id; 81 guint8 *header_block; 82 guint header_block_len; 83 guint16 frame_type; 84 } spdy_frame_info_t; 85 86 /* 87 * This structures keeps track of all the data frames 88 * associated with a stream, so that they can be 89 * reassembled into a single chunk. 90 */ 91 typedef struct _spdy_data_frame_t { 92 guint8 *data; 93 guint32 length; 94 guint32 framenum; 95 } spdy_data_frame_t; 96 97 typedef struct _spdy_stream_info_t { 98 gchar *content_type; 99 gchar *content_type_parameters; 100 gchar *content_encoding; 101 GSList *data_frames; 102 tvbuff_t *assembled_data; 103 guint num_data_frames; 104 } spdy_stream_info_t; 105 106 #include <epan/tap.h> 107 108 109 static int spdy_tap = -1; 110 static int spdy_eo_tap = -1; 111 112 static int proto_spdy = -1; 113 static int hf_spdy_syn_stream = -1; 114 static int hf_spdy_syn_reply = -1; 115 static int hf_spdy_control_bit = -1; 116 static int hf_spdy_version = -1; 117 static int hf_spdy_type = -1; 118 static int hf_spdy_flags = -1; 119 static int hf_spdy_flags_fin = -1; 120 static int hf_spdy_length = -1; 121 static int hf_spdy_header = -1; 122 static int hf_spdy_header_name = -1; 123 static int hf_spdy_header_name_text = -1; 124 static int hf_spdy_header_value = -1; 125 static int hf_spdy_header_value_text = -1; 126 static int hf_spdy_streamid = -1; 127 static int hf_spdy_associated_streamid = -1; 128 static int hf_spdy_priority = -1; 129 static int hf_spdy_num_headers = -1; 130 static int hf_spdy_num_headers_string = -1; 131 132 static gint ett_spdy = -1; 133 static gint ett_spdy_syn_stream = -1; 134 static gint ett_spdy_syn_reply = -1; 135 static gint ett_spdy_fin_stream = -1; 136 static gint ett_spdy_flags = -1; 137 static gint ett_spdy_header = -1; 138 static gint ett_spdy_header_name = -1; 139 static gint ett_spdy_header_value = -1; 140 141 static gint ett_spdy_encoded_entity = -1; 142 143 static dissector_handle_t data_handle; 144 static dissector_handle_t media_handle; 145 static dissector_handle_t spdy_handle; 146 147 /* Stuff for generation/handling of fields for custom HTTP headers */ 148 typedef struct _header_field_t { 149 gchar* header_name; 150 gchar* header_desc; 151 } header_field_t; 152 153 /* 154 * desegmentation of SPDY control frames 155 * (when we are over TCP or another protocol providing the desegmentation API) 156 */ 157 static gboolean spdy_desegment_control_frames = TRUE; 158 159 /* 160 * desegmentation of SPDY data frames bodies 161 * (when we are over TCP or another protocol providing the desegmentation API) 162 * TODO let the user filter on content-type the bodies he wants desegmented 163 */ 164 static gboolean spdy_desegment_data_frames = TRUE; 165 166 static gboolean spdy_assemble_entity_bodies = TRUE; 167 168 /* 169 * Decompression of zlib encoded entities. 170 */ 171 #ifdef HAVE_LIBZ 172 static gboolean spdy_decompress_body = TRUE; 173 static gboolean spdy_decompress_headers = TRUE; 174 #else 175 static gboolean spdy_decompress_body = FALSE; 176 static gboolean spdy_decompress_headers = FALSE; 177 #endif 178 static gboolean spdy_debug = FALSE; 179 180 #define TCP_PORT_DAAP 3689 181 182 /* 183 * SSDP is implemented atop HTTP (yes, it really *does* run over UDP). 184 */ 185 #define TCP_PORT_SSDP 1900 186 #define UDP_PORT_SSDP 1900 187 188 /* 189 * tcp and ssl ports 190 */ 191 192 #define TCP_DEFAULT_RANGE "80,8080" 193 #define SSL_DEFAULT_RANGE "443" 194 195 static range_t *global_spdy_tcp_range = NULL; 196 static range_t *global_spdy_ssl_range = NULL; 197 198 static range_t *spdy_tcp_range = NULL; 199 static range_t *spdy_ssl_range = NULL; 200 201 static const value_string vals_status_code[] = { 202 { 100, "Continue" }, 203 { 101, "Switching Protocols" }, 204 { 102, "Processing" }, 205 { 199, "Informational - Others" }, 206 207 { 200, "OK"}, 208 { 201, "Created"}, 209 { 202, "Accepted"}, 210 { 203, "Non-authoritative Information"}, 211 { 204, "No Content"}, 212 { 205, "Reset Content"}, 213 { 206, "Partial Content"}, 214 { 207, "Multi-Status"}, 215 { 299, "Success - Others"}, 216 217 { 300, "Multiple Choices"}, 218 { 301, "Moved Permanently"}, 219 { 302, "Found"}, 220 { 303, "See Other"}, 221 { 304, "Not Modified"}, 222 { 305, "Use Proxy"}, 223 { 307, "Temporary Redirect"}, 224 { 399, "Redirection - Others"}, 225 226 { 400, "Bad Request"}, 227 { 401, "Unauthorized"}, 228 { 402, "Payment Required"}, 229 { 403, "Forbidden"}, 230 { 404, "Not Found"}, 231 { 405, "Method Not Allowed"}, 232 { 406, "Not Acceptable"}, 233 { 407, "Proxy Authentication Required"}, 234 { 408, "Request Time-out"}, 235 { 409, "Conflict"}, 236 { 410, "Gone"}, 237 { 411, "Length Required"}, 238 { 412, "Precondition Failed"}, 239 { 413, "Request Entity Too Large"}, 240 { 414, "Request-URI Too Long"}, 241 { 415, "Unsupported Media Type"}, 242 { 416, "Requested Range Not Satisfiable"}, 243 { 417, "Expectation Failed"}, 244 { 418, "I'm a teapot"}, /* RFC 2324 */ 245 { 422, "Unprocessable Entity"}, 246 { 423, "Locked"}, 247 { 424, "Failed Dependency"}, 248 { 499, "Client Error - Others"}, 249 250 { 500, "Internal Server Error"}, 251 { 501, "Not Implemented"}, 252 { 502, "Bad Gateway"}, 253 { 503, "Service Unavailable"}, 254 { 504, "Gateway Time-out"}, 255 { 505, "HTTP Version not supported"}, 256 { 507, "Insufficient Storage"}, 257 { 599, "Server Error - Others"}, 258 259 { 0, NULL} 260 }; 261 262 static const char spdy_dictionary[] = 263 "optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-" 264 "languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi" 265 "f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser" 266 "-agent10010120020120220320420520630030130230330430530630740040140240340440" 267 "5406407408409410411412413414415416417500501502503504505accept-rangesageeta" 268 "glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic" 269 "ateallowcontent-basecontent-encodingcache-controlconnectiondatetrailertran" 270 "sfer-encodingupgradeviawarningcontent-languagecontent-lengthcontent-locati" 271 "oncontent-md5content-rangecontent-typeetagexpireslast-modifiedset-cookieMo" 272 "ndayTuesdayWednesdayThursdayFridaySaturdaySundayJanFebMarAprMayJunJulAugSe" 273 "pOctNovDecchunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplic" 274 "ation/xhtmltext/plainpublicmax-agecharset=iso-8859-1utf-8gzipdeflateHTTP/1" 275 ".1statusversionurl"; 276 277 static void reset_decompressors(void) 278 { 279 if (spdy_debug) printf("Should reset SPDY decompressors\n"); 280 } 281 282 static spdy_conv_t * 283 get_spdy_conversation_data(packet_info *pinfo) 284 { 285 conversation_t *conversation; 286 spdy_conv_t *conv_data; 287 int retcode; 288 289 conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype, pinfo->srcport, pinfo->destport, 0); 290 if (spdy_debug) { 291 printf("\n===========================================\n\n"); 292 printf("Conversation for frame #%d is %p\n", pinfo->fd->num, conversation); 293 if (conversation) 294 printf(" conv_data=%p\n", conversation_get_proto_data(conversation, proto_spdy)); 295 } 296 297 if(!conversation) /* Conversation does not exist yet - create it */ 298 conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype, pinfo->srcport, pinfo->destport, 0); 299 300 /* Retrieve information from conversation 301 */ 302 conv_data = conversation_get_proto_data(conversation, proto_spdy); 303 if(!conv_data) { 304 /* Setup the conversation structure itself */ 305 conv_data = se_alloc0(sizeof(spdy_conv_t)); 306 307 conv_data->streams = NULL; 308 if (spdy_decompress_headers) { 309 conv_data->rqst_decompressor = se_alloc0(sizeof(z_stream)); 310 conv_data->rply_decompressor = se_alloc0(sizeof(z_stream)); 311 retcode = inflateInit(conv_data->rqst_decompressor); 312 if (retcode == Z_OK) 313 retcode = inflateInit(conv_data->rply_decompressor); 314 if (retcode != Z_OK) 315 printf("frame #%d: inflateInit() failed: %d\n", pinfo->fd->num, retcode); 316 else if (spdy_debug) 317 printf("created decompressor\n"); 318 conv_data->dictionary_id = adler32(0L, Z_NULL, 0); 319 conv_data->dictionary_id = adler32(conv_data->dictionary_id, 320 spdy_dictionary, 321 sizeof(spdy_dictionary)); 322 } 323 324 conversation_add_proto_data(conversation, proto_spdy, conv_data); 325 register_postseq_cleanup_routine(reset_decompressors); 326 } 327 return conv_data; 328 } 329 330 static void 331 spdy_save_stream_info(spdy_conv_t *conv_data, 332 guint32 stream_id, 333 gchar *content_type, 334 gchar *content_type_params, 335 gchar *content_encoding) 336 { 337 spdy_stream_info_t *si; 338 339 if (conv_data->streams == NULL) 340 conv_data->streams = g_array_new(FALSE, TRUE, sizeof(spdy_stream_info_t *)); 341 if (stream_id < conv_data->streams->len) 342 DISSECTOR_ASSERT(g_array_index(conv_data->streams, spdy_stream_info_t*, stream_id) == NULL); 343 else 344 g_array_set_size(conv_data->streams, stream_id+1); 345 si = se_alloc(sizeof(spdy_stream_info_t)); 346 si->content_type = content_type; 347 si->content_type_parameters = content_type_params; 348 si->content_encoding = content_encoding; 349 si->data_frames = NULL; 350 si->num_data_frames = 0; 351 si->assembled_data = NULL; 352 g_array_index(conv_data->streams, spdy_stream_info_t*, stream_id) = si; 353 if (spdy_debug) 354 printf("Saved stream info for ID %u, content type %s\n", stream_id, content_type); 355 } 356 357 static spdy_stream_info_t * 358 spdy_get_stream_info(spdy_conv_t *conv_data, guint32 stream_id) 359 { 360 if (conv_data->streams == NULL || stream_id >= conv_data->streams->len) 361 return NULL; 362 else 363 return g_array_index(conv_data->streams, spdy_stream_info_t*, stream_id); 364 } 365 366 static void 367 spdy_add_data_chunk(spdy_conv_t *conv_data, guint32 stream_id, guint32 frame, 368 guint8 *data, guint32 length) 369 { 370 spdy_stream_info_t *si = spdy_get_stream_info(conv_data, stream_id); 371 372 if (si == NULL) { 373 if (spdy_debug) printf("No stream_info found for stream %d\n", stream_id); 374 } else { 375 spdy_data_frame_t *df = g_malloc(sizeof(spdy_data_frame_t)); 376 df->data = data; 377 df->length = length; 378 df->framenum = frame; 379 si->data_frames = g_slist_append(si->data_frames, df); 380 ++si->num_data_frames; 381 if (spdy_debug) 382 printf("Saved %u bytes of data for stream %u frame %u\n", 383 length, stream_id, df->framenum); 384 } 385 } 386 387 static void 388 spdy_increment_data_chunk_count(spdy_conv_t *conv_data, guint32 stream_id) 389 { 390 spdy_stream_info_t *si = spdy_get_stream_info(conv_data, stream_id); 391 if (si != NULL) 392 ++si->num_data_frames; 393 } 394 395 /* 396 * Return the number of data frames saved so far for the specified stream. 397 */ 398 static guint 399 spdy_get_num_data_frames(spdy_conv_t *conv_data, guint32 stream_id) 400 { 401 spdy_stream_info_t *si = spdy_get_stream_info(conv_data, stream_id); 402 403 return si == NULL ? 0 : si->num_data_frames; 404 } 405 406 static spdy_stream_info_t * 407 spdy_assemble_data_frames(spdy_conv_t *conv_data, guint32 stream_id) 408 { 409 spdy_stream_info_t *si = spdy_get_stream_info(conv_data, stream_id); 410 tvbuff_t *tvb; 411 412 if (si == NULL) 413 return NULL; 414 415 /* 416 * Compute the total amount of data and concatenate the 417 * data chunks, if it hasn't already been done. 418 */ 419 if (si->assembled_data == NULL) { 420 spdy_data_frame_t *df; 421 guint8 *data; 422 guint32 datalen; 423 guint32 offset; 424 guint32 framenum; 425 GSList *dflist = si->data_frames; 426 if (dflist == NULL) 427 return si; 428 dflist = si->data_frames; 429 datalen = 0; 430 /* 431 * I'd like to use a composite tvbuff here, but since 432 * only a real-data tvbuff can be the child of another 433 * tvb, I can't. It would be nice if this limitation 434 * could be fixed. 435 */ 436 while (dflist != NULL) { 437 df = dflist->data; 438 datalen += df->length; 439 dflist = g_slist_next(dflist); 440 } 441 if (datalen != 0) { 442 data = se_alloc(datalen); 443 dflist = si->data_frames; 444 offset = 0; 445 framenum = 0; 446 while (dflist != NULL) { 447 df = dflist->data; 448 memcpy(data+offset, df->data, df->length); 449 offset += df->length; 450 dflist = g_slist_next(dflist); 451 } 452 tvb = tvb_new_real_data(data, datalen, datalen); 453 si->assembled_data = tvb; 454 } 455 } 456 return si; 457 } 458 459 static void 460 spdy_discard_data_frames(spdy_stream_info_t *si) 461 { 462 GSList *dflist = si->data_frames; 463 spdy_data_frame_t *df; 464 465 if (dflist == NULL) 466 return; 467 while (dflist != NULL) { 468 df = dflist->data; 469 if (df->data != NULL) { 470 g_free(df->data); 471 df->data = NULL; 472 } 473 dflist = g_slist_next(dflist); 474 } 475 /*g_slist_free(si->data_frames); 476 si->data_frames = NULL; */ 477 } 478 479 // TODO(cbentzel): tvb_child_uncompress should be exported by wireshark. 480 static tvbuff_t* spdy_tvb_child_uncompress(tvbuff_t *parent _U_, tvbuff_t *tvb, 481 int offset, int comprlen) 482 { 483 tvbuff_t *new_tvb = tvb_uncompress(tvb, offset, comprlen); 484 if (new_tvb) 485 tvb_set_child_real_data_tvbuff (parent, new_tvb); 486 return new_tvb; 487 } 488 489 static int 490 dissect_spdy_data_frame(tvbuff_t *tvb, int offset, 491 packet_info *pinfo, 492 proto_tree *top_level_tree, 493 proto_tree *spdy_tree, 494 proto_item *spdy_proto, 495 spdy_conv_t *conv_data) 496 { 497 guint32 stream_id; 498 guint8 flags; 499 guint32 frame_length; 500 proto_item *ti; 501 proto_tree *flags_tree; 502 guint32 reported_datalen; 503 guint32 datalen; 504 dissector_table_t media_type_subdissector_table; 505 dissector_table_t port_subdissector_table; 506 dissector_handle_t handle; 507 guint num_data_frames; 508 gboolean dissected; 509 510 stream_id = tvb_get_bits32(tvb, (offset << 3) + 1, 31, FALSE); 511 flags = tvb_get_guint8(tvb, offset+4); 512 frame_length = tvb_get_ntoh24(tvb, offset+5); 513 514 if (spdy_debug) 515 printf("Data frame [stream_id=%u flags=0x%x length=%d]\n", 516 stream_id, flags, frame_length); 517 if (spdy_tree) proto_item_append_text(spdy_tree, ", data frame"); 518 col_add_fstr(pinfo->cinfo, COL_INFO, "DATA[%u] length=%d", 519 stream_id, frame_length); 520 521 proto_item_append_text(spdy_proto, ":%s stream=%d length=%d", 522 flags & SPDY_FIN ? " [FIN]" : "", 523 stream_id, frame_length); 524 525 proto_tree_add_boolean(spdy_tree, hf_spdy_control_bit, tvb, offset, 1, 0); 526 proto_tree_add_uint(spdy_tree, hf_spdy_streamid, tvb, offset, 4, stream_id); 527 ti = proto_tree_add_uint_format(spdy_tree, hf_spdy_flags, tvb, offset+4, 1, flags, 528 "Flags: 0x%02x%s", flags, flags&SPDY_FIN ? " (FIN)" : ""); 529 530 flags_tree = proto_item_add_subtree(ti, ett_spdy_flags); 531 proto_tree_add_boolean(flags_tree, hf_spdy_flags_fin, tvb, offset+4, 1, flags); 532 proto_tree_add_uint(spdy_tree, hf_spdy_length, tvb, offset+5, 3, frame_length); 533 534 datalen = tvb_length_remaining(tvb, offset); 535 if (datalen > frame_length) 536 datalen = frame_length; 537 538 reported_datalen = tvb_reported_length_remaining(tvb, offset); 539 if (reported_datalen > frame_length) 540 reported_datalen = frame_length; 541 542 num_data_frames = spdy_get_num_data_frames(conv_data, stream_id); 543 if (datalen != 0 || num_data_frames != 0) { 544 /* 545 * There's stuff left over; process it. 546 */ 547 tvbuff_t *next_tvb = NULL; 548 tvbuff_t *data_tvb = NULL; 549 spdy_stream_info_t *si = NULL; 550 void *save_private_data = NULL; 551 guint8 *copied_data; 552 gboolean private_data_changed = FALSE; 553 gboolean is_single_chunk = FALSE; 554 gboolean have_entire_body; 555 556 /* 557 * Create a tvbuff for the payload. 558 */ 559 if (datalen != 0) { 560 next_tvb = tvb_new_subset(tvb, offset+8, datalen, 561 reported_datalen); 562 is_single_chunk = num_data_frames == 0 && (flags & SPDY_FIN) != 0; 563 if (!pinfo->fd->flags.visited) { 564 if (!is_single_chunk) { 565 if (spdy_assemble_entity_bodies) { 566 copied_data = tvb_memdup(next_tvb, 0, datalen); 567 spdy_add_data_chunk(conv_data, stream_id, pinfo->fd->num, 568 copied_data, datalen); 569 } else 570 spdy_increment_data_chunk_count(conv_data, stream_id); 571 } 572 } 573 } else 574 is_single_chunk = (num_data_frames == 1); 575 576 if (!(flags & SPDY_FIN)) { 577 col_set_fence(pinfo->cinfo, COL_INFO); 578 col_add_fstr(pinfo->cinfo, COL_INFO, " (partial entity)"); 579 proto_item_append_text(spdy_proto, " (partial entity body)"); 580 /* would like the proto item to say */ 581 /* " (entity body fragment N of M)" */ 582 goto body_dissected; 583 } 584 have_entire_body = is_single_chunk; 585 /* 586 * On seeing the last data frame in a stream, we can 587 * reassemble the frames into one data block. 588 */ 589 si = spdy_assemble_data_frames(conv_data, stream_id); 590 if (si == NULL) 591 goto body_dissected; 592 data_tvb = si->assembled_data; 593 if (spdy_assemble_entity_bodies) 594 have_entire_body = TRUE; 595 596 if (!have_entire_body) 597 goto body_dissected; 598 599 if (data_tvb == NULL) 600 data_tvb = next_tvb; 601 else 602 add_new_data_source(pinfo, data_tvb, "Assembled entity body"); 603 604 if (have_entire_body && si->content_encoding != NULL && 605 g_ascii_strcasecmp(si->content_encoding, "identity") != 0) { 606 /* 607 * We currently can't handle, for example, "compress"; 608 * just handle them as data for now. 609 * 610 * After July 7, 2004 the LZW patent expires, so support 611 * might be added then. However, I don't think that 612 * anybody ever really implemented "compress", due to 613 * the aforementioned patent. 614 */ 615 tvbuff_t *uncomp_tvb = NULL; 616 proto_item *e_ti = NULL; 617 proto_item *ce_ti = NULL; 618 proto_tree *e_tree = NULL; 619 620 if (spdy_decompress_body && 621 (g_ascii_strcasecmp(si->content_encoding, "gzip") == 0 || 622 g_ascii_strcasecmp(si->content_encoding, "deflate") 623 == 0)) { 624 uncomp_tvb = spdy_tvb_child_uncompress(tvb, data_tvb, 0, 625 tvb_length(data_tvb)); 626 } 627 /* 628 * Add the encoded entity to the protocol tree 629 */ 630 e_ti = proto_tree_add_text(top_level_tree, data_tvb, 631 0, tvb_length(data_tvb), 632 "Content-encoded entity body (%s): %u bytes", 633 si->content_encoding, 634 tvb_length(data_tvb)); 635 e_tree = proto_item_add_subtree(e_ti, ett_spdy_encoded_entity); 636 if (si->num_data_frames > 1) { 637 GSList *dflist; 638 spdy_data_frame_t *df; 639 guint32 framenum; 640 ce_ti = proto_tree_add_text(e_tree, data_tvb, 0, 641 tvb_length(data_tvb), 642 "Assembled from %d frames in packet(s)", si->num_data_frames); 643 dflist = si->data_frames; 644 framenum = 0; 645 while (dflist != NULL) { 646 df = dflist->data; 647 if (framenum != df->framenum) { 648 proto_item_append_text(ce_ti, " #%u", df->framenum); 649 framenum = df->framenum; 650 } 651 dflist = g_slist_next(dflist); 652 } 653 } 654 655 if (uncomp_tvb != NULL) { 656 /* 657 * Decompression worked 658 */ 659 660 /* XXX - Don't free this, since it's possible 661 * that the data was only partially 662 * decompressed, such as when desegmentation 663 * isn't enabled. 664 * 665 tvb_free(next_tvb); 666 */ 667 proto_item_append_text(e_ti, " -> %u bytes", tvb_length(uncomp_tvb)); 668 data_tvb = uncomp_tvb; 669 add_new_data_source(pinfo, data_tvb, "Uncompressed entity body"); 670 } else { 671 if (spdy_decompress_body) 672 proto_item_append_text(e_ti, " [Error: Decompression failed]"); 673 call_dissector(data_handle, data_tvb, pinfo, e_tree); 674 675 goto body_dissected; 676 } 677 } 678 if (si != NULL) 679 spdy_discard_data_frames(si); 680 /* 681 * Do subdissector checks. 682 * 683 * First, check whether some subdissector asked that they 684 * be called if something was on some particular port. 685 */ 686 687 port_subdissector_table = find_dissector_table("http.port"); 688 media_type_subdissector_table = find_dissector_table("media_type"); 689 if (have_entire_body && port_subdissector_table != NULL) 690 handle = dissector_get_port_handle(port_subdissector_table, 691 pinfo->match_port); 692 else 693 handle = NULL; 694 if (handle == NULL && have_entire_body && si->content_type != NULL && 695 media_type_subdissector_table != NULL) { 696 /* 697 * We didn't find any subdissector that 698 * registered for the port, and we have a 699 * Content-Type value. Is there any subdissector 700 * for that content type? 701 */ 702 save_private_data = pinfo->private_data; 703 private_data_changed = TRUE; 704 705 if (si->content_type_parameters) 706 pinfo->private_data = ep_strdup(si->content_type_parameters); 707 else 708 pinfo->private_data = NULL; 709 /* 710 * Calling the string handle for the media type 711 * dissector table will set pinfo->match_string 712 * to si->content_type for us. 713 */ 714 pinfo->match_string = si->content_type; 715 handle = dissector_get_string_handle( 716 media_type_subdissector_table, 717 si->content_type); 718 } 719 if (handle != NULL) { 720 /* 721 * We have a subdissector - call it. 722 */ 723 dissected = call_dissector(handle, data_tvb, pinfo, top_level_tree); 724 } else 725 dissected = FALSE; 726 727 if (dissected) { 728 /* 729 * The subdissector dissected the body. 730 * Fix up the top-level item so that it doesn't 731 * include the stuff for that protocol. 732 */ 733 if (ti != NULL) 734 proto_item_set_len(ti, offset); 735 } else if (have_entire_body && si->content_type != NULL) { 736 /* 737 * Calling the default media handle if there is a content-type that 738 * wasn't handled above. 739 */ 740 call_dissector(media_handle, next_tvb, pinfo, top_level_tree); 741 } else { 742 /* Call the default data dissector */ 743 call_dissector(data_handle, next_tvb, pinfo, top_level_tree); 744 } 745 746 body_dissected: 747 /* 748 * Do *not* attempt at freeing the private data; 749 * it may be in use by subdissectors. 750 */ 751 if (private_data_changed) /*restore even NULL value*/ 752 pinfo->private_data = save_private_data; 753 /* 754 * We've processed "datalen" bytes worth of data 755 * (which may be no data at all); advance the 756 * offset past whatever data we've processed. 757 */ 758 } 759 return frame_length + 8; 760 } 761 762 static guint8 * 763 spdy_decompress_header_block(tvbuff_t *tvb, z_streamp decomp, 764 guint32 dictionary_id, int offset, 765 guint32 length, guint *uncomp_length) 766 { 767 int retcode; 768 size_t bufsize = 16384; 769 const guint8 *hptr = tvb_get_ptr(tvb, offset, length); 770 guint8 *uncomp_block = ep_alloc(bufsize); 771 decomp->next_in = (Bytef *)hptr; 772 decomp->avail_in = length; 773 decomp->next_out = uncomp_block; 774 decomp->avail_out = bufsize; 775 retcode = inflate(decomp, Z_SYNC_FLUSH); 776 if (retcode == Z_NEED_DICT) { 777 if (decomp->adler != dictionary_id) { 778 printf("decompressor wants dictionary %#x, but we have %#x\n", 779 (guint)decomp->adler, dictionary_id); 780 } else { 781 retcode = inflateSetDictionary(decomp, 782 spdy_dictionary, 783 sizeof(spdy_dictionary)); 784 if (retcode == Z_OK) 785 retcode = inflate(decomp, Z_SYNC_FLUSH); 786 } 787 } 788 789 if (retcode != Z_OK) { 790 return NULL; 791 } else { 792 *uncomp_length = bufsize - decomp->avail_out; 793 if (spdy_debug) 794 printf("Inflation SUCCEEDED. uncompressed size=%d\n", *uncomp_length); 795 if (decomp->avail_in != 0) 796 if (spdy_debug) 797 printf(" but there were %d input bytes left over\n", decomp->avail_in); 798 } 799 return se_memdup(uncomp_block, *uncomp_length); 800 } 801 802 /* 803 * Try to determine heuristically whether the header block is 804 * compressed. For an uncompressed block, the first two bytes 805 * gives the number of headers. Each header name and value is 806 * a two-byte length followed by ASCII characters. 807 */ 808 static gboolean 809 spdy_check_header_compression(tvbuff_t *tvb, 810 int offset, 811 guint32 frame_length) 812 { 813 guint16 length; 814 if (!tvb_bytes_exist(tvb, offset, 6)) 815 return 1; 816 length = tvb_get_ntohs(tvb, offset); 817 if (length > frame_length) 818 return 1; 819 length = tvb_get_ntohs(tvb, offset+2); 820 if (length > frame_length) 821 return 1; 822 if (spdy_debug) printf("Looks like the header block is not compressed\n"); 823 return 0; 824 } 825 826 // TODO(cbentzel): Change wireshark to export p_remove_proto_data, rather 827 // than duplicating code here. 828 typedef struct _spdy_frame_proto_data { 829 int proto; 830 void *proto_data; 831 } spdy_frame_proto_data; 832 833 static gint spdy_p_compare(gconstpointer a, gconstpointer b) 834 { 835 const spdy_frame_proto_data *ap = (const spdy_frame_proto_data *)a; 836 const spdy_frame_proto_data *bp = (const spdy_frame_proto_data *)b; 837 838 if (ap -> proto > bp -> proto) 839 return 1; 840 else if (ap -> proto == bp -> proto) 841 return 0; 842 else 843 return -1; 844 845 } 846 847 static void spdy_p_remove_proto_data(frame_data *fd, int proto) 848 { 849 spdy_frame_proto_data temp; 850 GSList *item; 851 852 temp.proto = proto; 853 temp.proto_data = NULL; 854 855 item = g_slist_find_custom(fd->pfd, (gpointer *)&temp, spdy_p_compare); 856 857 if (item) { 858 fd->pfd = g_slist_remove(fd->pfd, item->data); 859 } 860 } 861 862 static spdy_frame_info_t * 863 spdy_save_header_block(frame_data *fd, 864 guint32 stream_id, 865 guint frame_type, 866 guint8 *header, 867 guint length) 868 { 869 GSList *filist = p_get_proto_data(fd, proto_spdy); 870 spdy_frame_info_t *frame_info = se_alloc(sizeof(spdy_frame_info_t)); 871 if (filist != NULL) 872 spdy_p_remove_proto_data(fd, proto_spdy); 873 frame_info->stream_id = stream_id; 874 frame_info->header_block = header; 875 frame_info->header_block_len = length; 876 frame_info->frame_type = frame_type; 877 filist = g_slist_append(filist, frame_info); 878 p_add_proto_data(fd, proto_spdy, filist); 879 return frame_info; 880 /* TODO(ers) these need to get deleted when no longer needed */ 881 } 882 883 static spdy_frame_info_t * 884 spdy_find_saved_header_block(frame_data *fd, 885 guint32 stream_id, 886 guint16 frame_type) 887 { 888 GSList *filist = p_get_proto_data(fd, proto_spdy); 889 while (filist != NULL) { 890 spdy_frame_info_t *fi = filist->data; 891 if (fi->stream_id == stream_id && fi->frame_type == frame_type) 892 return fi; 893 filist = g_slist_next(filist); 894 } 895 return NULL; 896 } 897 898 /* 899 * Given a content type string that may contain optional parameters, 900 * return the parameter string, if any, otherwise return NULL. This 901 * also has the side effect of null terminating the content type 902 * part of the original string. 903 */ 904 static gchar * 905 spdy_parse_content_type(gchar *content_type) 906 { 907 gchar *cp = content_type; 908 909 while (*cp != '\0' && *cp != ';' && !isspace(*cp)) { 910 *cp = tolower(*cp); 911 ++cp; 912 } 913 if (*cp == '\0') 914 cp = NULL; 915 916 if (cp != NULL) { 917 *cp++ = '\0'; 918 while (*cp == ';' || isspace(*cp)) 919 ++cp; 920 if (*cp != '\0') 921 return cp; 922 } 923 return NULL; 924 } 925 926 static int 927 dissect_spdy_message(tvbuff_t *tvb, int offset, packet_info *pinfo, 928 proto_tree *tree, spdy_conv_t *conv_data) 929 { 930 guint8 control_bit; 931 guint16 version; 932 guint16 frame_type; 933 guint8 flags; 934 guint32 frame_length; 935 guint32 stream_id; 936 guint32 associated_stream_id; 937 gint priority; 938 guint16 num_headers; 939 guint32 fin_status; 940 guint8 *frame_header; 941 const char *proto_tag; 942 const char *frame_type_name; 943 proto_tree *spdy_tree = NULL; 944 proto_item *ti = NULL; 945 proto_item *spdy_proto = NULL; 946 int orig_offset; 947 int hoffset; 948 int hdr_offset = 0; 949 spdy_frame_type_t spdy_type; 950 proto_tree *sub_tree; 951 proto_tree *flags_tree; 952 tvbuff_t *header_tvb = NULL; 953 gboolean headers_compressed; 954 gchar *hdr_verb = NULL; 955 gchar *hdr_url = NULL; 956 gchar *hdr_version = NULL; 957 gchar *content_type = NULL; 958 gchar *content_encoding = NULL; 959 960 /* 961 * Minimum size for a SPDY frame is 8 bytes. 962 */ 963 if (tvb_reported_length_remaining(tvb, offset) < 8) 964 return -1; 965 966 proto_tag = "SPDY"; 967 968 if (check_col(pinfo->cinfo, COL_PROTOCOL)) 969 col_set_str(pinfo->cinfo, COL_PROTOCOL, proto_tag); 970 971 /* 972 * Is this a control frame or a data frame? 973 */ 974 orig_offset = offset; 975 control_bit = tvb_get_bits8(tvb, offset << 3, 1); 976 if (control_bit) { 977 version = tvb_get_bits16(tvb, (offset << 3) + 1, 15, FALSE); 978 frame_type = tvb_get_ntohs(tvb, offset+2); 979 if (frame_type >= SPDY_INVALID) { 980 return -1; 981 } 982 frame_header = ep_tvb_memdup(tvb, offset, 16); 983 } else { 984 version = 1; /* avoid gcc warning */ 985 frame_type = SPDY_DATA; 986 frame_header = NULL; /* avoid gcc warning */ 987 } 988 frame_type_name = frame_type_names[frame_type]; 989 offset += 4; 990 flags = tvb_get_guint8(tvb, offset); 991 frame_length = tvb_get_ntoh24(tvb, offset+1); 992 offset += 4; 993 /* 994 * Make sure there's as much data as the frame header says there is. 995 */ 996 if ((guint)tvb_reported_length_remaining(tvb, offset) < frame_length) { 997 if (spdy_debug) 998 printf("Not enough header data: %d vs. %d\n", 999 frame_length, tvb_reported_length_remaining(tvb, offset)); 1000 return -1; 1001 } 1002 if (tree) { 1003 spdy_proto = proto_tree_add_item(tree, proto_spdy, tvb, orig_offset, frame_length+8, FALSE); 1004 spdy_tree = proto_item_add_subtree(spdy_proto, ett_spdy); 1005 } 1006 1007 if (control_bit) { 1008 if (spdy_debug) 1009 printf("Control frame [version=%d type=%d flags=0x%x length=%d]\n", 1010 version, frame_type, flags, frame_length); 1011 if (tree) proto_item_append_text(spdy_tree, ", control frame"); 1012 } else { 1013 return dissect_spdy_data_frame(tvb, orig_offset, pinfo, tree, 1014 spdy_tree, spdy_proto, conv_data); 1015 } 1016 num_headers = 0; 1017 sub_tree = NULL; /* avoid gcc warning */ 1018 switch (frame_type) { 1019 case SPDY_SYN_STREAM: 1020 case SPDY_SYN_REPLY: 1021 if (tree) { 1022 int hf; 1023 hf = frame_type == SPDY_SYN_STREAM ? hf_spdy_syn_stream : hf_spdy_syn_reply; 1024 ti = proto_tree_add_bytes(spdy_tree, hf, tvb, 1025 orig_offset, 16, frame_header); 1026 sub_tree = proto_item_add_subtree(ti, ett_spdy_syn_stream); 1027 } 1028 stream_id = tvb_get_bits32(tvb, (offset << 3) + 1, 31, FALSE); 1029 offset += 4; 1030 if (frame_type == SPDY_SYN_STREAM) { 1031 associated_stream_id = tvb_get_bits32(tvb, (offset << 3) + 1, 31, FALSE); 1032 offset += 4; 1033 priority = tvb_get_bits8(tvb, offset << 3, 2); 1034 offset += 2; 1035 } else { 1036 // The next two bytes have no meaning in SYN_REPLY 1037 offset += 2; 1038 } 1039 if (tree) { 1040 proto_tree_add_boolean(sub_tree, hf_spdy_control_bit, tvb, orig_offset, 1, control_bit); 1041 proto_tree_add_uint(sub_tree, hf_spdy_version, tvb, orig_offset, 2, version); 1042 proto_tree_add_uint(sub_tree, hf_spdy_type, tvb, orig_offset+2, 2, frame_type); 1043 ti = proto_tree_add_uint_format(sub_tree, hf_spdy_flags, tvb, orig_offset+4, 1, flags, 1044 "Flags: 0x%02x%s", flags, flags&SPDY_FIN ? " (FIN)" : ""); 1045 flags_tree = proto_item_add_subtree(ti, ett_spdy_flags); 1046 proto_tree_add_boolean(flags_tree, hf_spdy_flags_fin, tvb, orig_offset+4, 1, flags); 1047 proto_tree_add_uint(sub_tree, hf_spdy_length, tvb, orig_offset+5, 3, frame_length); 1048 proto_tree_add_uint(sub_tree, hf_spdy_streamid, tvb, orig_offset+8, 4, stream_id); 1049 if (frame_type == SPDY_SYN_STREAM) { 1050 proto_tree_add_uint(sub_tree, hf_spdy_associated_streamid, tvb, orig_offset+12, 4, associated_stream_id); 1051 proto_tree_add_uint(sub_tree, hf_spdy_priority, tvb, orig_offset+16, 1, priority); 1052 } 1053 proto_item_append_text(spdy_proto, ": %s%s stream=%d length=%d", 1054 frame_type_name, 1055 flags & SPDY_FIN ? " [FIN]" : "", 1056 stream_id, frame_length); 1057 if (spdy_debug) 1058 printf(" stream ID=%u priority=%d\n", stream_id, priority); 1059 } 1060 break; 1061 1062 case SPDY_FIN_STREAM: 1063 stream_id = tvb_get_bits32(tvb, (offset << 3) + 1, 31, FALSE); 1064 fin_status = tvb_get_ntohl(tvb, offset); 1065 // TODO(ers) fill in tree and summary 1066 offset += 8; 1067 break; 1068 1069 case SPDY_HELLO: 1070 // TODO(ers) fill in tree and summary 1071 stream_id = 0; /* avoid gcc warning */ 1072 break; 1073 1074 default: 1075 stream_id = 0; /* avoid gcc warning */ 1076 return -1; 1077 break; 1078 } 1079 1080 /* 1081 * Process the name-value pairs one at a time, after possibly 1082 * decompressing the header block. 1083 */ 1084 if (frame_type == SPDY_SYN_STREAM || frame_type == SPDY_SYN_REPLY) { 1085 headers_compressed = spdy_check_header_compression(tvb, offset, frame_length); 1086 if (!spdy_decompress_headers || !headers_compressed) { 1087 header_tvb = tvb; 1088 hdr_offset = offset; 1089 } else { 1090 spdy_frame_info_t *per_frame_info = 1091 spdy_find_saved_header_block(pinfo->fd, 1092 stream_id, 1093 frame_type == SPDY_SYN_REPLY); 1094 if (per_frame_info == NULL) { 1095 guint uncomp_length; 1096 z_streamp decomp = frame_type == SPDY_SYN_STREAM ? 1097 conv_data->rqst_decompressor : conv_data->rply_decompressor; 1098 guint8 *uncomp_ptr = 1099 spdy_decompress_header_block(tvb, decomp, 1100 conv_data->dictionary_id, 1101 offset, 1102 frame_length + 8 - (offset - orig_offset), 1103 &uncomp_length); 1104 if (uncomp_ptr == NULL) { /* decompression failed */ 1105 if (spdy_debug) 1106 printf("Frame #%d: Inflation failed\n", pinfo->fd->num); 1107 proto_item_append_text(spdy_proto, " [Error: Header decompression failed]"); 1108 // Should we just bail here? 1109 } else { 1110 if (spdy_debug) 1111 printf("Saving %u bytes of uncomp hdr\n", uncomp_length); 1112 per_frame_info = 1113 spdy_save_header_block(pinfo->fd, stream_id, frame_type == SPDY_SYN_REPLY, 1114 uncomp_ptr, uncomp_length); 1115 } 1116 } else if (spdy_debug) { 1117 printf("Found uncompressed header block len %u for stream %u frame_type=%d\n", 1118 per_frame_info->header_block_len, 1119 per_frame_info->stream_id, 1120 per_frame_info->frame_type); 1121 } 1122 if (per_frame_info != NULL) { 1123 header_tvb = tvb_new_child_real_data(tvb, 1124 per_frame_info->header_block, 1125 per_frame_info->header_block_len, 1126 per_frame_info->header_block_len); 1127 add_new_data_source(pinfo, header_tvb, "Uncompressed headers"); 1128 hdr_offset = 0; 1129 } 1130 } 1131 offset = orig_offset + 8 + frame_length; 1132 num_headers = tvb_get_ntohs(header_tvb, hdr_offset); 1133 hdr_offset += 2; 1134 if (header_tvb == NULL || 1135 (headers_compressed && !spdy_decompress_headers)) { 1136 num_headers = 0; 1137 ti = proto_tree_add_string(sub_tree, hf_spdy_num_headers_string, 1138 tvb, 1139 frame_type == SPDY_SYN_STREAM ? orig_offset+18 : orig_offset + 14, 1140 2, 1141 "Unknown (header block is compressed)"); 1142 } else 1143 ti = proto_tree_add_uint(sub_tree, hf_spdy_num_headers, 1144 tvb, 1145 frame_type == SPDY_SYN_STREAM ? orig_offset+18 : orig_offset +14, 1146 2, num_headers); 1147 } 1148 spdy_type = SPDY_INVALID; /* type not known yet */ 1149 if (spdy_debug) 1150 printf(" %d Headers:\n", num_headers); 1151 if (num_headers > frame_length) { 1152 printf("Number of headers is greater than frame length!\n"); 1153 proto_item_append_text(ti, " [Error: Number of headers is larger than frame length]"); 1154 col_add_fstr(pinfo->cinfo, COL_INFO, "%s[%d]", frame_type_name, stream_id); 1155 return frame_length+8; 1156 } 1157 hdr_verb = hdr_url = hdr_version = content_type = content_encoding = NULL; 1158 while (num_headers-- && tvb_reported_length_remaining(header_tvb, hdr_offset) != 0) { 1159 gchar *header_name; 1160 gchar *header_value; 1161 proto_tree *header_tree; 1162 proto_tree *name_tree; 1163 proto_tree *value_tree; 1164 proto_item *header; 1165 gint16 length; 1166 gint header_length = 0; 1167 1168 hoffset = hdr_offset; 1169 1170 header = proto_tree_add_item(spdy_tree, hf_spdy_header, header_tvb, 1171 hdr_offset, frame_length, FALSE); 1172 header_tree = proto_item_add_subtree(header, ett_spdy_header); 1173 1174 length = tvb_get_ntohs(header_tvb, hdr_offset); 1175 hdr_offset += 2; 1176 header_name = (gchar *)tvb_get_ephemeral_string(header_tvb, hdr_offset, length); 1177 hdr_offset += length; 1178 header_length += hdr_offset - hoffset; 1179 if (tree) { 1180 ti = proto_tree_add_text(header_tree, header_tvb, hoffset, length+2, "Name: %s", 1181 header_name); 1182 name_tree = proto_item_add_subtree(ti, ett_spdy_header_name); 1183 proto_tree_add_uint(name_tree, hf_spdy_length, header_tvb, hoffset, 2, length); 1184 proto_tree_add_string_format(name_tree, hf_spdy_header_name_text, header_tvb, hoffset+2, length, 1185 header_name, "Text: %s", format_text(header_name, length)); 1186 } 1187 1188 hoffset = hdr_offset; 1189 length = tvb_get_ntohs(header_tvb, hdr_offset); 1190 hdr_offset += 2; 1191 header_value = (gchar *)tvb_get_ephemeral_string(header_tvb, hdr_offset, length); 1192 hdr_offset += length; 1193 header_length += hdr_offset - hoffset; 1194 if (tree) { 1195 ti = proto_tree_add_text(header_tree, header_tvb, hoffset, length+2, "Value: %s", 1196 header_value); 1197 value_tree = proto_item_add_subtree(ti, ett_spdy_header_value); 1198 proto_tree_add_uint(value_tree, hf_spdy_length, header_tvb, hoffset, 2, length); 1199 proto_tree_add_string_format(value_tree, hf_spdy_header_value_text, header_tvb, hoffset+2, length, 1200 header_value, "Text: %s", format_text(header_value, length)); 1201 proto_item_append_text(header, ": %s: %s", header_name, header_value); 1202 proto_item_set_len(header, header_length); 1203 } 1204 if (spdy_debug) printf(" %s: %s\n", header_name, header_value); 1205 /* 1206 * TODO(ers) check that the header name contains only legal characters. 1207 */ 1208 if (g_ascii_strcasecmp(header_name, "method") == 0 || 1209 g_ascii_strcasecmp(header_name, "status") == 0) { 1210 hdr_verb = header_value; 1211 } else if (g_ascii_strcasecmp(header_name, "url") == 0) { 1212 hdr_url = header_value; 1213 } else if (g_ascii_strcasecmp(header_name, "version") == 0) { 1214 hdr_version = header_value; 1215 } else if (g_ascii_strcasecmp(header_name, "content-type") == 0) { 1216 content_type = se_strdup(header_value); 1217 } else if (g_ascii_strcasecmp(header_name, "content-encoding") == 0) { 1218 content_encoding = se_strdup(header_value); 1219 } 1220 } 1221 if (hdr_version != NULL) { 1222 if (hdr_url != NULL) { 1223 col_add_fstr(pinfo->cinfo, COL_INFO, "%s[%d]: %s %s %s", 1224 frame_type_name, stream_id, hdr_verb, hdr_url, hdr_version); 1225 } else { 1226 col_add_fstr(pinfo->cinfo, COL_INFO, "%s[%d]: %s %s", 1227 frame_type_name, stream_id, hdr_verb, hdr_version); 1228 } 1229 } else { 1230 col_add_fstr(pinfo->cinfo, COL_INFO, "%s[%d]", frame_type_name, stream_id); 1231 } 1232 /* 1233 * If we expect data on this stream, we need to remember the content 1234 * type and content encoding. 1235 */ 1236 if (content_type != NULL && !pinfo->fd->flags.visited) { 1237 gchar *content_type_params = spdy_parse_content_type(content_type); 1238 spdy_save_stream_info(conv_data, stream_id, content_type, 1239 content_type_params, content_encoding); 1240 } 1241 1242 return offset - orig_offset; 1243 } 1244 1245 static int 1246 dissect_spdy(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) 1247 { 1248 spdy_conv_t *conv_data; 1249 int offset = 0; 1250 int len; 1251 int firstpkt = 1; 1252 1253 /* 1254 * The first byte of a SPDY packet must be either 0 or 1255 * 0x80. If it's not, assume that this is not SPDY. 1256 * (In theory, a data frame could have a stream ID 1257 * >= 2^24, in which case it won't have 0 for a first 1258 * byte, but this is a pretty reliable heuristic for 1259 * now.) 1260 */ 1261 guint8 first_byte = tvb_get_guint8(tvb, 0); 1262 if (first_byte != 0x80 && first_byte != 0x0) 1263 return 0; 1264 1265 conv_data = get_spdy_conversation_data(pinfo); 1266 1267 while (tvb_reported_length_remaining(tvb, offset) != 0) { 1268 if (!firstpkt) { 1269 col_add_fstr(pinfo->cinfo, COL_INFO, " >> "); 1270 col_set_fence(pinfo->cinfo, COL_INFO); 1271 } 1272 len = dissect_spdy_message(tvb, offset, pinfo, tree, conv_data); 1273 if (len <= 0) 1274 return 0; 1275 offset += len; 1276 /* 1277 * OK, we've set the Protocol and Info columns for the 1278 * first SPDY message; set a fence so that subsequent 1279 * SPDY messages don't overwrite the Info column. 1280 */ 1281 col_set_fence(pinfo->cinfo, COL_INFO); 1282 firstpkt = 0; 1283 } 1284 return 1; 1285 } 1286 1287 static gboolean 1288 dissect_spdy_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) 1289 { 1290 if (!value_is_in_range(global_spdy_tcp_range, pinfo->destport) && 1291 !value_is_in_range(global_spdy_tcp_range, pinfo->srcport)) 1292 return FALSE; 1293 return dissect_spdy(tvb, pinfo, tree) != 0; 1294 } 1295 1296 static void reinit_spdy(void) 1297 { 1298 } 1299 1300 // NMAKE complains about flags_set_truth not being constant. Duplicate 1301 // the values inside of it. 1302 static const true_false_string tfs_spdy_set_notset = { "Set", "Not set" }; 1303 1304 void 1305 proto_register_spdy(void) 1306 { 1307 static hf_register_info hf[] = { 1308 { &hf_spdy_syn_stream, 1309 { "Syn Stream", "spdy.syn_stream", 1310 FT_BYTES, BASE_NONE, NULL, 0x0, 1311 "", HFILL }}, 1312 { &hf_spdy_syn_reply, 1313 { "Syn Reply", "spdy.syn_reply", 1314 FT_BYTES, BASE_NONE, NULL, 0x0, 1315 "", HFILL }}, 1316 { &hf_spdy_control_bit, 1317 { "Control bit", "spdy.control_bit", 1318 FT_BOOLEAN, BASE_NONE, NULL, 0x0, 1319 "TRUE if SPDY control frame", HFILL }}, 1320 { &hf_spdy_version, 1321 { "Version", "spdy.version", 1322 FT_UINT16, BASE_DEC, NULL, 0x0, 1323 "", HFILL }}, 1324 { &hf_spdy_type, 1325 { "Type", "spdy.type", 1326 FT_UINT16, BASE_DEC, NULL, 0x0, 1327 "", HFILL }}, 1328 { &hf_spdy_flags, 1329 { "Flags", "spdy.flags", 1330 FT_UINT8, BASE_HEX, NULL, 0x0, 1331 "", HFILL }}, 1332 { &hf_spdy_flags_fin, 1333 { "Fin", "spdy.flags.fin", 1334 FT_BOOLEAN, 8, TFS(&tfs_spdy_set_notset), 1335 SPDY_FIN, "", HFILL }}, 1336 { &hf_spdy_length, 1337 { "Length", "spdy.length", 1338 FT_UINT24, BASE_DEC, NULL, 0x0, 1339 "", HFILL }}, 1340 { &hf_spdy_header, 1341 { "Header", "spdy.header", 1342 FT_NONE, BASE_NONE, NULL, 0x0, 1343 "", HFILL }}, 1344 { &hf_spdy_header_name, 1345 { "Name", "spdy.header.name", 1346 FT_NONE, BASE_NONE, NULL, 0x0, 1347 "", HFILL }}, 1348 { &hf_spdy_header_name_text, 1349 { "Text", "spdy.header.name.text", 1350 FT_STRING, BASE_NONE, NULL, 0x0, 1351 "", HFILL }}, 1352 { &hf_spdy_header_value, 1353 { "Value", "spdy.header.value", 1354 FT_NONE, BASE_NONE, NULL, 0x0, 1355 "", HFILL }}, 1356 { &hf_spdy_header_value_text, 1357 { "Text", "spdy.header.value.text", 1358 FT_STRING, BASE_NONE, NULL, 0x0, 1359 "", HFILL }}, 1360 { &hf_spdy_streamid, 1361 { "Stream ID", "spdy.streamid", 1362 FT_UINT32, BASE_DEC, NULL, 0x0, 1363 "", HFILL }}, 1364 { &hf_spdy_associated_streamid, 1365 { "Associated Stream ID", "spdy.associated.streamid", 1366 FT_UINT32, BASE_DEC, NULL, 0x0, 1367 "", HFILL }}, 1368 { &hf_spdy_priority, 1369 { "Priority", "spdy.priority", 1370 FT_UINT8, BASE_DEC, NULL, 0x0, 1371 "", HFILL }}, 1372 { &hf_spdy_num_headers, 1373 { "Number of headers", "spdy.numheaders", 1374 FT_UINT16, BASE_DEC, NULL, 0x0, 1375 "", HFILL }}, 1376 { &hf_spdy_num_headers_string, 1377 { "Number of headers", "spdy.numheaders", 1378 FT_STRING, BASE_NONE, NULL, 0x0, 1379 "", HFILL }}, 1380 }; 1381 static gint *ett[] = { 1382 &ett_spdy, 1383 &ett_spdy_syn_stream, 1384 &ett_spdy_syn_reply, 1385 &ett_spdy_fin_stream, 1386 &ett_spdy_flags, 1387 &ett_spdy_header, 1388 &ett_spdy_header_name, 1389 &ett_spdy_header_value, 1390 &ett_spdy_encoded_entity, 1391 }; 1392 1393 module_t *spdy_module; 1394 1395 proto_spdy = proto_register_protocol("SPDY", "SPDY", "spdy"); 1396 proto_register_field_array(proto_spdy, hf, array_length(hf)); 1397 proto_register_subtree_array(ett, array_length(ett)); 1398 new_register_dissector("spdy", dissect_spdy, proto_spdy); 1399 spdy_module = prefs_register_protocol(proto_spdy, reinit_spdy); 1400 prefs_register_bool_preference(spdy_module, "desegment_headers", 1401 "Reassemble SPDY control frames spanning multiple TCP segments", 1402 "Whether the SPDY dissector should reassemble control frames " 1403 "spanning multiple TCP segments. " 1404 "To use this option, you must also enable " 1405 "\"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", 1406 &spdy_desegment_control_frames); 1407 prefs_register_bool_preference(spdy_module, "desegment_body", 1408 "Reassemble SPDY bodies spanning multiple TCP segments", 1409 "Whether the SPDY dissector should reassemble " 1410 "data frames spanning multiple TCP segments. " 1411 "To use this option, you must also enable " 1412 "\"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", 1413 &spdy_desegment_data_frames); 1414 prefs_register_bool_preference(spdy_module, "assemble_data_frames", 1415 "Assemble SPDY bodies that consist of multiple DATA frames", 1416 "Whether the SPDY dissector should reassemble multiple " 1417 "data frames into an entity body.", 1418 &spdy_assemble_entity_bodies); 1419 #ifdef HAVE_LIBZ 1420 prefs_register_bool_preference(spdy_module, "decompress_headers", 1421 "Uncompress SPDY headers", 1422 "Whether to uncompress SPDY headers.", 1423 &spdy_decompress_headers); 1424 prefs_register_bool_preference(spdy_module, "decompress_body", 1425 "Uncompress entity bodies", 1426 "Whether to uncompress entity bodies that are compressed " 1427 "using \"Content-Encoding: \"", 1428 &spdy_decompress_body); 1429 #endif 1430 prefs_register_bool_preference(spdy_module, "debug_output", 1431 "Print debug info on stdout", 1432 "Print debug info on stdout", 1433 &spdy_debug); 1434 #if 0 1435 prefs_register_string_preference(ssl_module, "debug_file", "SPDY debug file", 1436 "Redirect SPDY debug to file name; " 1437 "leave empty to disable debugging, " 1438 "or use \"" SPDY_DEBUG_USE_STDOUT "\"" 1439 " to redirect output to stdout\n", 1440 (const gchar **)&sdpy_debug_file_name); 1441 #endif 1442 prefs_register_obsolete_preference(spdy_module, "tcp_alternate_port"); 1443 1444 range_convert_str(&global_spdy_tcp_range, TCP_DEFAULT_RANGE, 65535); 1445 spdy_tcp_range = range_empty(); 1446 prefs_register_range_preference(spdy_module, "tcp.port", "TCP Ports", 1447 "TCP Ports range", 1448 &global_spdy_tcp_range, 65535); 1449 1450 range_convert_str(&global_spdy_ssl_range, SSL_DEFAULT_RANGE, 65535); 1451 spdy_ssl_range = range_empty(); 1452 prefs_register_range_preference(spdy_module, "ssl.port", "SSL/TLS Ports", 1453 "SSL/TLS Ports range", 1454 &global_spdy_ssl_range, 65535); 1455 1456 spdy_handle = new_create_dissector_handle(dissect_spdy, proto_spdy); 1457 /* 1458 * Register for tapping 1459 */ 1460 spdy_tap = register_tap("spdy"); /* SPDY statistics tap */ 1461 spdy_eo_tap = register_tap("spdy_eo"); /* SPDY Export Object tap */ 1462 } 1463 1464 void 1465 proto_reg_handoff_spdy(void) 1466 { 1467 data_handle = find_dissector("data"); 1468 media_handle = find_dissector("media"); 1469 heur_dissector_add("tcp", dissect_spdy_heur, proto_spdy); 1470 } 1471 1472 /* 1473 * Content-Type: message/http 1474 */ 1475 1476 static gint proto_message_spdy = -1; 1477 static gint ett_message_spdy = -1; 1478 1479 static void 1480 dissect_message_spdy(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) 1481 { 1482 proto_tree *subtree; 1483 proto_item *ti; 1484 gint offset = 0, next_offset; 1485 gint len; 1486 1487 if (check_col(pinfo->cinfo, COL_INFO)) 1488 col_append_str(pinfo->cinfo, COL_INFO, " (message/spdy)"); 1489 if (tree) { 1490 ti = proto_tree_add_item(tree, proto_message_spdy, 1491 tvb, 0, -1, FALSE); 1492 subtree = proto_item_add_subtree(ti, ett_message_spdy); 1493 while (tvb_reported_length_remaining(tvb, offset) != 0) { 1494 len = tvb_find_line_end(tvb, offset, 1495 tvb_ensure_length_remaining(tvb, offset), 1496 &next_offset, FALSE); 1497 if (len == -1) 1498 break; 1499 proto_tree_add_text(subtree, tvb, offset, next_offset - offset, 1500 "%s", tvb_format_text(tvb, offset, len)); 1501 offset = next_offset; 1502 } 1503 } 1504 } 1505 1506 void 1507 proto_register_message_spdy(void) 1508 { 1509 static gint *ett[] = { 1510 &ett_message_spdy, 1511 }; 1512 1513 proto_message_spdy = proto_register_protocol( 1514 "Media Type: message/spdy", 1515 "message/spdy", 1516 "message-spdy" 1517 ); 1518 proto_register_subtree_array(ett, array_length(ett)); 1519 } 1520 1521 void 1522 proto_reg_handoff_message_spdy(void) 1523 { 1524 dissector_handle_t message_spdy_handle; 1525 1526 message_spdy_handle = create_dissector_handle(dissect_message_spdy, 1527 proto_message_spdy); 1528 1529 dissector_add_string("media_type", "message/spdy", message_spdy_handle); 1530 1531 reinit_spdy(); 1532 } 1533
