net/tools/spdyshark/packet-spdy.c - Issue 68013005: Remove net/tools/spdyshark

Side by Side Diff: net/tools/spdyshark/packet-spdy.c

Issue 68013005: Remove net/tools/spdyshark (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 7 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
	(Empty)
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@google.com>

8 *

9 * $Id$

10 *

11 * Wireshark - Network traffic analyzer

12 * By Gerald Combs <gerald@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, p info->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, conversatio n);

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, cont ent_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, flag s);

532 proto_tree_add_uint(spdy_tree, hf_spdy_length, tvb, offset+5, 3, frame_lengt h);

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_fr ames);

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_t vb));

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->av ail_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, fra me_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_spd y_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, or ig_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_o ffset+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_le ngth);

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_decompres sor;

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 decompre ssion 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 fra me_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_le n,

1126 per_frame_info->header_block_le n);

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 fr ame length]");

1154 col_add_fstr(pinfo->cinfo, COL_INFO, "%s[%d]", frame_type_name, stream_i d);

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, he ader_tvb, hoffset+2, length,

1185 header_name, "Text: %s", format_text(he ader_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(h eader_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_vers ion);

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_i d);

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 mult iple 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 stre ams\" 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 stre ams\" 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 multipl e 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 }

OLD	NEW

« no previous file with comments | « net/tools/spdyshark/packet-spdy.h ('k') | net/tools/spdyshark/plugin.rc.in » ('j') | no next file with comments »