?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dcerpc-netlogon: maintain netlogon_auth_vars for NetrServerAuthenticateKerberos
[wireshark-sm.git] / epan / dissectors / packet-sdp.c
blob09919354b27919d5ead3ccef8315cf42c7acd2a6
1 /* packet-sdp.c
2 * Routines for SDP packet disassembly (RFC 2327)
3 *
4 * Jason Lango <jal@netapp.com>
5 * Liberally copied from packet-http.c, by Guy Harris <guy@alum.mit.edu>
6 *
7 * Wireshark - Network traffic analyzer
8 * By Gerald Combs <gerald@wireshark.org>
9 * Copyright 1998 Gerald Combs
10 *
11 * SPDX-License-Identifier: GPL-2.0-or-later
12 * Ref https://www.ietf.org/rfc/rfc4566
13 */
14
15 #include "config.h"
16
17 #include <epan/packet.h>
18 #include <epan/exceptions.h>
19 #include <epan/asn1.h>
20 #include <epan/prefs.h>
21 #include <epan/expert.h>
22 #include <epan/tap.h>
23 #include <epan/rtp_pt.h>
24 #include <epan/show_exception.h>
25 #include <epan/addr_resolv.h>
26 #include <epan/conversation.h>
27 #include <epan/proto_data.h>
28 #include <epan/strutil.h>
29
30 #include <wsutil/strtoi.h>
31 #include <wsutil/str_util.h>
32
33 #include "packet-media-type.h"
34 #include "packet-sdp.h"
35
36 /* un-comment the following as well as this line in conversation.c, to enable debug printing */
37 /* #define DEBUG_CONVERSATION */
38 #include "conversation_debug.h"
39
40 #include "packet-gsm_osmux.h"
41 #include "packet-rtp.h"
42 #include "packet-rtcp.h"
43 #include "packet-t38.h"
44 #include "packet-msrp.h"
45 #include "packet-sprt.h"
46 #include "packet-bfcp.h"
47 #include "packet-h245.h"
48 #include "packet-h264.h"
49 #include "packet-h265.h"
50 #include "packet-mp4ves.h"
51
52 void proto_register_sdp(void);
53 void proto_reg_handoff_sdp(void);
54
55 static dissector_handle_t sdp_handle;
56 static dissector_handle_t rtcp_handle;
57 static dissector_handle_t sprt_handle;
58 static dissector_handle_t msrp_handle;
59 static dissector_handle_t bfcp_handle;
60 static dissector_handle_t h264_handle;
61 static dissector_handle_t h265_handle;
62 static dissector_handle_t mp4ves_config_handle;
63
64 static int sdp_tap;
65
66 static int proto_sdp;
67 static int proto_sprt;
68
69 static const char* UNKNOWN_ENCODING = "Unknown";
70 static wmem_tree_t *sdp_transport_reqs;
71 static wmem_tree_t *sdp_transport_rsps;
72
73 /* preference globals */
74 static bool global_sdp_establish_conversation = true;
75
76 /* Top level fields */
77 static int hf_protocol_version;
78 static int hf_owner;
79 static int hf_session_name;
80 static int hf_session_info;
81 static int hf_uri;
82 static int hf_email;
83 static int hf_phone;
84 static int hf_connection_info;
85 static int hf_bandwidth;
86 static int hf_timezone;
87 static int hf_encryption_key;
88 static int hf_session_attribute;
89 static int hf_media_attribute;
90 static int hf_time;
91 static int hf_repeat_time;
92 static int hf_media;
93 static int hf_media_title;
94 static int hf_unknown;
95 static int hf_invalid;
96 static int hf_ipbcp_version;
97 static int hf_ipbcp_type;
98
99 /* hf_owner subfields*/
100 static int hf_owner_username;
101 static int hf_owner_sessionid;
102 static int hf_owner_version;
103 static int hf_owner_network_type;
104 static int hf_owner_address_type;
105 static int hf_owner_address;
106
107 /* hf_connection_info subfields */
108 static int hf_connection_info_network_type;
109 static int hf_connection_info_address_type;
110 static int hf_connection_info_connection_address;
111 static int hf_connection_info_ttl;
112 static int hf_connection_info_num_addr;
113
114 /* hf_bandwidth subfields */
115 static int hf_bandwidth_modifier;
116 static int hf_bandwidth_value;
117
118 /* hf_time subfields */
119 static int hf_time_start;
120 static int hf_time_stop;
121
122 /* hf_repeat_time subfield */
123 static int hf_repeat_time_interval;
124 static int hf_repeat_time_duration;
125 static int hf_repeat_time_offset;
126
127 /* hf_timezone subfields */
128 static int hf_timezone_time;
129 static int hf_timezone_offset;
130
131 /* hf_encryption_key subfields */
132 static int hf_encryption_key_type;
133 static int hf_encryption_key_data;
134
135 /* hf_session_attribute subfields */
136 static int hf_session_attribute_field;
137 static int hf_session_attribute_value;
138
139 /* hf_media subfields */
140 static int hf_media_media;
141 static int hf_media_port;
142 static int hf_media_port_string;
143 static int hf_media_portcount;
144 static int hf_media_proto;
145 static int hf_media_format;
146
147 /* hf_session_attribute subfields */
148 static int hf_media_attribute_field;
149 static int hf_media_attribute_value;
150 static int hf_media_encoding_name;
151 static int hf_media_sample_rate;
152 static int hf_media_channels;
153 static int hf_media_format_specific_parameter;
154 static int hf_sdp_fmtp_mpeg4_profile_level_id;
155 static int hf_sdp_fmtp_h263_profile;
156 static int hf_sdp_fmtp_h263_level;
157 static int hf_sdp_h264_packetization_mode;
158 static int hf_SDPh223LogicalChannelParameters;
159
160 /* hf_session_attribute hf_media_attribute subfields */
161 static int hf_key_mgmt_att_value;
162 static int hf_key_mgmt_prtcl_id;
163 static int hf_key_mgmt_data;
164
165 static int hf_sdp_crypto_tag;
166 static int hf_sdp_crypto_crypto_suite;
167 static int hf_sdp_crypto_master_key;
168 static int hf_sdp_crypto_master_salt;
169 static int hf_sdp_crypto_lifetime;
170 static int hf_sdp_crypto_mki;
171 static int hf_sdp_crypto_mki_length;
172
173 /* a=candidate subfields */
174 static int hf_ice_candidate_foundation;
175 static int hf_ice_candidate_componentid;
176 static int hf_ice_candidate_transport;
177 static int hf_ice_candidate_priority;
178 static int hf_ice_candidate_address;
179 static int hf_ice_candidate_port;
180 static int hf_ice_candidate_type;
181
182 /* Generated from convert_proto_tree_add_text.pl */
183 static int hf_sdp_nal_unit_2_string;
184 static int hf_sdp_key_and_salt;
185 static int hf_sdp_nal_unit_1_string;
186 static int hf_sdp_data;
187
188 /* trees */
189 static int ett_sdp;
190 static int ett_sdp_owner;
191 static int ett_sdp_connection_info;
192 static int ett_sdp_bandwidth;
193 static int ett_sdp_time;
194 static int ett_sdp_repeat_time;
195 static int ett_sdp_timezone;
196 static int ett_sdp_encryption_key;
197 static int ett_sdp_session_attribute;
198 static int ett_sdp_media;
199 static int ett_sdp_media_attribute;
200 static int ett_sdp_fmtp;
201 static int ett_sdp_key_mgmt;
202 static int ett_sdp_crypto_key_parameters;
203
204 static expert_field ei_sdp_invalid_key_param;
205 static expert_field ei_sdp_invalid_line_equal;
206 static expert_field ei_sdp_invalid_line_fields;
207 static expert_field ei_sdp_invalid_line_space;
208 static expert_field ei_sdp_invalid_conversion;
209 static expert_field ei_sdp_invalid_media_port;
210 static expert_field ei_sdp_invalid_sample_rate;
211 static expert_field ei_sdp_invalid_channels;
212 static expert_field ei_sdp_invalid_media_format;
213 static expert_field ei_sdp_invalid_crypto_tag;
214 static expert_field ei_sdp_invalid_crypto_mki_length;
215
216 /* patterns used for tvb_ws_mempbrk_pattern_uint8 */
217 static ws_mempbrk_pattern pbrk_digits;
218 static ws_mempbrk_pattern pbrk_alpha;
219
220 typedef enum {
221 SDP_PROTO_UNKNOWN = 0,
222 SDP_PROTO_RTP,
223 SDP_PROTO_SRTP,
224 SDP_PROTO_T38,
225 SDP_PROTO_MSRP,
226 SDP_PROTO_SPRT,
227 SDP_PROTO_BFCP,
228 } transport_proto_t;
229
230
231 #define SDP_MAX_RTP_CHANNELS 4
232 #define SDP_MAX_RTP_PAYLOAD_TYPES 20
233 #define SDP_NO_OF_PT 128
234 /*
235 * All parameters specific to one media description ("m=").
236 */
237 typedef struct {
238 int32_t pt[SDP_MAX_RTP_PAYLOAD_TYPES];
239 int8_t pt_count;
240 rtp_dyn_payload_t *rtp_dyn_payload;
241 bool set_rtp;
242 } transport_media_pt_t;
243
244 /*
245 * Store data extracted from one Media Description section of a SDP. Memory is
246 * allocated in wmem_file_scope().
247 */
248 typedef struct {
249 transport_proto_t proto; /**< Protocol, parsed from "m=" line. */
250 uint32_t media_types; /**< Whether "m=video" or others */
251 bool bundled; /**< "m=" lines are "bundled", that is, all on same port */
252 uint16_t media_port; /**< Port number, parsed from "m=" line. */
253 uint16_t control_port; /**< Port number, parsed from "a=rtcp" or "a=rtcp-mux" line. */
254 address conn_addr; /**< The address from the "c=" line (default
255 from session level, possibly overridden at
256 the media level). */
257 transport_media_pt_t media; /**< Information about payload numbers for this media. */
258
259 /*
260 * Media-level only attributes.
261 */
262 union {
263 struct {
264 address ipaddr;
265 uint16_t port_number;
266 } msrp; /**< MSRP transport info, parsed from "a=label:" */
267 } media_attr;
268 } media_description_t;
269
270 /*
271 * Information parsed from one or two (offer/answer) SDPs that is stored in the
272 * conversation. The contents are allocated within wmem_file_scope().
273 */
274 typedef struct {
275 enum sdp_exchange_type sdp_status;
276 char *encoding_name[SDP_NO_OF_PT];
277 int sample_rate[SDP_NO_OF_PT];
278 unsigned channels[SDP_NO_OF_PT];
279
280 /* Data parsed from "m=" */
281 wmem_array_t *media_descriptions; /* array of media_description_t */
282
283 wmem_array_t *sdp_setup_info_list; /* array of sdp_setup_info_t that refer
284 * to the same RTP conversation */
285
286 /* SRTP related info XXX note currently we only handle one crypto line in the SDP
287 * We should probably handle offer/answer and session updates etc(SIP) quite possibly the whole handling of
288 * seting up the RTP conversations should be done by the signaling protocol(s) calling the SDP dissector
289 * and the SDP dissector just provide the relevant data.
290 * YES! packet-sdp.c should be about SDP parsing... SDP *state* needs to be maintained by upper
291 * protocols, because each one has different rules/semantics.
292 */
293 unsigned encryption_algorithm;
294 unsigned auth_algorithm;
295 unsigned mki_len; /* number of octets used for the MKI in the RTP payload */
296 unsigned auth_tag_len; /* number of octets used for the Auth Tag in the RTP payload */
297 } transport_info_t;
298
299 /*
300 * Information about the session description. These are accumulated while
301 * parsing the session description and will be applied to the media description.
302 * Memory scope can be pinfo->pool since the contents are no longer
303 * needed once they are processed into transport_info_t (via
304 * complete_descriptions).
305 */
306 typedef struct {
307 address conn_addr; /**< Parsed from "c=" line. */
308 rtp_dyn_payload_t *rtp_dyn_payload; /**< Parsed from "a=rtpmap:" line.
309 Note: wmem_file_scope, needs manual dealloc. */
310 } session_info_t;
311
312 /* Structure for private data to hold ED137 related values */
313 typedef struct sdp_data_t {
314 char *ed137_type; /* Radio session type */
315 char *ed137_txrxmode; /* Tx/Rx mode */
316 char *ed137_fid; /* Frequency ID */
317 } sdp_data_t;
318
319
320 /* here lie the debugging dumper functions */
321 #ifdef DEBUG_CONVERSATION
322 static void sdp_dump_transport_media(const transport_media_pt_t* media) {
323 int i;
324 int count;
325 DPRINT2(("transport_media contents:"));
326 DINDENT();
327 if (!media) {
328 DPRINT2(("null transport_media_pt_t*"));
329 DENDENT();
330 return;
331 }
332 count = (int)media->pt_count;
333 DPRINT2(("pt_count=%d",count));
334 DINDENT();
335 for (i=0; i < count; i++) {
336 DPRINT2(("pt=%d", media->pt[i]));
337 }
338 DENDENT();
339 DPRINT2(("rtp_dyn_payload hashtable=%s", media->rtp_dyn_payload ? "YES" : "NO"));
340 if (media->rtp_dyn_payload) {
341 rtp_dump_dyn_payload(media->rtp_dyn_payload);
342 }
343 DPRINT2(("set_rtp=%s", media->set_rtp ? "TRUE" : "FALSE"));
344 DENDENT();
345 }
346
347 static const value_string sdp_exchange_type_vs[] = {
348 { SDP_EXCHANGE_OFFER, "SDP_EXCHANGE_OFFER" },
349 { SDP_EXCHANGE_ANSWER_ACCEPT, "SDP_EXCHANGE_ANSWER_ACCEPT" },
350 { SDP_EXCHANGE_ANSWER_REJECT, "SDP_EXCHANGE_ANSWER_REJECT" },
351 { 0, NULL }
352 };
353
354 static void sdp_dump_transport_info(const transport_info_t* info) {
355 int i;
356 int count;
357 DPRINT2(("transport_info contents:"));
358 DINDENT();
359 if (!info) {
360 DPRINT2(("null transport_info_t*"));
361 DENDENT();
362 return;
363 }
364 DPRINT2(("sdp_status=%s",
365 val_to_str_const(info->sdp_status, sdp_exchange_type_vs, "SDP_EXCHANGE_UNKNOWN")));
366 DPRINT2(("payload type contents:"));
367 DINDENT();
368 for (i=0; i < SDP_NO_OF_PT; i++) {
369 /* don't print out unknown encodings */
370 if (info->encoding_name[i] &&
371 strcmp(UNKNOWN_ENCODING,info->encoding_name[i]) != 0) {
372 DPRINT2(("payload type #%d:",i));
373 DINDENT();
374 DPRINT2(("encoding_name=%s", info->encoding_name[i]));
375 DPRINT2(("sample_rate=%d", info->sample_rate[i]));
376 DENDENT();
377 }
378 }
379 DENDENT();
380 count = wmem_array_get_count(info->media_descriptions);
381 DPRINT2(("media_count=%d", count));
382 DPRINT2(("rtp channels:"));
383 DINDENT();
384 for (i=0; i < count; i++) {
385 media_description_t *media_desc = (media_description_t *)wmem_array_index(info->media_descriptions, i);
386 DPRINT2(("channel #%d:",i));
387 DINDENT();
388 DPRINT2(("conn_addr=%s", address_to_str(pinfo->pool, &(media_desc->conn_addr))));
389 DPRINT2(("media_port=%d", media_desc->media_port));
390 DPRINT2(("proto=%d", media_desc->proto));
391 sdp_dump_transport_media(&(media_desc->media));
392 DENDENT();
393 }
394 DENDENT();
395 DPRINT2(("encryption_algorithm=%u", info->encryption_algorithm));
396 DPRINT2(("auth_algorithm=%u", info->auth_algorithm));
397 if (info->encryption_algorithm || info->auth_algorithm) {
398 DPRINT2(("mki_len=%u", info->mki_len));
399 if (info->auth_algorithm) {
400 DPRINT2(("auth_tag_len=%u", info->auth_tag_len));
401 }
402 }
403 DENDENT();
404 }
405
406 #endif /* DEBUG_CONVERSATION */
407
408
409 /* key-mgmt dissector
410 * IANA registry:
411 * http://www.iana.org/assignments/sdp-parameters
412 */
413 static dissector_table_t key_mgmt_dissector_table;
414
415 /* Finds next token (sequence of non-space chars) in tvb from given offset.
416 * The returned value is the token length, or 0 if none found.
417 * The offset is changed to be the starting offset, in case there were one or more
418 * spaces at the beginning. (this will also add expert info in such a case)
419 * The next_offset is set to the next found space after the token, or -1 if the
420 * end of line is hit or no token found.
421 * If this is the last token in the line, tokenlen will not be 0, but next_offset
422 * will be -1.
423 *
424 * The optional param, if true, means no expert error will be issued if no token
425 * is found; if false then a expert error will be issued if no token is found.
426 *
427 * This function expects to be given a tvb of only one line, and does no error
428 * checking of its given arguments.
429 */
430 static inline int
431 find_next_optional_token_in_line(tvbuff_t *tvb, proto_tree *tree,
432 int *offset, int *next_offset,
433 const bool optional)
434 {
435 int tokenlen = 0;
436 int next_off = -1;
437 int off = *offset;
438
439 if (tvb_offset_exists(tvb, off)) {
440 while (tokenlen == 0) {
441 next_off = tvb_find_uint8(tvb, off, -1, ' ');
442 if (next_off == -1) {
443 tokenlen = tvb_captured_length_remaining(tvb, off);
444 break; /* Nothing more left */
445 }
446
447 tokenlen = next_off - off;
448
449 if (tokenlen == 0) {
450 /* two spaces in a row - illegal, but we'll keep dissecting */
451 proto_tree_add_expert(tree, NULL, &ei_sdp_invalid_line_space, tvb, off-1, 2);
452 off = next_off + 1;
453 }
454 }
455 }
456
457 if (!optional && tokenlen == 0) {
458 proto_tree_add_expert(tree, NULL, &ei_sdp_invalid_line_fields, tvb, 0, -1);
459 }
460
461 *next_offset = next_off;
462 *offset = off;
463 return tokenlen;
464 }
465
466 /* Same as above, but always issues an expert error if a token is not found. */
467 static inline int
468 find_next_token_in_line(tvbuff_t *tvb, proto_tree *tree, int *offset, int *next_offset)
469 {
470 return find_next_optional_token_in_line(tvb, tree, offset, next_offset, false);
471 }
472
473 /* Convert the protocol from the "m=" line to something we understand. */
474 static transport_proto_t
475 parse_sdp_media_protocol(const char *media_proto)
476 {
477 /* Sorted according to the "proto" registry at
478 * https://www.iana.org/assignments/sdp-parameters/sdp-parameters.xhtml#sdp-parameters-2 */
479 const struct {
480 const char *proto_name;
481 transport_proto_t proto;
482 } protocols[] = {
483 { "RTP/AVP", SDP_PROTO_RTP }, /* RFC 4566 */
484 { "udptl", SDP_PROTO_T38 }, /* ITU-T T.38, example in Annex E */
485 { "UDPTL", SDP_PROTO_T38 }, /* Note: IANA registry contains lower case */
486 { "RTP/AVPF", SDP_PROTO_RTP }, /* RFC 4585 */
487 { "RTP/SAVP", SDP_PROTO_SRTP }, /* RFC 3711 */
488 { "RTP/SAVPF", SDP_PROTO_SRTP }, /* RFC 5124 */
489 { "UDP/TLS/RTP/SAVP", SDP_PROTO_SRTP }, /* RFC 5764 */
490 { "UDP/TLS/RTP/SAVPF", SDP_PROTO_SRTP }, /* RFC 5764 */
491 { "msrp/tcp", SDP_PROTO_MSRP }, /* Not in IANA, where is this from? */
492 { "UDPSPRT", SDP_PROTO_SPRT }, /* Not in IANA, but draft-rajeshkumar-avt-v150-registration-00 */
493 { "udpsprt", SDP_PROTO_SPRT }, /* lowercase per section E.1.1 of ITU-T V.150.1 */
494 { "udpsprt", SDP_PROTO_SPRT }, /* lowercase per section E.1.1 of ITU-T V.150.1 */
495 { "UDP/BFCP", SDP_PROTO_BFCP }, /* RFC 8856 */
496 };
497
498 for (unsigned i = 0; i < G_N_ELEMENTS(protocols); i++) {
499 if (!strcmp(protocols[i].proto_name, media_proto)) {
500 return protocols[i].proto;
501 }
502 }
503
504 return SDP_PROTO_UNKNOWN;
505 }
506
507 /* Parses the parts from "c=" into address structures. */
508 static void
509 parse_sdp_connection_address(const uint8_t *connection_type, const char *connection_address,
510 wmem_allocator_t *allocator, address *conn_addr)
511 {
512 if (strcmp(connection_type, "IP4") == 0) {
513 uint32_t ip4_addr;
514
515 if (str_to_ip(connection_address, &ip4_addr)) {
516 /* connection_address could be converted to a valid ipv4 address*/
517 alloc_address_wmem(allocator, conn_addr, AT_IPv4, 4, &ip4_addr);
518 }
519 } else if (strcmp(connection_type, "IP6") == 0) {
520 ws_in6_addr ip6_addr;
521
522 if (str_to_ip6(connection_address, &ip6_addr)) {
523 /* connection_address could be converted to a valid ipv6 address*/
524 alloc_address_wmem(allocator, conn_addr, AT_IPv6, 16, &ip6_addr);
525 }
526 }
527 }
528
529 /**
530 * Starts a new media description. If there are too many media descriptions,
531 * no new media description is started and NULL is returned.
532 */
533 static media_description_t *
534 sdp_new_media_description(wmem_array_t *media_descriptions, session_info_t *session_info)
535 {
536 media_description_t empty_desc;
537 media_description_t *media_desc;
538
539 /* Limit number to avoid consuming excess memory. */
540 if (wmem_array_get_count(media_descriptions) >= SDP_MAX_RTP_CHANNELS) {
541 DPRINT(("Too many media descriptions (more than %d), returning NULL!",
542 wmem_array_get_count(media_descriptions)));
543 return NULL;
544 }
545
546 memset(&empty_desc, 0, sizeof(media_description_t));
547 wmem_array_append_one(media_descriptions, empty_desc);
548 media_desc = (media_description_t *) wmem_array_index(media_descriptions,
549 wmem_array_get_count(media_descriptions) - 1);
550
551 /* XXX does it make sense making media_desc->media.pt a wmem array? */
552
553 /* If "c=" is given at the session level, copy it to the media description.
554 * It will be overridden as needed. */
555 if (session_info->conn_addr.type != AT_NONE) {
556 copy_address_wmem(wmem_file_scope(), &media_desc->conn_addr, &session_info->conn_addr);
557 }
558
559 /* If "a=rtpmap:" was set on the session level, copy them to media level. */
560 media_desc->media.rtp_dyn_payload =
561 rtp_dyn_payload_dup(session_info->rtp_dyn_payload);
562
563 return media_desc;
564 }
565
566 /* Remove information about media descriptions which are unused. These appeared
567 * in the "a=rtpmap:" (and maybe even in the payload types part of "m="?), but
568 * are not used (port is zero or it was not assigned to RTP dissector). */
569 static void
570 clean_unused_media_descriptions(wmem_array_t *descs)
571 {
572 for (unsigned i = 0; i < wmem_array_get_count(descs); i++) {
573 media_description_t *media_desc = (media_description_t *)wmem_array_index(descs, i);
574
575 /* If not assigned to subdissector, clear the unused information. */
576 if (!media_desc->media.set_rtp) {
577 rtp_dyn_payload_free(media_desc->media.rtp_dyn_payload);
578 media_desc->media.rtp_dyn_payload = NULL;
579 }
580 }
581 }
582
583
584 /* Subdissector functions */
585 static void
586 dissect_sdp_owner(tvbuff_t *tvb, proto_item *ti) {
587 proto_tree *sdp_owner_tree;
588 int offset, next_offset, tokenlen;
589
590 offset = 0;
591
592 sdp_owner_tree = proto_item_add_subtree(ti, ett_sdp_owner);
593
594 /* Find the username */
595 tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);
596 if (tokenlen == 0)
597 return;
598
599 proto_tree_add_item(sdp_owner_tree, hf_owner_username, tvb, offset, tokenlen,
600 ENC_UTF_8);
601 offset = next_offset + 1;
602
603 /* Find the session id */
604 tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);
605 if (tokenlen == 0)
606 return;
607
608 proto_tree_add_item(sdp_owner_tree, hf_owner_sessionid, tvb, offset,
609 tokenlen, ENC_UTF_8);
610 offset = next_offset + 1;
611
612 /* Find the version */
613 tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);
614 if (tokenlen == 0)
615 return;
616
617 proto_tree_add_item(sdp_owner_tree, hf_owner_version, tvb, offset, tokenlen,
618 ENC_UTF_8);
619 offset = next_offset + 1;
620
621 /* Find the network type */
622 tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);
623 if (tokenlen == 0)
624 return;
625
626 proto_tree_add_item(sdp_owner_tree, hf_owner_network_type, tvb, offset,
627 tokenlen, ENC_UTF_8);
628 offset = next_offset + 1;
629
630 /* Find the address type */
631 tokenlen = find_next_token_in_line(tvb, sdp_owner_tree, &offset, &next_offset);
632 if (tokenlen == 0)
633 return;
634
635 proto_tree_add_item(sdp_owner_tree, hf_owner_address_type, tvb, offset,
636 tokenlen, ENC_UTF_8);
637 offset = next_offset + 1;
638
639 /* Find the address */
640 proto_tree_add_item(sdp_owner_tree, hf_owner_address, tvb, offset, -1, ENC_UTF_8);
641 }
642
643 /*
644 * XXX - this can leak memory if an exception is thrown after we've fetched
645 * a string.
646 */
647 static void
648 dissect_sdp_connection_info(packet_info *pinfo, tvbuff_t *tvb, proto_item* ti, session_info_t *session_info, media_description_t *media_desc)
649 {
650 proto_tree *sdp_connection_info_tree;
651 int offset, next_offset, tokenlen;
652 const uint8_t *connection_type, *connection_address;
653
654 offset = 0;
655
656 sdp_connection_info_tree = proto_item_add_subtree(ti,
657 ett_sdp_connection_info);
658
659 /* Find the network type */
660 tokenlen = find_next_token_in_line(tvb, sdp_connection_info_tree, &offset, &next_offset);
661 if (tokenlen == 0)
662 return;
663
664 proto_tree_add_item(sdp_connection_info_tree,
665 hf_connection_info_network_type, tvb, offset, tokenlen,
666 ENC_UTF_8);
667 offset = next_offset + 1;
668
669 /* Find the address type */
670 tokenlen = find_next_token_in_line(tvb, sdp_connection_info_tree, &offset, &next_offset);
671 if (tokenlen == 0)
672 return;
673
674 /* Save connection address type */
675 proto_tree_add_item_ret_string(sdp_connection_info_tree,
676 hf_connection_info_address_type, tvb, offset, tokenlen,
677 ENC_UTF_8|ENC_NA, pinfo->pool, &connection_type);
678 DPRINT(("parsed connection line type=%s", connection_type));
679 offset = next_offset + 1;
680
681 /* Find the connection address */
682 /* XXX - what if there's a <number of addresses> value? */
683 next_offset = tvb_find_uint8(tvb, offset, -1, '/');
684 if (next_offset == -1) {
685 tokenlen = -1; /* end of tvbuff */
686 /* Save connection address */
687 connection_address = tvb_get_string_enc(pinfo->pool, tvb, offset, tvb_captured_length_remaining(tvb, offset), ENC_UTF_8|ENC_NA);
688 } else {
689 tokenlen = next_offset - offset;
690 /* Save connection address */
691 connection_address = tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA);
692 }
693
694 DPRINT(("parsed connection line address=%s", connection_address));
695 /* Parse and store connection address. Session-level addresses are
696 * packet-scoped since they will be cloned in file-scope when needed. */
697 if (session_info) {
698 parse_sdp_connection_address(connection_type, connection_address,
699 pinfo->pool,
700 &session_info->conn_addr);
701 } else if (media_desc) {
702 /* Clear possibly inherited address from session level. */
703 free_address_wmem(wmem_file_scope(), &media_desc->conn_addr);
704
705 parse_sdp_connection_address(connection_type, connection_address,
706 wmem_file_scope(),
707 &media_desc->conn_addr);
708 }
709
710 proto_tree_add_item(sdp_connection_info_tree,
711 hf_connection_info_connection_address, tvb, offset,
712 tokenlen, ENC_UTF_8);
713 if (next_offset != -1) {
714 offset = next_offset + 1;
715 next_offset = tvb_find_uint8(tvb, offset, -1, '/');
716 if (next_offset == -1) {
717 tokenlen = -1; /* end of tvbuff */
718 } else {
719 tokenlen = next_offset - offset;
720 }
721 proto_tree_add_item(sdp_connection_info_tree,
722 hf_connection_info_ttl, tvb, offset, tokenlen, ENC_UTF_8);
723 if (next_offset != -1) {
724 offset = next_offset + 1;
725 proto_tree_add_item(sdp_connection_info_tree,
726 hf_connection_info_num_addr, tvb, offset, -1, ENC_UTF_8);
727 }
728 }
729 }
730
731 static void
732 dissect_sdp_bandwidth(tvbuff_t *tvb, proto_item *ti) {
733 proto_tree *sdp_bandwidth_tree;
734 int offset, next_offset, tokenlen;
735 proto_item *item;
736 bool unit_is_kbs = false;
737 bool unit_is_bps = false;
738
739 offset = 0;
740
741 sdp_bandwidth_tree = proto_item_add_subtree(ti, ett_sdp_bandwidth);
742
743 /* find the modifier */
744 next_offset = tvb_find_uint8(tvb, offset, -1, ':');
745
746 if (next_offset == -1)
747 return;
748
749 tokenlen = next_offset - offset;
750
751 item = proto_tree_add_item(sdp_bandwidth_tree, hf_bandwidth_modifier, tvb, offset,
752 tokenlen, ENC_UTF_8);
753 if (tvb_strneql(tvb, offset, "CT", 2) == 0) {
754 proto_item_append_text(item, " [Conference Total(total bandwidth of all RTP sessions)]");
755 unit_is_kbs = true;
756 } else if (tvb_strneql(tvb, offset, "AS", 2) == 0) {
757 proto_item_append_text(item, " [Application Specific (RTP session bandwidth)]");
758 unit_is_kbs = true;
759 } else if (tvb_strneql(tvb, offset, "TIAS", 4) == 0) {
760 proto_item_append_text(item, " [Transport Independent Application Specific maximum]");
761 unit_is_bps = true;
762 }
763
764
765 offset = next_offset + 1;
766
767 item = proto_tree_add_item(sdp_bandwidth_tree, hf_bandwidth_value, tvb, offset, -1,
768 ENC_UTF_8);
769 if (unit_is_kbs == true)
770 proto_item_append_text(item, " kb/s");
771 if (unit_is_bps == true)
772 proto_item_append_text(item, " b/s");
773 }
774
775 static void dissect_sdp_time(tvbuff_t *tvb, proto_item* ti) {
776 proto_tree *sdp_time_tree;
777 int offset, next_offset, tokenlen;
778
779 offset = 0;
780
781 sdp_time_tree = proto_item_add_subtree(ti, ett_sdp_time);
782
783 /* get start time */
784 tokenlen = find_next_token_in_line(tvb, sdp_time_tree, &offset, &next_offset);
785 if (tokenlen == 0)
786 return;
787
788 proto_tree_add_item(sdp_time_tree, hf_time_start, tvb, offset, tokenlen,
789 ENC_UTF_8);
790
791 /* get stop time */
792 offset = next_offset + 1;
793 proto_tree_add_item(sdp_time_tree, hf_time_stop, tvb, offset, -1, ENC_UTF_8);
794 }
795
796 static void dissect_sdp_repeat_time(tvbuff_t *tvb, proto_item* ti) {
797 proto_tree *sdp_repeat_time_tree;
798 int offset, next_offset, tokenlen;
799 bool optional = false;
800
801 offset = 0;
802
803 sdp_repeat_time_tree = proto_item_add_subtree(ti, ett_sdp_time);
804
805 /* get interval */
806 tokenlen = find_next_token_in_line(tvb, sdp_repeat_time_tree, &offset, &next_offset);
807 if (tokenlen == 0)
808 return;
809
810 proto_tree_add_item(sdp_repeat_time_tree, hf_repeat_time_interval, tvb,
811 offset, tokenlen, ENC_UTF_8);
812
813 /* get duration */
814 offset = next_offset + 1;
815 tokenlen = find_next_token_in_line(tvb, sdp_repeat_time_tree, &offset, &next_offset);
816 if (tokenlen == 0)
817 return;
818
819 proto_tree_add_item(sdp_repeat_time_tree, hf_repeat_time_duration, tvb,
820 offset, tokenlen, ENC_UTF_8);
821
822 /* get offsets */
823 do {
824 offset = next_offset +1;
825 tokenlen = find_next_optional_token_in_line(tvb, sdp_repeat_time_tree,
826 &offset, &next_offset, optional);
827 if (tokenlen == 0)
828 break;
829 proto_tree_add_item(sdp_repeat_time_tree, hf_repeat_time_offset,
830 tvb, offset, tokenlen, ENC_UTF_8);
831 optional = true;
832 } while (next_offset != -1);
833
834 }
835
836 static void
837 dissect_sdp_timezone(tvbuff_t *tvb, proto_item* ti) {
838 proto_tree* sdp_timezone_tree;
839 int offset, next_offset, tokenlen;
840 bool optional = false;
841
842 offset = 0;
843
844 sdp_timezone_tree = proto_item_add_subtree(ti, ett_sdp_timezone);
845
846 do {
847 tokenlen = find_next_optional_token_in_line(tvb, sdp_timezone_tree,
848 &offset, &next_offset, optional);
849 if (tokenlen == 0)
850 break;
851
852 proto_tree_add_item(sdp_timezone_tree, hf_timezone_time, tvb, offset,
853 tokenlen, ENC_UTF_8);
854 offset = next_offset + 1;
855 tokenlen = find_next_optional_token_in_line(tvb, sdp_timezone_tree,
856 &offset, &next_offset, optional);
857 if (tokenlen == 0)
858 break;
859 proto_tree_add_item(sdp_timezone_tree, hf_timezone_offset, tvb, offset,
860 tokenlen, ENC_UTF_8);
861 offset = next_offset + 1;
862 optional = true;
863 } while (next_offset != -1);
864
865 }
866
867
868 static void dissect_sdp_encryption_key(tvbuff_t *tvb, proto_item * ti) {
869 proto_tree *sdp_encryption_key_tree;
870 int offset, next_offset, tokenlen;
871
872 offset = 0;
873
874 sdp_encryption_key_tree = proto_item_add_subtree(ti, ett_sdp_encryption_key);
875
876 next_offset = tvb_find_uint8(tvb, offset, -1, ':');
877
878 if (next_offset == -1)
879 return;
880
881 tokenlen = next_offset - offset;
882
883 proto_tree_add_item(sdp_encryption_key_tree, hf_encryption_key_type,
884 tvb, offset, tokenlen, ENC_UTF_8);
885
886 offset = next_offset + 1;
887 proto_tree_add_item(sdp_encryption_key_tree, hf_encryption_key_data,
888 tvb, offset, -1, ENC_UTF_8);
889 }
890
891 static void dissect_key_mgmt(tvbuff_t *tvb, packet_info * pinfo, proto_item * ti) {
892 char *data_p = NULL;
893 const uint8_t *prtcl_id = NULL;
894 int len;
895 tvbuff_t *keymgmt_tvb;
896 int found_match = 0;
897 proto_tree *key_tree;
898 int next_offset;
899 int offset = 0;
900 int tokenlen;
901
902 key_tree = proto_item_add_subtree(ti, ett_sdp_key_mgmt);
903
904 tokenlen = find_next_token_in_line(tvb, key_tree, &offset, &next_offset);
905 if (tokenlen == 0)
906 return;
907
908 proto_tree_add_item_ret_string(key_tree, hf_key_mgmt_prtcl_id, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA, pinfo->pool, &prtcl_id);
909
910 offset = next_offset + 1;
911
912 len = tvb_captured_length_remaining(tvb, offset);
913 if (len < 0)
914 return;
915
916 data_p = (char *)tvb_get_string_enc(pinfo->pool, tvb, offset, len, ENC_UTF_8|ENC_NA);
917 keymgmt_tvb = base64_to_tvb(tvb, data_p);
918 add_new_data_source(pinfo, keymgmt_tvb, "Key Management Data");
919
920 if ((prtcl_id != NULL) && (key_mgmt_dissector_table != NULL)) {
921 found_match = dissector_try_string(key_mgmt_dissector_table,
922 (const char *)prtcl_id,
923 keymgmt_tvb, pinfo,
924 key_tree, NULL);
925 }
926
927 if (found_match) {
928 proto_item *ti2 = proto_tree_add_item(key_tree, hf_key_mgmt_data,
929 keymgmt_tvb, 0, -1, ENC_NA);
930 proto_item_set_hidden(ti2);
931 } else {
932 proto_tree_add_item(key_tree, hf_key_mgmt_data,
933 keymgmt_tvb, 0, -1, ENC_NA);
934 }
935
936 }
937
938
939 static void dissect_sdp_session_attribute(tvbuff_t *tvb, packet_info * pinfo, proto_item * ti) {
940 proto_tree *sdp_session_attribute_tree;
941 int offset, next_offset, tokenlen;
942 const uint8_t *field_name;
943
944 offset = 0;
945
946 sdp_session_attribute_tree = proto_item_add_subtree(ti,
947 ett_sdp_session_attribute);
948
949 next_offset = tvb_find_uint8(tvb, offset, -1, ':');
950
951 if (next_offset == -1)
952 return;
953
954 tokenlen = next_offset - offset;
955
956 proto_tree_add_item_ret_string(sdp_session_attribute_tree, hf_session_attribute_field,
957 tvb, offset, tokenlen, ENC_UTF_8|ENC_NA, pinfo->pool, &field_name);
958
959 offset = next_offset + 1;
960
961 if (tvb_captured_length_remaining(tvb, offset) == 0) {
962 expert_add_info(pinfo, ti, &ei_sdp_invalid_line_fields);
963 return;
964 }
965
966 if (strcmp((const char *)field_name, "ipbcp") == 0) {
967 offset = tvb_ws_mempbrk_pattern_uint8(tvb, offset, -1,&pbrk_digits, NULL);
968
969 if (offset == -1)
970 return;
971
972 tokenlen = find_next_token_in_line(tvb, sdp_session_attribute_tree, &offset, &next_offset);
973 if (tokenlen == 0)
974 return;
975
976 proto_tree_add_item(sdp_session_attribute_tree, hf_ipbcp_version, tvb, offset, tokenlen, ENC_UTF_8);
977
978 offset = tvb_ws_mempbrk_pattern_uint8(tvb, offset, -1,&pbrk_alpha, NULL);
979
980 if (offset == -1)
981 return;
982
983 tokenlen = tvb_find_line_end(tvb, offset, -1, &next_offset, false);
984
985 if (tokenlen == -1)
986 return;
987
988 proto_tree_add_item(sdp_session_attribute_tree, hf_ipbcp_type, tvb, offset, tokenlen, ENC_UTF_8);
989 } else if (strcmp((const char *)field_name, "key-mgmt") == 0) {
990 tvbuff_t *key_tvb;
991 proto_item *key_ti;
992
993 key_tvb = tvb_new_subset_remaining(tvb, offset);
994 key_ti = proto_tree_add_item(sdp_session_attribute_tree, hf_key_mgmt_att_value, key_tvb, 0, -1, ENC_UTF_8);
995
996 dissect_key_mgmt(key_tvb, pinfo, key_ti);
997 } else {
998 proto_tree_add_item(sdp_session_attribute_tree, hf_session_attribute_value,
999 tvb, offset, -1, ENC_UTF_8);
1000 }
1001 }
1002
1003
1004 /* Dissect media description - this is passed the line starting after 'm=', so like one of these:
1005 * audio 29156 RTP/AVP 18 0
1006 * video 49170/2 RTP/AVP 31 99
1007 */
1008 static void
1009 dissect_sdp_media(tvbuff_t *tvb, packet_info* pinfo, proto_item *ti,
1010 media_description_t *media_desc) {
1011 proto_tree *sdp_media_tree;
1012 int offset, next_offset, tokenlen, idx;
1013 uint8_t *media_format;
1014 bool optional = false;
1015 proto_item *it;
1016 const uint8_t *media_type_str;
1017 const uint8_t *media_port_str;
1018 const uint8_t *media_proto_str;
1019 transport_proto_t transport_proto;
1020 uint16_t media_port;
1021 bool media_port_valid;
1022 proto_item *pi;
1023
1024 offset = 0;
1025
1026 /* Create tree for media session */
1027 sdp_media_tree = proto_item_add_subtree(ti, ett_sdp_media);
1028
1029 tokenlen = find_next_token_in_line(tvb, sdp_media_tree, &offset, &next_offset);
1030 if (tokenlen == 0)
1031 return;
1032
1033 /* Type of media session */
1034 proto_tree_add_item_ret_string(sdp_media_tree, hf_media_media, tvb, offset, tokenlen,
1035 ENC_UTF_8|ENC_NA, pinfo->pool, &media_type_str);
1036 if (media_desc) {
1037 /* for RTP statistics (supposedly?) */
1038 if (strcmp((const char*)media_type_str, "audio") == 0)
1039 media_desc->media_types |= RTP_MEDIA_AUDIO;
1040 else if (strcmp((const char*)media_type_str, "video") == 0)
1041 media_desc->media_types |= RTP_MEDIA_VIDEO;
1042 else
1043 media_desc->media_types |= RTP_MEDIA_OTHER;
1044 }
1045 DPRINT(("parsed media_type=%s", media_type_str));
1046
1047 offset = next_offset + 1;
1048
1049 tokenlen = find_next_token_in_line(tvb, sdp_media_tree, &offset, &next_offset);
1050 if (tokenlen == 0)
1051 return;
1052
1053 next_offset = tvb_find_uint8(tvb, offset, tokenlen, '/');
1054
1055 if (next_offset != -1) {
1056 tokenlen = next_offset - offset;
1057 /* Save port info */
1058 it = proto_tree_add_item_ret_string(sdp_media_tree, hf_media_port_string, tvb, offset, tokenlen,
1059 ENC_UTF_8|ENC_NA, pinfo->pool, &media_port_str);
1060 DPRINT(("parsed media_port=%s", media_port_str));
1061 if (g_ascii_isdigit(media_port_str[0])) {
1062 proto_item_set_hidden(it);
1063 media_port_valid = ws_strtou16(media_port_str, NULL, &media_port);
1064 pi = proto_tree_add_uint(sdp_media_tree, hf_media_port, tvb, offset, tokenlen,
1065 media_port);
1066 if (!media_port_valid)
1067 expert_add_info(pinfo, pi, &ei_sdp_invalid_media_port);
1068 if (media_desc) {
1069 media_desc->media_port = media_port;
1070 }
1071 }
1072
1073 offset = next_offset + 1;
1074 tokenlen = find_next_token_in_line(tvb, sdp_media_tree, &offset, &next_offset);
1075 if (tokenlen == 0)
1076 return;
1077
1078 /* TODO: this puts the (optional) number of ports in the tree, but we don't
1079 actually use it for building the extra RTP flows, which we should. */
1080 proto_tree_add_item(sdp_media_tree, hf_media_portcount, tvb, offset,
1081 tokenlen, ENC_UTF_8);
1082 offset = next_offset + 1;
1083 } else {
1084 tokenlen = find_next_token_in_line(tvb, sdp_media_tree, &offset, &next_offset);
1085 if (tokenlen == 0)
1086 return;
1087
1088 /* Save port info */
1089 it = proto_tree_add_item_ret_string(sdp_media_tree, hf_media_port_string, tvb, offset, tokenlen,
1090 ENC_UTF_8|ENC_NA, pinfo->pool, &media_port_str);
1091 DPRINT(("parsed media_port=%s", media_port_str));
1092 if (g_ascii_isdigit(media_port_str[0])) {
1093 proto_item_set_hidden(it);
1094 media_port_valid = ws_strtou16(media_port_str, NULL, &media_port);
1095 pi = proto_tree_add_uint(sdp_media_tree, hf_media_port, tvb, offset, tokenlen,
1096 media_port);
1097 if (!media_port_valid)
1098 expert_add_info(pinfo, pi, &ei_sdp_invalid_media_port);
1099 if (media_desc) {
1100 media_desc->media_port = media_port;
1101 }
1102 }
1103 offset = next_offset + 1;
1104 }
1105
1106 tokenlen = find_next_token_in_line(tvb, sdp_media_tree, &offset, &next_offset);
1107 if (tokenlen == 0)
1108 return;
1109
1110 /* Save port protocol */
1111 proto_tree_add_item_ret_string(sdp_media_tree, hf_media_proto, tvb, offset, tokenlen,
1112 ENC_UTF_8|ENC_NA, pinfo->pool, &media_proto_str);
1113 DPRINT(("parsed media_proto=%s", media_proto_str));
1114 /* Detect protocol for registering with other dissectors like RTP. */
1115 transport_proto = parse_sdp_media_protocol(media_proto_str);
1116 if (media_desc) {
1117 media_desc->proto = transport_proto;
1118 }
1119
1120 do {
1121 offset = next_offset + 1;
1122 tokenlen = find_next_optional_token_in_line(tvb, sdp_media_tree,
1123 &offset, &next_offset, optional);
1124 if (tokenlen == 0)
1125 break;
1126
1127 /* RFC 4566: If the <proto> sub-field is "RTP/AVP" or "RTP/SAVP" the
1128 * <fmt> sub-fields contain RTP payload type numbers. */
1129 if (transport_proto == SDP_PROTO_RTP || transport_proto == SDP_PROTO_SRTP) {
1130 media_format = tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA);
1131 if (g_ascii_isdigit(media_format[0])) {
1132 proto_tree_add_string(sdp_media_tree, hf_media_format, tvb, offset,
1133 tokenlen, val_to_str_ext((uint32_t)strtoul((char*)media_format, NULL, 10), &rtp_payload_type_vals_ext, "%u"));
1134
1135 if (media_desc) {
1136 idx = media_desc->media.pt_count;
1137 media_desc->media.pt[idx] = (int32_t)strtol((char*)media_format, NULL, 10);
1138 DPRINT(("parsed media codec pt=%d", media_desc->media.pt[idx]));
1139 if (idx < (SDP_MAX_RTP_PAYLOAD_TYPES-1))
1140 media_desc->media.pt_count++;
1141 }
1142 } else {
1143 proto_tree_add_item(sdp_media_tree, hf_media_format, tvb, offset,
1144 tokenlen, ENC_UTF_8);
1145 }
1146 } else {
1147 proto_tree_add_item(sdp_media_tree, hf_media_format, tvb, offset,
1148 tokenlen, ENC_UTF_8);
1149 }
1150 optional = true;
1151 } while (next_offset != -1);
1152
1153 /* XXX Dissect traffic to "Port" as "Protocol"
1154 * Remember this Port/Protocol pair so we can tear it down again later
1155 * Actually, it's harder than that:
1156 * We need to find out the address of the other side first and it
1157 * looks like that info can be found in SIP headers only.
1158 */
1159
1160 }
1161
1162 static tvbuff_t *
1163 ascii_bytes_to_tvb(tvbuff_t *tvb, packet_info *pinfo, char *msg)
1164 {
1165 size_t nbytes;
1166 uint8_t *buf = convert_string_to_hex(msg, &nbytes);
1167 if (buf) {
1168 tvbuff_t *bytes_tvb;
1169
1170 bytes_tvb = tvb_new_child_real_data(tvb, buf, (unsigned)nbytes, (unsigned)nbytes);
1171 tvb_set_free_cb(bytes_tvb, g_free);
1172 add_new_data_source(pinfo, bytes_tvb, "ASCII bytes to tvb");
1173 return bytes_tvb;
1174 }
1175 return NULL;
1176 }
1177
1178 /* Annex X Profiles and levels definition */
1179 static const value_string h263_profile_vals[] =
1180 {
1181 { 0, "Baseline Profile" },
1182 { 1, "H.320 Coding Efficiency Version 2 Backward-Compatibility Profile" },
1183 { 2, "Version 1 Backward-Compatibility Profile" },
1184 { 3, "Version 2 Interactive and Streaming Wireless Profile" },
1185 { 4, "Version 3 Interactive and Streaming Wireless Profile" },
1186 { 5, "Conversational High Compression Profile" },
1187 { 6, "Conversational Internet Profile" },
1188 { 7, "Conversational Interlace Profile" },
1189 { 8, "High Latency Profile" },
1190 { 0, NULL },
1191 };
1192
1193
1194 /* RFC 4629 The level are described in table X.2 of H.263 annex X */
1195 static const value_string h263_level_vals[] =
1196 {
1197 { 10, "QCIF (176 x 144), 1 x 64Kb/s" },
1198 { 20, "CIF (352 x 288), 2 x 64Kb/s" },
1199 { 30, "CIF (352 x 288), 6 x 64Kb/s" },
1200 { 40, "CIF (352 x 288), 32 x 64Kb/s" },
1201 { 45, "QCIF (176 x144) support of CPFMT, 2 x 64Kb/s" },
1202 { 50, "CIF (352 x 288) support of CPFMT, 64 x 64Kb/s" },
1203 { 60, "CPFMT: 720 x 288 support of CPFMT, 128 x 64Kb/s" },
1204 { 70, "CPFMT: 720 x 576 support of CPFMT, 256 x 64Kb/s" },
1205 { 0, NULL },
1206 };
1207
1208
1209 static const value_string h264_packetization_mode_vals[] =
1210 {
1211 { 0, "Single NAL mode" },
1212 { 1, "Non-interleaved mode" },
1213 { 2, "Interleaved mode" },
1214 { 0, NULL },
1215 };
1216
1217 /*
1218 * TODO: Make this a more generic routine to dissect fmtp parameters depending on media types
1219 */
1220 static void
1221 decode_sdp_fmtp(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset, int tokenlen, uint8_t pt, transport_info_t *transport_info, rtp_dyn_payload_t *rtp_dyn_payload) {
1222 int next_offset;
1223 int end_offset;
1224 uint8_t *field_name;
1225 char *format_specific_parameter;
1226 proto_item *item;
1227 tvbuff_t * volatile data_tvb;
1228
1229 const char *mime_type = transport_info->encoding_name[pt];
1230 end_offset = offset + tokenlen;
1231
1232 #if 0
1233 proto_tree_add_debug(tree, tvb, offset, tokenlen, "Debug; Analysed string: '%s'",
1234 tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_ASCII));
1235 #endif
1236
1237 /* Look for an '=' within this string - RFC 4855 suggets that parameters
1238 be "parameter=value" pairs. We'll store them in a hash map from the
1239 parameter name to the value, as well as dissect some of them here,
1240 depending on the media type.
1241 */
1242 next_offset = tvb_find_uint8(tvb, offset, tokenlen, '=');
1243 if (next_offset == -1)
1244 {
1245 /* Some media types, like telephone-event and RED, don't have the
1246 * "parameter=value" syntax:
1247 * https://datatracker.ietf.org/doc/html/rfc4733
1248 * 2.4.1. "Relationship to SDP"
1249 * "The "events" media type parameter deviates from the convention
1250 * suggested in RFC 3555 because it omits the string "events=" before
1251 * the list of supported events."
1252 * https://www.iana.org/assignments/media-types/audio/RED
1253 * We'll handle them with the empty string as the parameter name.
1254 * The media types should know how to deal with that, if necessary.
1255 */
1256 field_name = wmem_strdup(pinfo->pool, "");
1257 } else {
1258 /* Find the name of the parameter */
1259 tokenlen = next_offset - offset;
1260 field_name = tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_UTF_8);
1261
1262 #if 0
1263 proto_tree_add_debug(tree, tvb, offset, tokenlen, "Debug; MIMEtype '%s'Parameter name: '%s'", mime_type, field_name); */
1264 #endif
1265
1266 /* Move past the '=' */
1267 offset = next_offset + 1;
1268 }
1269
1270 /* Get the value */
1271 tokenlen = end_offset - offset;
1272 format_specific_parameter = tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_UTF_8);
1273
1274 if (rtp_dyn_payload) {
1275 rtp_dyn_payload_add_fmtp(rtp_dyn_payload, pt,
1276 field_name,
1277 format_specific_parameter);
1278 }
1279
1280 /* Dissect the MPEG4 profile-level-id parameter if present */
1281 if ((mime_type != NULL) && (g_ascii_strcasecmp(mime_type, "MP4V-ES") == 0)) {
1282 if (strcmp((char*)field_name, "profile-level-id") == 0) {
1283 item = proto_tree_add_uint(tree, hf_sdp_fmtp_mpeg4_profile_level_id, tvb, offset, tokenlen,
1284 (uint32_t)strtol((char*)format_specific_parameter, NULL, 10));
1285 proto_item_set_generated(item);
1286 } else if (strcmp((char*)field_name, "config") == 0) {
1287 data_tvb = ascii_bytes_to_tvb(tvb, pinfo, format_specific_parameter);
1288 if (mp4ves_config_handle && data_tvb) {
1289 call_dissector(mp4ves_config_handle, data_tvb, pinfo, tree);
1290 }
1291 }
1292 }
1293
1294 /* Dissect the H263-2000 profile parameter if present */
1295 if (((mime_type != NULL) && (g_ascii_strcasecmp(mime_type, "H263-2000") == 0)) ||
1296 ((mime_type != NULL) && (g_ascii_strcasecmp(mime_type, "H263-1998") == 0))) {
1297 if (strcmp((char*)field_name, "profile") == 0) {
1298 item = proto_tree_add_uint(tree, hf_sdp_fmtp_h263_profile, tvb, offset, tokenlen,
1299 (uint32_t)strtol((char*)format_specific_parameter, NULL, 10));
1300 proto_item_set_generated(item);
1301 } else if (strcmp((char*)field_name, "level") == 0) {
1302 item = proto_tree_add_uint(tree, hf_sdp_fmtp_h263_level, tvb, offset, tokenlen,
1303 (uint32_t)strtol((char*)format_specific_parameter, NULL, 10));
1304 proto_item_set_generated(item);
1305 }
1306 }
1307
1308
1309 /* Dissect the H264 profile-level-id parameter
1310 * RFC 3984:
1311 * A base16 [6] (hexadecimal) representation of
1312 * the following three bytes in the sequence
1313 * parameter set NAL unit specified in [1]: 1)
1314 * profile_idc, 2) a byte herein referred to as
1315 * profile-iop, composed of the values of
1316 * constraint_set0_flag, constraint_set1_flag,
1317 * constraint_set2_flag, and reserved_zero_5bits
1318 * in bit-significance order, starting from the
1319 * most significant bit, and 3) level_idc.
1320 */
1321 if ((mime_type != NULL) && ((g_ascii_strcasecmp(mime_type, "H264") == 0) || (g_ascii_strcasecmp(mime_type, "H264-SVC") == 0))) {
1322 if (strcmp(field_name, "profile-level-id") == 0) {
1323 int length = 0;
1324
1325 data_tvb = ascii_bytes_to_tvb(tvb, pinfo, format_specific_parameter);
1326 if (!data_tvb) {
1327 proto_tree_add_expert_format(tree, pinfo, &ei_sdp_invalid_conversion, tvb, offset, tokenlen, "Could not convert '%s' to 3 bytes", format_specific_parameter);
1328 return;
1329 }
1330 length = tvb_reported_length(data_tvb);
1331 if (length == 3) {
1332 if (h264_handle && data_tvb) {
1333 dissect_h264_profile(data_tvb, pinfo, tree);
1334 }
1335 } else {
1336 item = proto_tree_add_expert_format(tree, pinfo, &ei_sdp_invalid_conversion, tvb, offset, tokenlen, "Incorrectly coded, must be three bytes");
1337 proto_item_set_generated(item);
1338 }
1339 } else if (strcmp(field_name, "packetization-mode") == 0) {
1340 item = proto_tree_add_uint(tree, hf_sdp_h264_packetization_mode, tvb, offset, tokenlen,
1341 (uint32_t)strtol((char*)format_specific_parameter, NULL, 10));
1342 proto_item_set_generated(item);
1343 } else if (strcmp(field_name, "sprop-parameter-sets") == 0) {
1344 /* The value of the parameter is the
1345 base64 [6] representation of the initial
1346 parameter set NAL units as specified in
1347 sections 7.3.2.1 and 7.3.2.2 of [1]. The
1348 parameter sets are conveyed in decoding order,
1349 and no framing of the parameter set NAL units
1350 takes place. A comma is used to separate any
1351 pair of parameter sets in the list.
1352 */
1353 const uint8_t *data_p = NULL;
1354 int comma_offset;
1355
1356 comma_offset = tvb_find_uint8(tvb, offset, -1, ',');
1357 if (comma_offset != -1) {
1358 tokenlen = comma_offset - offset;
1359 } else {
1360 tokenlen = end_offset - offset;
1361 }
1362
1363 proto_tree_add_item_ret_string(tree, hf_sdp_nal_unit_1_string, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA, pinfo->pool, &data_p);
1364
1365 data_tvb = base64_to_tvb(tvb, data_p);
1366 add_new_data_source(pinfo, data_tvb, "h264 prop-parameter-sets");
1367
1368 if (h264_handle && data_tvb) {
1369 TRY {
1370 dissect_h264_nal_unit(data_tvb, pinfo, tree);
1371 }
1372 CATCH_NONFATAL_ERRORS {
1373 show_exception(tvb, pinfo, tree, EXCEPT_CODE, GET_MESSAGE);
1374 }
1375 ENDTRY;
1376 if (comma_offset != -1) {
1377 /* Second NAL unit */
1378 offset = comma_offset +1;
1379 tokenlen = end_offset - offset;
1380 proto_tree_add_item_ret_string(tree, hf_sdp_nal_unit_2_string, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA, pinfo->pool, &data_p);
1381 data_tvb = base64_to_tvb(tvb, data_p);
1382 add_new_data_source(pinfo, data_tvb, "h264 prop-parameter-sets 2");
1383 dissect_h264_nal_unit(data_tvb, pinfo, tree);
1384 }
1385 }
1386 }
1387 }
1388
1389 /* Dissect the H265
1390 * RFC 7798:
1391 */
1392 else if ((mime_type != NULL) && (g_ascii_strcasecmp(mime_type, "H265") == 0)) {
1393 if (strcmp(field_name, "sprop-vps") == 0 || strcmp(field_name, "sprop-sps") == 0 || strcmp(field_name, "sprop-pps") == 0) {
1394
1395 data_tvb = base64_to_tvb(tvb, format_specific_parameter);
1396 add_new_data_source(pinfo, data_tvb, field_name);
1397 if (h265_handle && data_tvb) {
1398 dissect_h265_format_specific_parameter(tree, data_tvb, pinfo);
1399 }
1400 }
1401 }
1402
1403 }
1404
1405 static const string_string ice_candidate_types[] = {
1406 { "host", "Host candidate" },
1407 { "srflx", "Server reflexive candidate" },
1408 { "prflx", "Peer reflexive candidate" },
1409 { "relay", "Relayed candidate" },
1410 { NULL, NULL }
1411 };
1412
1413 static void
1414 dissect_sdp_media_attribute_candidate(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, int offset)
1415 {
1416 /* RFC 5245 (ICE): "The candidate attribute is a media-level attribute
1417 * only. It contains a transport address for a candidate that can be
1418 * used for connectivity checks."
1419 * https://tools.ietf.org/html/rfc5245#section-15.1
1420 *
1421 * candidate-attribute = "candidate" ":" foundation SP component-id SP
1422 * transport SP
1423 * priority SP
1424 * connection-address SP ;from RFC 4566
1425 * port ;port from RFC 4566
1426 * SP cand-type
1427 * [SP rel-addr]
1428 * [SP rel-port]
1429 * *(SP extension-att-name SP
1430 * extension-att-value)
1431 *
1432 * Example: "candidate:0 1 UDP 2122252543 10.9.0.2 60299 typ host"
1433 */
1434 proto_item *pi;
1435 int next_offset, tokenlen;
1436 const uint8_t *candidate_type;
1437
1438 /* foundation: between 1 and 32 "ICE chars" (ALPHA / DIGIT / "+" / "/") */
1439 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1440 if (tokenlen == 0)
1441 return;
1442 proto_tree_add_item(tree, hf_ice_candidate_foundation,
1443 tvb, offset, tokenlen, ENC_ASCII);
1444 offset = next_offset + 1;
1445
1446 /* component-id: integer between 1 and 256.
1447 * For RTP, 1 MUST be RTP and 2 MUST be RTCP (RFC 5245) */
1448 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1449 if (tokenlen == 0)
1450 return;
1451 proto_tree_add_item(tree, hf_ice_candidate_componentid,
1452 tvb, offset, tokenlen, ENC_ASCII);
1453 offset = next_offset + 1;
1454
1455 /* transport: "UDP", etc. */
1456 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1457 if (tokenlen == 0)
1458 return;
1459 proto_tree_add_item(tree, hf_ice_candidate_transport,
1460 tvb, offset, tokenlen, ENC_ASCII);
1461 offset = next_offset + 1;
1462
1463 /* priority: integer between 1 and 2^31-1 */
1464 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1465 if (tokenlen == 0)
1466 return;
1467 proto_tree_add_item(tree, hf_ice_candidate_priority,
1468 tvb, offset, tokenlen, ENC_ASCII);
1469 offset = next_offset + 1;
1470
1471 /* connection-address: IPv4, IPv6 address or FQDN. */
1472 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1473 if (tokenlen == 0)
1474 return;
1475 proto_tree_add_item(tree, hf_ice_candidate_address,
1476 tvb, offset, tokenlen, ENC_ASCII);
1477 offset = next_offset + 1;
1478
1479 /* port */
1480 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1481 if (tokenlen == 0)
1482 return;
1483 proto_tree_add_item(tree, hf_ice_candidate_port,
1484 tvb, offset, tokenlen, ENC_ASCII);
1485 offset = next_offset + 1;
1486
1487 /* cand-type: type of candidate (where it learned the candidate)
1488 * Check for "typ " in "typ host" and skip it. */
1489 if (tvb_strneql(tvb, offset, "typ ", 4))
1490 return;
1491 offset += 4;
1492 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1493 if (tokenlen == 0)
1494 return;
1495 pi = proto_tree_add_item_ret_string(tree, hf_ice_candidate_type,
1496 tvb, offset, tokenlen, ENC_ASCII|ENC_NA,
1497 pinfo->pool, &candidate_type);
1498 if ((candidate_type = try_str_to_str(candidate_type, ice_candidate_types))) {
1499 proto_item_append_text(pi, " (%s)", candidate_type);
1500 }
1501 /* offset = next_offset + 1; */
1502
1503 /* Ignored: [rel-addr] [rel-port] *(extension-att-name extension-att-value) */
1504 }
1505
1506 typedef struct {
1507 const char *name;
1508 } sdp_names_t;
1509
1510 #define SDP_RTPMAP 1
1511 #define SDP_FMTP 2
1512 #define SDP_PATH 3
1513 #define SDP_H248_ITEM 4
1514 #define SDP_CRYPTO 5
1515 #define SDP_SPRTMAP 6
1516 #define SDP_CANDIDATE 7
1517 #define SDP_ED137_TYPE 8
1518 #define SDP_ED137_TXRXMODE 9
1519 #define SDP_ED137_FID 10
1520 #define SDP_RTCP 11
1521 #define SDP_RTCP_MUX 12
1522
1523 static const sdp_names_t sdp_media_attribute_names[] = {
1524 { "Unknown-name"}, /* 0 Pad so that the real headers start at index 1 */
1525 { "rtpmap"}, /* 1 */
1526 { "fmtp"}, /* 2 */
1527 { "path"}, /* 3 */
1528 { "h248item"}, /* 4 */
1529 { "crypto"}, /* 5 */
1530 { "sprt"}, /* 6 */
1531 { "candidate" }, /* 7 */
1532 { "type" }, /* 8 */
1533 { "txrxmode" }, /* 9 */
1534 { "fid" }, /* 10 */
1535 { "rtcp" }, /* 11 */
1536 { "rtcp-mux" }, /* 12 */
1537 };
1538
1539 static int find_sdp_media_attribute_names(tvbuff_t *tvb, int offset, unsigned len)
1540 {
1541 unsigned i;
1542
1543 for (i = 1; i < array_length(sdp_media_attribute_names); i++) {
1544 if ((len == strlen(sdp_media_attribute_names[i].name)) &&
1545 (tvb_strncaseeql(tvb, offset, sdp_media_attribute_names[i].name, len) == 0))
1546 return i;
1547 }
1548
1549 return -1;
1550 }
1551
1552 /* A few protocols give the fmtp parameter as a string instead of a
1553 * numeric payload type, list them here (lower case for comparison).
1554 */
1555 static const string_string media_format_str_types[] = {
1556 /* ETSI TS 102 472, ETSI TS 102 592 */
1557 { "ipdc-kmm", "IP Datacast Key Management Message"},
1558 { "ipdc-ksm", "IP Datacast Key Stream Message"},
1559 /* ETSI TS 124 380 */
1560 { "mcptt", "Mission Critical Push To Talk"},
1561 /* ETSI TS 124 581 */
1562 { "mcvideo", "Mission Critical Video"},
1563 /* OMA PoC Control Plane */
1564 { "tbcp", "Talk Burst Control Protocol"},
1565 { NULL, NULL }
1566 };
1567
1568 static void
1569 dissect_sdp_media_attribute_rtpmap(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, int length,
1570 transport_info_t *transport_info, session_info_t *session_info,
1571 media_description_t *media_desc, int offset)
1572 {
1573 int next_offset, tokenlen;
1574 const uint8_t *payload_type;
1575 proto_item *pi;
1576 uint8_t pt;
1577
1578 /* RFC 8866 6.6 rtpmap
1579 Syntax:
1580 rtpmap-value = payload-type SP encoding-name
1581 "/" clock-rate [ "/" encoding-params ]
1582 payload-type = zero-based-integer
1583 encoding-name = token
1584 clock-rate = integer
1585 encoding-params = channels
1586 channels = integer
1587 */
1588 next_offset = tvb_find_uint8(tvb, offset, -1, ' ');
1589
1590 if (next_offset == -1)
1591 return;
1592
1593 tokenlen = next_offset - offset;
1594
1595 proto_tree_add_item_ret_string(tree, hf_media_format, tvb,
1596 offset, tokenlen, ENC_UTF_8|ENC_NA, pinfo->pool, &payload_type);
1597
1598 offset = next_offset + 1;
1599
1600 next_offset = tvb_find_uint8(tvb, offset, -1, '/');
1601
1602 if (next_offset == -1) {
1603 return;
1604 }
1605
1606 tokenlen = next_offset - offset;
1607
1608 proto_tree_add_item(tree, hf_media_encoding_name, tvb,
1609 offset, tokenlen, ENC_UTF_8);
1610
1611 if (!ws_strtou8(payload_type, NULL, &pt) || pt >= SDP_NO_OF_PT) {
1612 return; /* Invalid */
1613 }
1614
1615 /* String is file scope allocated because transport_info is connection related */
1616 transport_info->encoding_name[pt] = (char*)tvb_get_string_enc(wmem_file_scope(), tvb, offset, tokenlen, ENC_UTF_8|ENC_NA);
1617
1618 offset = next_offset + 1;
1619
1620 next_offset = tvb_find_uint8(tvb, offset, length - offset, '/');
1621 if (next_offset == -1) {
1622 next_offset = length;
1623 }
1624
1625 tokenlen = next_offset - offset;
1626 pi = proto_tree_add_item(tree, hf_media_sample_rate, tvb,
1627 offset, tokenlen, ENC_UTF_8);
1628 transport_info->sample_rate[pt] = 0;
1629 if (!ws_strtou32(tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA),
1630 NULL, &transport_info->sample_rate[pt])) {
1631 expert_add_info(pinfo, pi, &ei_sdp_invalid_sample_rate);
1632 } else if (!strcmp(transport_info->encoding_name[pt], "G722")) {
1633 // The reported sampling rate is 8000, but the actual value is
1634 // 16kHz. https://tools.ietf.org/html/rfc3551#section-4.5.2
1635 proto_item_append_text(pi, " (RTP clock rate is 8kHz, actual sampling rate is 16kHz)");
1636 }
1637
1638 transport_info->channels[pt] = 1;
1639 if (media_desc && media_desc->media_types & RTP_MEDIA_AUDIO) {
1640 if (next_offset < length) {
1641 offset = next_offset + 1;
1642 tokenlen = length - offset;
1643 pi = proto_tree_add_item(tree, hf_media_channels, tvb,
1644 offset, tokenlen, ENC_UTF_8);
1645 if (!ws_strtou32(tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA),
1646 NULL, &transport_info->channels[pt])) {
1647 expert_add_info(pinfo, pi, &ei_sdp_invalid_channels);
1648 }
1649 }
1650 }
1651 /* As per RFC2327 it is possible to have multiple Media Descriptions ("m=").
1652 For example:
1653
1654 a=rtpmap:101 G726-32/8000
1655 m=audio 49170 RTP/AVP 0 97
1656 a=rtpmap:97 telephone-event/8000
1657 m=audio 49172 RTP/AVP 97 101
1658 a=rtpmap:97 G726-24/8000
1659
1660 The Media attributes ("a="s) after the "m=" only apply for that "m=".
1661 If there is an "a=" before the first "m=", that attribute applies for
1662 all the session (all the "m="s).
1663 */
1664
1665 if (session_info) {
1666 /* If this "a=" appear before any "m=", we add it to the session
1667 * info, these will be added later to all media (via
1668 * sdp_new_media_description).
1669 *
1670 * NOTE: This should not happen, because rtpmap is Usage Level: media
1671 * (RFC 8866 6.6, also RFC 4566 6, and heavily implied by RFC 2327)
1672 */
1673 rtp_dyn_payload_insert(session_info->rtp_dyn_payload,
1674 pt,
1675 transport_info->encoding_name[pt],
1676 transport_info->sample_rate[pt],
1677 transport_info->channels[pt]);
1678 } else if (media_desc) {
1679 /* if the "a=" is after an "m=", only apply to this "m=" */
1680 rtp_dyn_payload_insert(media_desc->media.rtp_dyn_payload,
1681 pt,
1682 transport_info->encoding_name[pt],
1683 transport_info->sample_rate[pt],
1684 transport_info->channels[pt]);
1685 }
1686 }
1687
1688 static void
1689 dissect_sdp_media_attribute_fmtp(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb,
1690 transport_info_t *transport_info, session_info_t *session_info,
1691 media_description_t *media_desc, int offset)
1692 {
1693 int next_offset, tokenlen;
1694 proto_item *fmtp_item, *media_format_item;
1695 const uint8_t *payload_type;
1696 const uint8_t *media_format_str;
1697 proto_tree *fmtp_tree;
1698 bool has_more_pars = true;
1699 /* Reading the Format parameter(fmtp) */
1700 uint8_t media_format;
1701
1702 /* Skip leading space, if any */
1703 offset = tvb_skip_wsp(tvb, offset, tvb_captured_length_remaining(tvb, offset));
1704 /* Media format extends to the next space */
1705 next_offset = tvb_find_uint8(tvb, offset, -1, ' ');
1706
1707 if (next_offset == -1)
1708 return;
1709
1710 tokenlen = next_offset - offset;
1711
1712 media_format_item = proto_tree_add_item_ret_string(tree, hf_media_format, tvb,
1713 offset, tokenlen, ENC_UTF_8 | ENC_NA, pinfo->pool, &payload_type);
1714
1715 /* Append encoding name to format if known */
1716 payload_type = wmem_ascii_strdown(pinfo->pool, payload_type, -1);
1717 media_format = 0;
1718 if ((media_format_str = try_str_to_str(payload_type, media_format_str_types))) {
1719
1720 proto_item_append_text(media_format_item, " [%s]",
1721 media_format_str);
1722 } else if (ws_strtou8(payload_type, NULL, &media_format) && media_format < SDP_NO_OF_PT) {
1723 if (media_format) {
1724 proto_item_append_text(media_format_item, " [%s]",
1725 transport_info->encoding_name[media_format]);
1726 }
1727 } else {
1728 expert_add_info(pinfo, media_format_item, &ei_sdp_invalid_media_format);
1729 return;
1730 }
1731
1732
1733 #if 0 /* XXX: ?? */
1734 payload_type = tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_ASCII);
1735 #endif
1736 /* Move offset past the payload type */
1737 offset = next_offset + 1;
1738
1739 while (has_more_pars == true) {
1740 next_offset = tvb_find_uint8(tvb, offset, -1, ';');
1741 offset = tvb_skip_wsp(tvb, offset, tvb_captured_length_remaining(tvb, offset));
1742
1743 if (next_offset == -1) {
1744 has_more_pars = false;
1745 next_offset= tvb_captured_length(tvb);
1746 }
1747
1748 /* There are at least 2 - add the first parameter */
1749 tokenlen = next_offset - offset;
1750 fmtp_item = proto_tree_add_item(tree, hf_media_format_specific_parameter, tvb,
1751 offset, tokenlen, ENC_UTF_8);
1752
1753 fmtp_tree = proto_item_add_subtree(fmtp_item, ett_sdp_fmtp);
1754
1755 rtp_dyn_payload_t *rtp_dyn_payload = NULL;
1756 if (session_info) {
1757 rtp_dyn_payload = session_info->rtp_dyn_payload;
1758 } else if (media_desc) {
1759 rtp_dyn_payload = media_desc->media.rtp_dyn_payload;
1760 }
1761 decode_sdp_fmtp(fmtp_tree, tvb, pinfo, offset, tokenlen,
1762 media_format, transport_info, rtp_dyn_payload);
1763
1764 /* Move offset past "; " and onto first char */
1765 offset = next_offset + 1;
1766 }
1767 }
1768
1769 static void
1770 dissect_sdp_media_attribute_path(packet_info *pinfo, tvbuff_t *tvb, uint8_t *attribute_value,
1771 media_description_t *media_desc, const char *msrp_res, int offset)
1772 {
1773 /* msrp attributes that contain address needed for conversation */
1774 /* RFC 4975
1775 * path = path-label ":" path-list
1776 * path-label = "path"
1777 * path-list= MSRP-URI *(SP MSRP-URI)
1778 * MSRP-URI = msrp-scheme "://" authority
1779 * ["/" session-id] ";" transport *( ";" URI-parameter)
1780 * ; authority as defined in RFC3986
1781 *
1782 * msrp-scheme = "msrp" / "msrps"
1783 * RFC 3986
1784 * The authority component is preceded by a double slash ("//") and is terminated by
1785 * the next slash ("/"), question mark ("?"), or number sign ("#") character, or by
1786 * the end of the URI.
1787 */
1788
1789 /* Check for "msrp://" */
1790 if (strncmp((char*)attribute_value, msrp_res, strlen(msrp_res)) == 0 && msrp_handle &&
1791 media_desc && media_desc->proto == SDP_PROTO_MSRP) {
1792 int address_offset, port_offset, port_end_offset;
1793
1794 /* Address starts here */
1795 address_offset = offset + (int)strlen(msrp_res);
1796
1797 /* Port is after next ':' */
1798 port_offset = tvb_find_uint8(tvb, address_offset, -1, ':');
1799 /* Check if port is present if not skipp */
1800 if (port_offset!= -1) {
1801 /* Port ends with '/' */
1802 port_end_offset = tvb_find_uint8(tvb, port_offset, -1, '/');
1803 if (port_end_offset == -1) {
1804 /* No "/" look for the ";" */
1805 port_end_offset = tvb_find_uint8(tvb, port_offset, -1, ';');
1806 }
1807 /* Attempt to convert address */
1808 uint32_t msrp_ipaddr;
1809 uint16_t msrp_port_number;
1810 if (str_to_ip((char*)tvb_get_string_enc(pinfo->pool, tvb, address_offset, port_offset-address_offset, ENC_UTF_8|ENC_NA),
1811 &msrp_ipaddr)) {
1812 /* Get port number */
1813 if (ws_strtou16(tvb_get_string_enc(pinfo->pool, tvb, port_offset + 1,
1814 port_end_offset - port_offset - 1, ENC_UTF_8|ENC_NA), NULL, &msrp_port_number)) {
1815 /* Port and address are usable, store for later use in
1816 * complete_descriptions (overrides the "c=" address). */
1817 alloc_address_wmem(wmem_file_scope(), &media_desc->media_attr.msrp.ipaddr, AT_IPv4, 4, &msrp_ipaddr);
1818 media_desc->media_attr.msrp.port_number = msrp_port_number;
1819 }
1820 }
1821 }
1822 }
1823 }
1824
1825 static void
1826 dissect_sdp_media_attribute_h248_item(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb,
1827 uint8_t *attribute_value, const char *msrp_res)
1828 {
1829 const char *h324ext_h223lcparm = "h324ext/h223lcparm";
1830 tvbuff_t *h245_tvb;
1831
1832 if (strncmp((char*)attribute_value, h324ext_h223lcparm, strlen(msrp_res)) == 0) {
1833 /* A.5.1.3 H.223 Logical channel parameters
1834 * This property indicates the H.245
1835 * H223LogicalChannelsParameters structure encoded by applying the PER specified in
1836 * ITU-T Rec. X.691. Value encoded as per A.5.1.2. For text encoding the mechanism defined
1837 * in ITU-T Rec. H.248.15 is used.
1838 *
1839 * H.248.15 6 IANA considerations
1840 * The format of the Package attribute is as below:
1841 * a=h248item:<package name>/<property name> = <value>
1842 */
1843 asn1_ctx_t actx;
1844
1845 attribute_value = strchr(attribute_value, '=');
1846 if (!attribute_value) {
1847 return;
1848 }
1849
1850 h245_tvb = ascii_bytes_to_tvb(tvb, pinfo, ++attribute_value);
1851 /* should go through a handle, however, the two h245 entry
1852 points are different, one is over tpkt and the other is raw
1853 */
1854 if (h245_tvb) {
1855 asn1_ctx_init(&actx, ASN1_ENC_PER, true, pinfo);
1856 dissect_h245_H223LogicalChannelParameters(h245_tvb, 0, &actx,
1857 tree,hf_SDPh223LogicalChannelParameters);
1858 }
1859 }
1860 }
1861
1862 static void
1863 dissect_sdp_media_attribute_crypto(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb,
1864 transport_info_t *transport_info, int offset)
1865 {
1866 /* https://tools.ietf.org/html/rfc4568
1867 * 9.1. Generic "Crypto" Attribute Grammar
1868 *
1869 * The ABNF grammar for the crypto attribute is defined below:
1870 *
1871 * "a=crypto:" tag 1*WSP crypto-suite 1*WSP key-params
1872 * *(1*WSP session-param)
1873 *
1874 * tag = 1*9DIGIT
1875 * crypto-suite = 1*(ALPHA / DIGIT / "_")
1876 *
1877 * key-params = key-param *(";" key-param)
1878 * key-param = key-method ":" key-info
1879 * key-method = "inline" / key-method-ext
1880 * key-method-ext = 1*(ALPHA / DIGIT / "_")
1881 * key-info = 1*(%x21-3A / %x3C-7E) ; visible (printing) chars
1882 * ; except semi-colon
1883 * session-param = 1*(VCHAR) ; visible (printing) characters
1884 *
1885 * where WSP, ALPHA, DIGIT, and VCHAR are defined in [RFC4234].
1886 *
1887 */
1888 int next_offset, tokenlen;
1889 proto_tree *parameter_item;
1890 proto_item *parameter_tree;
1891 uint32_t crypto_tag;
1892 bool crypto_tag_valid;
1893 bool has_more_pars = true;
1894 uint8_t master_key_length = 0, master_salt_length = 0;
1895 bool mki_len_valid;
1896 proto_item *pi;
1897
1898 /* We are at the first colon */
1899 /* tag */
1900 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1901 if (tokenlen == 0)
1902 return;
1903 crypto_tag_valid = ws_strtou32(tvb_get_string_enc(pinfo->pool, tvb, offset,
1904 tokenlen, ENC_UTF_8|ENC_NA), NULL, &crypto_tag);
1905 pi = proto_tree_add_uint(tree, hf_sdp_crypto_tag, tvb, offset, tokenlen, crypto_tag);
1906 if (!crypto_tag_valid)
1907 expert_add_info(pinfo, pi, &ei_sdp_invalid_crypto_tag);
1908 offset = next_offset + 1;
1909
1910 /* crypto-suite */
1911 tokenlen = find_next_token_in_line(tvb, tree, &offset, &next_offset);
1912 if (tokenlen == 0)
1913 return;
1914 parameter_item = proto_tree_add_item(tree, hf_sdp_crypto_crypto_suite, tvb, offset, tokenlen, ENC_UTF_8);
1915 if (tvb_strncaseeql(tvb, offset, "AES_CM_128_HMAC_SHA1_80", tokenlen) == 0) {
1916
1917 /* XXX This may only work in simple cases */
1918 if (transport_info->encryption_algorithm == SRTP_ENC_ALG_NOT_SET) {
1919 transport_info->encryption_algorithm = SRTP_ENC_ALG_AES_CM;
1920 transport_info->auth_algorithm = SRTP_AUTH_ALG_HMAC_SHA1;
1921 /* number of octets used for the Auth Tag in the RTP payload */
1922 transport_info->auth_tag_len = 10;
1923 }
1924 master_key_length = 16; /* 128 bits = 16 octets */
1925 master_salt_length = 14; /* 112 bits = 14 octets */
1926 } else if (tvb_strncaseeql(tvb, offset, "AES_CM_128_HMAC_SHA1_32", tokenlen) == 0) {
1927 /* XXX This may only work in simple cases */
1928 if (transport_info->encryption_algorithm == SRTP_ENC_ALG_NOT_SET) {
1929 transport_info->encryption_algorithm = SRTP_ENC_ALG_AES_CM;
1930 transport_info->auth_algorithm = SRTP_AUTH_ALG_HMAC_SHA1;
1931 /* number of octets used for the Auth Tag in the RTP payload */
1932 transport_info->auth_tag_len = 4;
1933 }
1934 master_key_length = 16; /* 128 bits = 16 octets */
1935 master_salt_length = 14; /* 112 bits = 14 octets */
1936 } else if (tvb_strncaseeql(tvb, offset, "F8_128_HMAC_SHA1_80", tokenlen) == 0) {
1937 if (transport_info->encryption_algorithm == SRTP_ENC_ALG_NOT_SET) {
1938 /* XXX This may only work in simple cases */
1939 transport_info->encryption_algorithm = SRTP_ENC_ALG_AES_F8;
1940 transport_info->auth_algorithm = SRTP_AUTH_ALG_HMAC_SHA1;
1941 /* number of octets used for the Auth Tag in the RTP payload */
1942 transport_info->auth_tag_len = 10;
1943 }
1944 master_key_length = 16; /* 128 bits = 16 octets */
1945 master_salt_length = 14; /* 112 bits = 14 octets */
1946 }
1947 offset = next_offset + 1;
1948
1949 /* key-params */
1950 while (has_more_pars == true) {
1951 int param_end_offset;
1952 tvbuff_t *key_salt_tvb;
1953 char *data_p = NULL;
1954
1955 param_end_offset = tvb_find_uint8(tvb, offset, -1, ';');
1956 if (param_end_offset == -1) {
1957 has_more_pars = false;
1958 param_end_offset = tvb_captured_length(tvb);
1959 }
1960 /* key-method or key-method-ext */
1961 next_offset = tvb_find_uint8(tvb, offset, -1, ':');
1962 if (next_offset == -1) {
1963 expert_add_info(pinfo, parameter_item, &ei_sdp_invalid_key_param);
1964 break;
1965 }
1966
1967 if (tvb_strncaseeql(tvb, offset, "inline", next_offset-offset) == 0) {
1968 parameter_tree = proto_tree_add_subtree(tree, tvb, offset,param_end_offset-offset,
1969 ett_sdp_crypto_key_parameters, NULL, "Key parameters");
1970 /* XXX only for SRTP? */
1971 /* srtp-key-info = key-salt ["|" lifetime] ["|" mki] */
1972 offset = next_offset +1;
1973 next_offset = tvb_find_uint8(tvb, offset, -1, '|');
1974 if (next_offset == -1) {
1975 tokenlen = param_end_offset - offset;
1976 } else {
1977 tokenlen = next_offset - offset;
1978 }
1979 data_p = tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_UTF_8|ENC_NA);
1980 key_salt_tvb = base64_to_tvb(tvb, data_p);
1981 add_new_data_source(pinfo, key_salt_tvb, "Key_Salt_tvb");
1982 if (master_key_length != 0) {
1983 proto_tree_add_item(parameter_tree, hf_sdp_key_and_salt, tvb, offset, tokenlen, ENC_NA);
1984 proto_tree_add_item(parameter_tree, hf_sdp_crypto_master_key,
1985 key_salt_tvb, 0, master_key_length, ENC_NA);
1986 proto_tree_add_item(parameter_tree, hf_sdp_crypto_master_salt,
1987 key_salt_tvb, master_key_length, master_salt_length, ENC_NA);
1988 } else {
1989 proto_tree_add_item(parameter_tree, hf_sdp_key_and_salt, key_salt_tvb, 0, -1, ENC_NA);
1990 }
1991
1992 /* ["|" lifetime] ["|" mki] are optional */
1993 if (next_offset != -1) {
1994 offset = next_offset + 1;
1995 next_offset = tvb_find_uint8(tvb, offset, -1, '|');
1996 if (next_offset == -1) {
1997 if (next_offset < param_end_offset){
1998 next_offset = param_end_offset;
1999 }
2000 }
2001 if (next_offset != -1) {
2002 /*lifetime = ["2^"] 1*(DIGIT) ; see section 6.1 for "2^" */
2003 tokenlen = next_offset - offset;
2004 proto_tree_add_item(parameter_tree, hf_sdp_crypto_lifetime,
2005 tvb, offset, tokenlen, ENC_UTF_8);
2006 offset = next_offset + 1;
2007 }
2008 /* mki = mki-value ":" mki-length
2009 *
2010 * mki-value = 1*DIGIT
2011 */
2012 if (offset>param_end_offset) {
2013 next_offset = -1;
2014 } else {
2015 next_offset = tvb_find_uint8(tvb, offset, -1, ':');
2016 }
2017 if (next_offset != -1) {
2018 tokenlen = next_offset - offset;
2019 proto_tree_add_item(parameter_tree, hf_sdp_crypto_mki, tvb, offset, tokenlen, ENC_UTF_8);
2020 offset = next_offset + 1;
2021
2022 /* mki-length = 1*3DIGIT ; range 1..128. */
2023 next_offset = param_end_offset;
2024 tokenlen = next_offset - offset;
2025
2026 /* This will not work if more than one parameter */
2027 /* number of octets used for the MKI in the RTP payload */
2028 mki_len_valid = ws_strtou32(tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen,
2029 ENC_UTF_8|ENC_NA), NULL, &transport_info->mki_len);
2030 pi = proto_tree_add_item(parameter_tree, hf_sdp_crypto_mki_length,
2031 tvb, offset, tokenlen, ENC_UTF_8);
2032 if (!mki_len_valid)
2033 expert_add_info(pinfo, pi, &ei_sdp_invalid_crypto_mki_length);
2034 }
2035 }
2036 offset = param_end_offset;
2037 } else {
2038 break;
2039 }
2040 }
2041 }
2042
2043 static void dissect_sdp_media_attribute(tvbuff_t *tvb, packet_info *pinfo, proto_item * ti, int length,
2044 transport_info_t *transport_info,
2045 session_info_t *session_info,
2046 media_description_t *media_desc,
2047 sdp_data_t *sdp_data)
2048 {
2049 proto_tree *sdp_media_attribute_tree;
2050 proto_item *pi;
2051 int offset, tokenlen, colon_offset;
2052 uint8_t *attribute_value;
2053 int sdp_media_attrbute_code;
2054 const char *msrp_res = "msrp://";
2055
2056 offset = 0;
2057
2058 /* Create attribute tree */
2059 sdp_media_attribute_tree = proto_item_add_subtree(ti,
2060 ett_sdp_media_attribute);
2061 /* Find end of field */
2062 colon_offset = tvb_find_uint8(tvb, offset, -1, ':');
2063
2064 if (colon_offset == -1)
2065 return;
2066
2067 /* Attribute field name is token before ':' */
2068 tokenlen = colon_offset - offset;
2069 pi = proto_tree_add_item(sdp_media_attribute_tree,
2070 hf_media_attribute_field,
2071 tvb, offset, tokenlen, ENC_UTF_8);
2072 /*??field_name = tvb_get_string_enc(pinfo->pool, tvb, offset, tokenlen, ENC_ASCII);*/
2073 sdp_media_attrbute_code = find_sdp_media_attribute_names(tvb, offset, tokenlen);
2074
2075 /* Skip colon */
2076 offset = colon_offset + 1;
2077 /* skip leading wsp */
2078 offset = tvb_skip_wsp(tvb, offset, tvb_captured_length_remaining(tvb, offset));
2079
2080 /* Value is the remainder of the line */
2081 if (tvb_captured_length_remaining(tvb, offset) > 0)
2082 attribute_value = tvb_get_string_enc(pinfo->pool, tvb, offset, tvb_captured_length_remaining(tvb, offset), ENC_UTF_8|ENC_NA);
2083 else
2084 {
2085 expert_add_info(pinfo, pi, &ei_sdp_invalid_line_fields);
2086 return;
2087 }
2088
2089 /*********************************************/
2090 /* Special parsing for some field name types */
2091
2092 switch (sdp_media_attrbute_code) {
2093 case SDP_RTPMAP:
2094 /* decode the rtpmap to see if it is DynamicPayload to dissect them automatic */
2095 dissect_sdp_media_attribute_rtpmap(sdp_media_attribute_tree, pinfo, tvb, length, transport_info,
2096 session_info, media_desc, offset);
2097 break;
2098 case SDP_FMTP:
2099 dissect_sdp_media_attribute_fmtp(sdp_media_attribute_tree, pinfo, tvb, transport_info,
2100 session_info, media_desc, offset);
2101 break;
2102 case SDP_PATH:
2103 dissect_sdp_media_attribute_path(pinfo, tvb, attribute_value, media_desc, msrp_res, offset);
2104 break;
2105 case SDP_H248_ITEM:
2106 /* Decode h248 item ITU-T Rec. H.248.12 (2001)/Amd.1 (11/2002)*/
2107 dissect_sdp_media_attribute_h248_item(sdp_media_attribute_tree, pinfo, tvb, attribute_value, msrp_res);
2108 break;
2109 case SDP_CRYPTO:
2110 dissect_sdp_media_attribute_crypto(sdp_media_attribute_tree, pinfo, tvb, transport_info, offset);
2111 break;
2112 case SDP_CANDIDATE:
2113 dissect_sdp_media_attribute_candidate(sdp_media_attribute_tree, pinfo, tvb, offset);
2114 break;
2115 case SDP_ED137_TYPE:
2116 /* Remember the value and add it to tree */
2117 sdp_data->ed137_type = attribute_value;
2118 proto_tree_add_item(sdp_media_attribute_tree, hf_media_attribute_value,
2119 tvb, offset, -1, ENC_UTF_8);
2120 break;
2121 case SDP_ED137_TXRXMODE:
2122 /* Remember the value and add it to tree */
2123 sdp_data->ed137_txrxmode = attribute_value;
2124 proto_tree_add_item(sdp_media_attribute_tree, hf_media_attribute_value,
2125 tvb, offset, -1, ENC_UTF_8);
2126 break;
2127 case SDP_ED137_FID:
2128 /* Remember the value and add it to tree */
2129 sdp_data->ed137_fid = attribute_value;
2130 proto_tree_add_item(sdp_media_attribute_tree, hf_media_attribute_value,
2131 tvb, offset, -1, ENC_UTF_8);
2132 break;
2133 case SDP_RTCP :
2134 if (media_desc) {
2135 if (!ws_strtou16(attribute_value, NULL, &media_desc->control_port))
2136 media_desc->control_port = 0; /* Just use default, if not legal port */
2137 }
2138 proto_tree_add_item(sdp_media_attribute_tree, hf_media_attribute_value,
2139 tvb, offset, -1, ENC_UTF_8);
2140 break;
2141 case SDP_RTCP_MUX :
2142 if (media_desc) {
2143 media_desc->control_port = media_desc->media_port;
2144 }
2145 proto_tree_add_item(sdp_media_attribute_tree, hf_media_attribute_value,
2146 tvb, offset, -1, ENC_UTF_8);
2147 break;
2148 default:
2149 /* No special treatment for values of this attribute type, just add as one item. */
2150 proto_tree_add_item(sdp_media_attribute_tree, hf_media_attribute_value,
2151 tvb, offset, -1, ENC_UTF_8);
2152 break;
2153 }
2154 }
2155
2156 static void
2157 call_sdp_subdissector(tvbuff_t *tvb, packet_info *pinfo, int hf, proto_tree* ti, int length,
2158 transport_info_t *transport_info,
2159 session_info_t *session_info,
2160 media_description_t *media_desc,
2161 sdp_data_t *sdp_data)
2162 {
2163 if (hf == hf_owner) {
2164 dissect_sdp_owner(tvb, ti);
2165 } else if (hf == hf_connection_info) {
2166 dissect_sdp_connection_info(pinfo, tvb, ti, session_info, media_desc);
2167 } else if (hf == hf_bandwidth) {
2168 dissect_sdp_bandwidth(tvb, ti);
2169 } else if (hf == hf_time) {
2170 dissect_sdp_time(tvb, ti);
2171 } else if (hf == hf_repeat_time) {
2172 dissect_sdp_repeat_time(tvb, ti);
2173 } else if (hf == hf_timezone) {
2174 dissect_sdp_timezone(tvb, ti);
2175 } else if (hf == hf_encryption_key) {
2176 dissect_sdp_encryption_key(tvb, ti);
2177 } else if (hf == hf_session_attribute) {
2178 dissect_sdp_session_attribute(tvb, pinfo, ti);
2179 } else if (hf == hf_media) {
2180 dissect_sdp_media(tvb, pinfo, ti, media_desc);
2181 } else if (hf == hf_media_attribute) {
2182 dissect_sdp_media_attribute(tvb, pinfo, ti, length, transport_info, session_info, media_desc, sdp_data);
2183 }
2184 }
2185
2186 /**
2187 * Post-processes the media descriptions after parsing it from the tvb. This
2188 * performs processing that can only be done when the full media description is
2189 * parsed (since otherwise the order of attributes could influence the result).
2190 * Must be called before applying the SDP with apply_sdp_transport.
2191 * It will remove media streams when the port number in the answer is zero.
2192 *
2193 * If the currently processed SDP is an Answer to a known previous Offer, then
2194 * answer_offset is non-zero.
2195 */
2196 static void
2197 complete_descriptions(transport_info_t *transport_info, unsigned answer_offset)
2198 {
2199 unsigned media_count = wmem_array_get_count(transport_info->media_descriptions);
2200 media_description_t *media_descs = (media_description_t *)wmem_array_get_raw(transport_info->media_descriptions);
2201 media_description_t *bundle_media_desc = NULL;
2202
2203 DPRINT(("complete_descriptions called with answer_offset=%d media_count=%d",
2204 answer_offset, media_count));
2205
2206 for (unsigned i = answer_offset; i < media_count && !bundle_media_desc; i++) {
2207 for (unsigned j = i+1; j < media_count && !bundle_media_desc; j++) {
2208 if (media_descs[i].media_port == media_descs[j].media_port)
2209 bundle_media_desc = &media_descs[i];
2210 }
2211 }
2212
2213 if (bundle_media_desc) {
2214 /* We have "bundling" of media, so now combine all the media bit masks
2215 and merge the rtp_dyn_payload so that the first media description
2216 has all the data for every media desciption. */
2217 for (unsigned i = answer_offset; i < media_count; i++) {
2218 media_description_t *media_desc = &media_descs[i];
2219
2220 if (bundle_media_desc->media_port == media_desc->media_port) {
2221 media_desc->bundled = true;
2222
2223 if (media_desc != bundle_media_desc) {
2224 bundle_media_desc->media_types |= media_desc->media_types;
2225 for (unsigned pt = 0; pt < 128; ++pt) {
2226 const char * encoding_name;
2227 int sample_rate;
2228 unsigned channels;
2229 wmem_map_t *fmtp_map;
2230 if (rtp_dyn_payload_get_full(media_desc->media.rtp_dyn_payload,
2231 pt, &encoding_name, &sample_rate, &channels, &fmtp_map))
2232 rtp_dyn_payload_insert_full(bundle_media_desc->media.rtp_dyn_payload,
2233 pt, encoding_name, sample_rate, channels, fmtp_map);
2234 }
2235 }
2236 }
2237 }
2238 }
2239
2240 for (unsigned i = answer_offset; i < media_count; i++) {
2241 media_description_t *media_desc = &media_descs[i];
2242
2243 if (media_desc->control_port == 0)
2244 media_desc->control_port = media_desc->media_port + 1;
2245
2246 if (media_desc->control_port == 0)
2247 media_desc->control_port = media_desc->media_port + 1;
2248
2249 /* If this is an answer to a previous offer... */
2250 if (answer_offset > 0) {
2251 /* A zero port removes the media stream (RFC 3264, Section 8.2) */
2252 if (media_desc->media_port == 0) {
2253 DPRINT(("disabling media_port=%d, for index=%d",
2254 media_descs[i - answer_offset].media_port,
2255 i - answer_offset));
2256 media_descs[i - answer_offset].media_port = 0;
2257 }
2258 }
2259
2260 /* MSRP uses addresses discovered in attribute
2261 rather than connection information of media session line */
2262 if (media_desc->proto == SDP_PROTO_MSRP && msrp_handle &&
2263 media_desc->media_attr.msrp.ipaddr.type != AT_NONE) {
2264 /* clear old address and set new address and port. */
2265 free_address_wmem(wmem_file_scope(), &media_desc->conn_addr);
2266 copy_address_shallow(&media_desc->conn_addr,
2267 &media_desc->media_attr.msrp.ipaddr);
2268 media_desc->media_port = media_desc->media_attr.msrp.port_number;
2269 }
2270 }
2271 }
2272
2273 /**
2274 * Given is a structure containing the parsed result from the SDP (including
2275 * protocol type (RTP, SRTP, T38, etc.), media info (payload type, etc.) and
2276 * connection info (address, port). Register the addresss+port such that the
2277 * protocol will be invoked for this tuple with the media information.
2278 *
2279 * For use with SDP using the Offer/Answer model (such as SIP with INVITE and
2280 * 200 OK).
2281 * XXX what about RTSP where the SDP merely provides media info, without
2282 * actually establishing connections (Bug 5208).
2283 *
2284 * The passed transport information is modified: 'set_rtp' is set when the media
2285 * is assigned to a conversation. Note that the unassigned media (payload types)
2286 * are not freed, this is the responsibility of the caller.
2287 */
2288 static void
2289 apply_sdp_transport(packet_info *pinfo, transport_info_t *transport_info, int request_frame, sdp_setup_info_t *setup_info)
2290 {
2291 int establish_frame = 0;
2292 wmem_array_t *setup_info_list;
2293
2294 struct srtp_info *srtp_info = NULL;
2295
2296 if (!global_sdp_establish_conversation) {
2297 /* Do not register with other dissectors when this pref is disabled. */
2298 return;
2299 }
2300
2301 /* If no request_frame number has been found use this frame's number */
2302 if (request_frame == 0) {
2303 establish_frame = pinfo->num;
2304 } else {
2305 establish_frame = request_frame;
2306 }
2307
2308 bool bundled_media_set = false;
2309
2310 for (unsigned i = 0; i < wmem_array_get_count(transport_info->media_descriptions); i++) {
2311 media_description_t *media_desc =
2312 (media_description_t *)wmem_array_index(transport_info->media_descriptions, i);
2313 uint32_t current_rtp_port = 0;
2314
2315 /* Add (s)rtp and (s)rtcp conversation, if available (overrides t38 if conversation already set) */
2316 if ((media_desc->media_port != 0) &&
2317 !media_desc->media.set_rtp &&
2318 (media_desc->proto == SDP_PROTO_RTP ||
2319 media_desc->proto == SDP_PROTO_SRTP) &&
2320 (media_desc->conn_addr.type == AT_IPv4 ||
2321 media_desc->conn_addr.type == AT_IPv6)) {
2322
2323 media_desc->media.set_rtp = true;
2324
2325 if (media_desc->bundled) {
2326 if (bundled_media_set)
2327 continue;
2328 bundled_media_set = true;
2329 }
2330
2331 if (media_desc->proto == SDP_PROTO_SRTP) {
2332 srtp_info = wmem_new0(wmem_file_scope(), struct srtp_info);
2333 if (transport_info->encryption_algorithm != SRTP_ENC_ALG_NOT_SET) {
2334 srtp_info->encryption_algorithm = transport_info->encryption_algorithm;
2335 srtp_info->auth_algorithm = transport_info->auth_algorithm;
2336 srtp_info->mki_len = transport_info->mki_len;
2337 srtp_info->auth_tag_len = transport_info->auth_tag_len;
2338
2339 }
2340 DPRINT(("calling srtp_add_address, channel=%d, media_port=%d",
2341 i, media_desc->media_port));
2342 DINDENT();
2343 /* srtp_add_address and rtp_add_address are given the request_frame's not this frame's number,
2344 because that's where the RTP flow started, and thus conversation needs to check against */
2345 srtp_add_address(pinfo, PT_UDP, &media_desc->conn_addr, media_desc->media_port, 0, "SDP", establish_frame,
2346 media_desc->media_types,
2347 media_desc->media.rtp_dyn_payload, srtp_info,
2348 setup_info);
2349 DENDENT();
2350 } else if (setup_info && setup_info->is_osmux) {
2351 DPRINT(("calling osmux_add_address, channel=%d, media_port=%d",
2352 i, media_desc->media_port));
2353 DINDENT();
2354 osmux_add_address(pinfo, &media_desc->conn_addr, media_desc->media_port, 0, establish_frame);
2355 DENDENT();
2356 } else {
2357 DPRINT(("calling rtp_add_address, channel=%d, media_port=%d",
2358 i, media_desc->media_port));
2359 DINDENT();
2360 srtp_add_address(pinfo, PT_UDP, &media_desc->conn_addr, media_desc->media_port, 0, "SDP", establish_frame,
2361 media_desc->media_types,
2362 media_desc->media.rtp_dyn_payload, NULL, setup_info);
2363 DENDENT();
2364 }
2365 /* SPRT might use the same port... */
2366 current_rtp_port = media_desc->media_port;
2367
2368 if (rtcp_handle && media_desc->media_port != media_desc->control_port) {
2369 if (media_desc->proto == SDP_PROTO_SRTP) {
2370 DPRINT(("calling rtcp_add_address, channel=%d, control_port=%d",
2371 i, media_desc->control_port));
2372 DINDENT();
2373 srtcp_add_address(pinfo, &media_desc->conn_addr, media_desc->control_port, 0, "SDP", establish_frame, srtp_info);
2374 DENDENT();
2375 } else if (!setup_info || !setup_info->is_osmux) {
2376 DPRINT(("calling rtcp_add_address, channel=%d, control_port=%d",
2377 i, media_desc->control_port));
2378 DINDENT();
2379 rtcp_add_address(pinfo, &media_desc->conn_addr, media_desc->control_port, 0, "SDP", establish_frame);
2380 DENDENT();
2381 }
2382 }
2383 }
2384
2385 /* add SPRT conversation */
2386 if (media_desc->proto == SDP_PROTO_SPRT &&
2387 (media_desc->conn_addr.type == AT_IPv4 ||
2388 media_desc->conn_addr.type == AT_IPv6) &&
2389 (sprt_handle)) {
2390
2391 if (media_desc->media_port == 0 && current_rtp_port) {
2392 sprt_add_address(pinfo, &media_desc->conn_addr, current_rtp_port,
2393 0, "SDP", pinfo->num); /* will use same port as RTP */
2394 } else {
2395 sprt_add_address(pinfo, &media_desc->conn_addr, media_desc->media_port, 0, "SDP", pinfo->num);
2396 }
2397 }
2398
2399 /* Add t38 conversation, if available and only if no rtp */
2400 if ((media_desc->media_port != 0) &&
2401 !media_desc->media.set_rtp &&
2402 media_desc->proto == SDP_PROTO_T38 &&
2403 media_desc->conn_addr.type == AT_IPv4) {
2404 t38_add_address(pinfo, &media_desc->conn_addr, media_desc->media_port, 0, "SDP", pinfo->num);
2405 }
2406
2407 /* Add MSRP conversation. Uses addresses discovered in attribute
2408 rather than connection information of media session line
2409 (already handled in media conversion) */
2410 if (media_desc->proto == SDP_PROTO_MSRP && msrp_handle) {
2411 msrp_add_address(pinfo, &media_desc->conn_addr, media_desc->media_port, "SDP", pinfo->num);
2412 }
2413
2414 /* Add BFCP conversation. Uses addresses discovered in attribute
2415 rather than connection information of media session line
2416 (already handled in media conversion) */
2417 if (media_desc->proto == SDP_PROTO_BFCP && bfcp_handle) {
2418 bfcp_add_address(pinfo, PT_UDP, &media_desc->conn_addr, media_desc->media_port, "SDP", establish_frame);
2419 }
2420 } /* end of loop through all media descriptions. */
2421
2422 /* Copy the list of setup info of calls with the same RTP information
2423 * to the transport info, so that we have it when dissecting the
2424 * request as well.
2425 * XXX - There can be multiple media descriptions, and while this SDP's
2426 * setup info is on all of them, some other SDP might have some but not
2427 * all media descriptions, so the arrays of setup infos might be different.
2428 * They should be consolidated as with rtp_add_setup_info_if_no_duplicate()
2429 * in packet-rtp.c, or stored with each media descriptor.
2430 */
2431 setup_info_list = p_get_proto_data(pinfo->pool, pinfo, proto_sdp, 0);
2432 if (setup_info_list) {
2433 transport_info->sdp_setup_info_list = setup_info_list;
2434 }
2435 }
2436
2437 void
2438 setup_sdp_transport(tvbuff_t *tvb, packet_info *pinfo, enum sdp_exchange_type exchange_type,
2439 int request_frame, const bool delay, sdp_setup_info_t *setup_info)
2440 {
2441 int offset = 0, next_offset, n;
2442 int linelen;
2443 bool in_media_description = false;
2444 unsigned char type, delim;
2445 const int tokenoffset = 2;
2446 int hf = -1;
2447 int start_transport_info_count = 0;
2448 transport_info_t* transport_info = NULL;
2449 media_description_t *media_desc = NULL;
2450 session_info_t session_info;
2451 sdp_data_t sdp_data;
2452
2453 DPRINT2(("-------------------- setup_sdp_transport -------------------"));
2454
2455 /* Only do this once during first pass */
2456 if (pinfo->fd->visited) {
2457 DPRINT(("already visited"));
2458 return;
2459 }
2460
2461 memset(&sdp_data, 0, sizeof(sdp_data));
2462
2463 if (request_frame != 0)
2464 transport_info = (transport_info_t*)wmem_tree_lookup32( sdp_transport_reqs, request_frame );
2465 if (transport_info == NULL) {
2466 transport_info = wmem_new0(wmem_file_scope(), transport_info_t);
2467 transport_info->media_descriptions = wmem_array_new(wmem_file_scope(), sizeof(media_description_t));
2468
2469 for (n = 0; n < SDP_NO_OF_PT; n++) {
2470 /* String is file scope allocated because transport_info is connection related */
2471 transport_info->encoding_name[n] = wmem_strdup(wmem_file_scope(), UNKNOWN_ENCODING);
2472 }
2473
2474 if (request_frame != 0)
2475 wmem_tree_insert32(sdp_transport_reqs, request_frame, (void *)transport_info);
2476 }
2477 #ifdef DEBUG_CONVERSATION
2478 else {
2479 DPRINT(("found previous transport_info:"));
2480 sdp_dump_transport_info(pinfo, transport_info);
2481 }
2482 #endif
2483
2484 if (exchange_type != SDP_EXCHANGE_OFFER)
2485 wmem_tree_insert32(sdp_transport_rsps, pinfo->num, (void *)transport_info);
2486
2487 /* Offer has already been answered or rejected and hash tables freed, so
2488 * don't try to add to it
2489 * XXX - Need to support "modified offers" */
2490 if ((transport_info->sdp_status == SDP_EXCHANGE_ANSWER_REJECT) ||
2491 (transport_info->sdp_status == SDP_EXCHANGE_ANSWER_ACCEPT))
2492 return;
2493
2494 /* Initialize the session description before parsing the media descriptions. */
2495 memset(&session_info, 0, sizeof(session_info_t));
2496 session_info.rtp_dyn_payload = rtp_dyn_payload_new();
2497
2498 /* Remember where the answer should start (it will be zero if there was no
2499 * previous offer with media descriptions). */
2500 start_transport_info_count = wmem_array_get_count(transport_info->media_descriptions);
2501
2502 DPRINT(("start_transport_info_count=%d", start_transport_info_count));
2503
2504 /*
2505 * Show the SDP message a line at a time.
2506 */
2507 while (tvb_offset_exists(tvb, offset)) {
2508 /*
2509 * Find the end of the line.
2510 */
2511 linelen = tvb_find_line_end_unquoted(tvb, offset, -1, &next_offset);
2512
2513 /*
2514 * Line must contain at least e.g. "v=".
2515 */
2516 if (linelen < 2)
2517 break;
2518
2519 type = tvb_get_uint8(tvb, offset);
2520 delim = tvb_get_uint8(tvb, offset + 1);
2521 if (delim != '=') {
2522 offset = next_offset;
2523 continue;
2524 }
2525
2526 /*
2527 * Attributes. Only care about ones that affect the transport. Ignore others.
2528 */
2529 switch (type) {
2530 case 'c':
2531 hf = hf_connection_info;
2532 break;
2533 case 'm':
2534 hf = hf_media;
2535
2536 /* Try to create a new media description (it will return NULL if
2537 * there are too many). */
2538 media_desc = sdp_new_media_description(transport_info->media_descriptions, &session_info);
2539
2540 in_media_description = true;
2541 DPRINT(("in media description, media descriptions count=%d",
2542 wmem_array_get_count(transport_info->media_descriptions)));
2543 break;
2544 case 'a':
2545 if (in_media_description) {
2546 hf = hf_media_attribute;
2547 } else {
2548 hf = hf_session_attribute;
2549 }
2550 break;
2551 default:
2552 hf = hf_unknown;
2553 break;
2554 }
2555
2556 if (hf != hf_unknown)
2557 {
2558 DINDENT();
2559 call_sdp_subdissector(tvb_new_subset_length(tvb, offset + tokenoffset,
2560 linelen - tokenoffset),
2561 pinfo,
2562 hf, NULL, linelen-tokenoffset,
2563 transport_info,
2564 in_media_description ? NULL : &session_info,
2565 media_desc,
2566 &sdp_data);
2567 DENDENT();
2568 }
2569
2570 offset = next_offset;
2571 }
2572
2573 /* Done parsing media description, no more need for the session-level details. */
2574 rtp_dyn_payload_free(session_info.rtp_dyn_payload);
2575 session_info.rtp_dyn_payload = NULL;
2576
2577 /* Post-processing, close media streams, apply attributes, etc. */
2578 complete_descriptions(transport_info, start_transport_info_count);
2579
2580 #ifdef DEBUG_CONVERSATION
2581 sdp_dump_transport_info(pinfo, transport_info);
2582 #endif
2583
2584 /* We have a successful negotiation, apply data to their respective protocols */
2585 if (!delay || ((exchange_type == SDP_EXCHANGE_ANSWER_ACCEPT) &&
2586 (transport_info->sdp_status == SDP_EXCHANGE_OFFER))) {
2587 /* Accepting answer to a previous offer (or delay pref is false). */
2588 apply_sdp_transport(pinfo, transport_info, request_frame, setup_info);
2589
2590 /* Free all media hash tables that were not assigned to a conversation
2591 * ('set_rtp' is false) */
2592 clean_unused_media_descriptions(transport_info->media_descriptions);
2593
2594 transport_info->sdp_status = exchange_type;
2595
2596 } else if ((exchange_type == SDP_EXCHANGE_ANSWER_REJECT) &&
2597 (transport_info->sdp_status != SDP_EXCHANGE_ANSWER_REJECT)) {
2598 /* Rejecting answer */
2599 clean_unused_media_descriptions(transport_info->media_descriptions);
2600
2601 transport_info->sdp_status = SDP_EXCHANGE_ANSWER_REJECT;
2602 } /* else attempt to accept an unknown offer. */
2603 }
2604
2605 void setup_sdp_transport_resend(int current_frame, int request_frame)
2606 {
2607 transport_info_t* transport_info = NULL;
2608
2609 if (request_frame != 0) {
2610 transport_info = (transport_info_t*)wmem_tree_lookup32( sdp_transport_reqs, request_frame );
2611 if (transport_info != NULL) {
2612 wmem_tree_insert32(sdp_transport_reqs, current_frame, (void *)transport_info);
2613 }
2614 }
2615 }
2616
2617 static int
2618 dissect_sdp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
2619 {
2620 proto_tree *sdp_tree;
2621 proto_item *ti, *sub_ti;
2622 int offset = 0, next_offset, n;
2623 int linelen;
2624 bool in_media_description;
2625 unsigned char type, delim;
2626 int datalen, tokenoffset, hf = -1;
2627 char *string;
2628 sdp_data_t sdp_data;
2629
2630 transport_info_t local_transport_info;
2631 transport_info_t* transport_info = NULL;
2632 media_description_t *media_desc = NULL;
2633 session_info_t session_info;
2634 sdp_packet_info *sdp_pi;
2635 sdp_setup_info_t *setup_info = NULL;
2636
2637 if (data) {
2638 media_content_info_t *content_info = (media_content_info_t *)data;
2639 if (content_info->type == MEDIA_CONTAINER_SIP_DATA) {
2640 setup_info = (sdp_setup_info_t *)content_info->data;
2641 }
2642 }
2643
2644 DPRINT2(("----------------------- dissect_sdp ------------------------"));
2645
2646 /* Initialise packet info for passing to tap */
2647 sdp_pi = wmem_new(pinfo->pool, sdp_packet_info);
2648 sdp_pi->summary_str[0] = '\0';
2649
2650 memset(&sdp_data, 0, sizeof(sdp_data));
2651
2652 transport_info = (transport_info_t*)wmem_tree_lookup32( sdp_transport_reqs, pinfo->num );
2653
2654 if (transport_info == NULL) {
2655 /* Can't find it in the requests, make sure it's not a response */
2656 transport_info = (transport_info_t*)wmem_tree_lookup32( sdp_transport_rsps, pinfo->num );
2657 }
2658
2659 if (transport_info == NULL) {
2660 transport_info = &local_transport_info;
2661 }
2662 #ifdef DEBUG_CONVERSATION
2663 else {
2664 DPRINT(("found previous transport_info:"));
2665 sdp_dump_transport_info(pinfo, transport_info);
2666 }
2667 #endif
2668
2669 /* Initialize local transport info */
2670 memset(&local_transport_info, 0, sizeof(local_transport_info));
2671 /* Note: packet-scoped since it is only needed while parsing this packet. */
2672 local_transport_info.media_descriptions = wmem_array_new(pinfo->pool, sizeof(media_description_t));
2673
2674 for (n = 0; n < SDP_NO_OF_PT; n++) {
2675 local_transport_info.encoding_name[n] = wmem_strdup(pinfo->pool, UNKNOWN_ENCODING);
2676 }
2677
2678 /*
2679 * As RFC 2327 says, "SDP is purely a format for session
2680 * description - it does not incorporate a transport protocol,
2681 * and is intended to use different transport protocols as
2682 * appropriate including the Session Announcement Protocol,
2683 * Session Initiation Protocol, Real-Time Streaming Protocol,
2684 * electronic mail using the MIME extensions, and the
2685 * Hypertext Transport Protocol."
2686 *
2687 * We therefore don't set the protocol or info columns;
2688 * instead, we append to them, so that we don't erase
2689 * what the protocol inside which the SDP stuff resides
2690 * put there.
2691 */
2692 col_append_str(pinfo->cinfo, COL_PROTOCOL, "/SDP");
2693
2694 ti = proto_tree_add_item(tree, proto_sdp, tvb, offset, -1, ENC_NA);
2695 sdp_tree = proto_item_add_subtree(ti, ett_sdp);
2696
2697 /*
2698 * Show the SDP message a line at a time.
2699 */
2700 in_media_description = false;
2701
2702 /* Initialize the session description before parsing the media level. */
2703 memset(&session_info, 0, sizeof(session_info_t));
2704 session_info.rtp_dyn_payload = rtp_dyn_payload_new();
2705
2706 while (tvb_offset_exists(tvb, offset)) {
2707 /*
2708 * Find the end of the line.
2709 */
2710 linelen = tvb_find_line_end_unquoted(tvb, offset, -1, &next_offset);
2711
2712 /*
2713 * Line must contain at least e.g. "v=".
2714 */
2715 if (linelen < 2)
2716 break;
2717
2718 type = tvb_get_uint8(tvb, offset);
2719 delim = tvb_get_uint8(tvb, offset + 1);
2720 if (delim != '=') {
2721 proto_item *ti2 = proto_tree_add_item(sdp_tree, hf_invalid, tvb, offset, linelen, ENC_UTF_8);
2722 expert_add_info(pinfo, ti2, &ei_sdp_invalid_line_equal);
2723 offset = next_offset;
2724 continue;
2725 }
2726
2727 /*
2728 * Attributes.
2729 */
2730 switch (type) {
2731 case 'v':
2732 hf = hf_protocol_version;
2733 break;
2734 case 'o':
2735 hf = hf_owner;
2736 break;
2737 case 's':
2738 hf = hf_session_name;
2739 break;
2740 case 'i':
2741 if (in_media_description) {
2742 hf = hf_media_title;
2743 } else {
2744 hf = hf_session_info;
2745 }
2746 break;
2747 case 'u':
2748 hf = hf_uri;
2749 break;
2750 case 'e':
2751 hf = hf_email;
2752 break;
2753 case 'p':
2754 hf = hf_phone;
2755 break;
2756 case 'c':
2757 hf = hf_connection_info;
2758 break;
2759 case 'b':
2760 hf = hf_bandwidth;
2761 break;
2762 case 't':
2763 hf = hf_time;
2764 break;
2765 case 'r':
2766 hf = hf_repeat_time;
2767 break;
2768 case 'm':
2769 hf = hf_media;
2770
2771 /* Try to create a new media description (it will return NULL if
2772 * there are too many). Pass local_transport_info since we do
2773 * not want to modify the transport_info that was created by
2774 * setup_sdp_transport. */
2775 media_desc = sdp_new_media_description(local_transport_info.media_descriptions, &session_info);
2776
2777 in_media_description = true;
2778 break;
2779 case 'k':
2780 hf = hf_encryption_key;
2781 break;
2782 case 'a':
2783 if (in_media_description) {
2784 hf = hf_media_attribute;
2785 } else {
2786 hf = hf_session_attribute;
2787 }
2788 break;
2789 case 'z':
2790 hf = hf_timezone;
2791 break;
2792 default:
2793 hf = hf_unknown;
2794 break;
2795 }
2796 tokenoffset = 2;
2797 if (hf == hf_unknown)
2798 tokenoffset = 0;
2799 string = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset + tokenoffset,
2800 linelen - tokenoffset, ENC_ASCII);
2801 sub_ti = proto_tree_add_string(sdp_tree, hf, tvb, offset, linelen,
2802 string);
2803
2804 call_sdp_subdissector(tvb_new_subset_length(tvb, offset + tokenoffset,
2805 linelen - tokenoffset),
2806 pinfo,
2807 hf, sub_ti, linelen-tokenoffset,
2808 &local_transport_info,
2809 in_media_description ? NULL : &session_info,
2810 in_media_description ? media_desc : NULL,
2811 &sdp_data);
2812
2813 offset = next_offset;
2814 }
2815
2816 if (NULL != sdp_data.ed137_fid) {
2817 col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", sdp_data.ed137_fid);
2818 (void) g_strlcat(sdp_pi->summary_str, sdp_data.ed137_fid, 50);
2819 }
2820 if (NULL != sdp_data.ed137_txrxmode) {
2821 col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", sdp_data.ed137_txrxmode);
2822 if (strlen(sdp_pi->summary_str))
2823 (void) g_strlcat(sdp_pi->summary_str, " ", 50);
2824 (void) g_strlcat(sdp_pi->summary_str, sdp_data.ed137_txrxmode, 50);
2825 }
2826 if (NULL != sdp_data.ed137_type) {
2827 col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", sdp_data.ed137_type);
2828 if (strlen(sdp_pi->summary_str))
2829 (void) g_strlcat(sdp_pi->summary_str, " ", 50);
2830 (void) g_strlcat(sdp_pi->summary_str, sdp_data.ed137_type, 50);
2831 }
2832
2833 /* Done parsing media description, no more need for the session-level details. */
2834 rtp_dyn_payload_free(session_info.rtp_dyn_payload);
2835 session_info.rtp_dyn_payload = NULL;
2836
2837 /* Post-processing, close media streams, apply attributes, etc. */
2838 if (transport_info == &local_transport_info) {
2839 DPRINT(("no previous transport_info saved, calling complete_descriptions()"));
2840 DINDENT();
2841 complete_descriptions(transport_info, 0);
2842 DENDENT();
2843 #ifdef DEBUG_CONVERSATION
2844 sdp_dump_transport_info(pinfo, transport_info);
2845 #endif
2846 }
2847 #ifdef DEBUG_CONVERSATION
2848 else {
2849 DPRINT(("not overwriting previous transport_info, local_transport_info contents:"));
2850 sdp_dump_transport_info(pinfo, &local_transport_info);
2851 }
2852 #endif
2853
2854 /* For messages not part of the Offer/Answer model, assume that the SDP is
2855 * immediately effective (apply it now). */
2856 if ((!pinfo->fd->visited) && (transport_info == &local_transport_info)) {
2857 /* XXX - This is a placeholder for higher layer protocols that haven't implemented the proper
2858 * OFFER/ANSWER functionality using setup_sdp_transport(). Once all of the higher layers
2859 * use setup_sdp_transport(), this should be removed
2860 * Note that transport_info contains the SDP info from this frame (and
2861 * not an earlier request (transport_info == &local_transport_info).
2862 * Use 0 as request_frame since there is no (known) request.
2863 */
2864 apply_sdp_transport(pinfo, transport_info, 0, setup_info);
2865 /* Save the list of setup info of calls with the same RTP information
2866 * to the packet in file scope, since transport_info is local and
2867 * we won't do this on future passes.
2868 */
2869 p_add_proto_data(wmem_file_scope(), pinfo, proto_sdp, 0, transport_info->sdp_setup_info_list);
2870 }
2871
2872 /* Add information to the VoIP Calls dialog. */
2873 for (unsigned i = 0; i < wmem_array_get_count(local_transport_info.media_descriptions); i++)
2874 {
2875 media_desc = (media_description_t *)wmem_array_index(local_transport_info.media_descriptions, i);
2876
2877 if (media_desc->media_port != 0) {
2878 /* Create the RTP summary str for the Voip Call analysis.
2879 * XXX - Currently this is based only on the current packet
2880 */
2881 for (int j = 0; j < media_desc->media.pt_count; j++)
2882 {
2883 DPRINT(("in for-loop for voip call analysis setting for media #%d, pt=%d",
2884 j, media_desc->media. pt[j]));
2885 /* if the payload type is dynamic (96 to 127), check the hash table to add the desc in the SDP summary */
2886 if ((media_desc->media.pt[j] >= 96) && (media_desc->media.pt[j] <= 127)) {
2887 const char *payload_type_str = rtp_dyn_payload_get_name(
2888 media_desc->media.rtp_dyn_payload,
2889 media_desc->media.pt[j]);
2890 if (payload_type_str) {
2891 if (strlen(sdp_pi->summary_str))
2892 (void) g_strlcat(sdp_pi->summary_str, " ", 50);
2893 (void) g_strlcat(sdp_pi->summary_str, payload_type_str, 50);
2894 } else {
2895 char num_pt[10];
2896 snprintf(num_pt, 10, "%u", media_desc->media.pt[j]);
2897 if (strlen(sdp_pi->summary_str))
2898 (void) g_strlcat(sdp_pi->summary_str, " ", 50);
2899 (void) g_strlcat(sdp_pi->summary_str, num_pt, 50);
2900 }
2901 } else {
2902 if (strlen(sdp_pi->summary_str))
2903 (void) g_strlcat(sdp_pi->summary_str, " ", 50);
2904 (void) g_strlcat(sdp_pi->summary_str,
2905 val_to_str_ext(media_desc->media.pt[j], &rtp_payload_type_short_vals_ext, "%u"),
2906 50);
2907 }
2908 }
2909 }
2910
2911 /* Create the T38 summary str for the Voip Call analysis
2912 * XXX - Currently this is based only on the current packet
2913 */
2914 if ((media_desc->media_port != 0) && media_desc->proto == SDP_PROTO_T38) {
2915 if (strlen(sdp_pi->summary_str))
2916 (void) g_strlcat(sdp_pi->summary_str, " ", 50);
2917 (void) g_strlcat(sdp_pi->summary_str, "t38", 50);
2918 }
2919 }
2920
2921 /* Free all media hash tables that were not assigned to a conversation
2922 * ('set_rtp' is false) */
2923 if (transport_info == &local_transport_info) {
2924 clean_unused_media_descriptions(transport_info->media_descriptions);
2925 }
2926
2927 datalen = tvb_captured_length_remaining(tvb, offset);
2928 if (datalen > 0) {
2929 proto_tree_add_item(sdp_tree, hf_sdp_data, tvb, offset, datalen, ENC_NA);
2930 }
2931 /* Add Trace info */
2932 wmem_array_t *setup_info_list = transport_info->sdp_setup_info_list;
2933 if (!setup_info_list) {
2934 setup_info_list = (wmem_array_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_sdp, 0);
2935 }
2936 if (setup_info_list) {
2937 unsigned i;
2938 sdp_setup_info_t *stored_setup_info;
2939 proto_item *item;
2940 for (i = 0; i < wmem_array_get_count(setup_info_list); i++) {
2941 stored_setup_info = (sdp_setup_info_t *)wmem_array_index(setup_info_list, i);
2942 if (stored_setup_info->hf_id) {
2943 if (stored_setup_info->hf_type == SDP_TRACE_ID_HF_TYPE_STR) {
2944 item = proto_tree_add_string(sdp_tree, stored_setup_info->hf_id, tvb, 0, 0, stored_setup_info->trace_id.str);
2945 proto_item_set_generated(item);
2946 if (stored_setup_info->add_hidden == true) {
2947 proto_item_set_hidden(item);
2948 }
2949 } else if (stored_setup_info->hf_type == SDP_TRACE_ID_HF_TYPE_UINT32) {
2950 item = proto_tree_add_uint(sdp_tree, stored_setup_info->hf_id, tvb, 0, 0, stored_setup_info->trace_id.num);
2951 proto_item_set_generated(item);
2952 if (stored_setup_info->add_hidden == true) {
2953 proto_item_set_hidden(item);
2954 }
2955 }
2956 }
2957 }
2958 }
2959 /* Report this packet to the tap */
2960 tap_queue_packet(sdp_tap, pinfo, sdp_pi);
2961
2962 return tvb_captured_length(tvb);
2963 }
2964
2965 void
2966 proto_register_sdp(void)
2967 {
2968 static hf_register_info hf[] = {
2969 { &hf_protocol_version,
2970 { "Session Description Protocol Version (v)", "sdp.version",
2971 FT_STRING, BASE_NONE, NULL, 0x0,
2972 NULL, HFILL }
2973 },
2974 { &hf_owner,
2975 { "Owner/Creator, Session Id (o)",
2976 "sdp.owner", FT_STRING, BASE_NONE, NULL,
2977 0x0, NULL, HFILL}
2978 },
2979 { &hf_session_name,
2980 { "Session Name (s)", "sdp.session_name",
2981 FT_STRING, BASE_NONE, NULL, 0x0,
2982 NULL, HFILL }
2983 },
2984 { &hf_session_info,
2985 { "Session Information (i)", "sdp.session_info",
2986 FT_STRING, BASE_NONE, NULL, 0x0,
2987 NULL, HFILL }
2988 },
2989 { &hf_uri,
2990 { "URI of Description (u)", "sdp.uri",
2991 FT_STRING, BASE_NONE, NULL, 0x0,
2992 NULL, HFILL }
2993 },
2994 { &hf_email,
2995 { "E-mail Address (e)", "sdp.email",
2996 FT_STRING, BASE_NONE, NULL, 0x0,
2997 NULL, HFILL }
2998 },
2999 { &hf_phone,
3000 { "Phone Number (p)", "sdp.phone",
3001 FT_STRING, BASE_NONE, NULL, 0x0,
3002 NULL, HFILL }
3003 },
3004 { &hf_connection_info,
3005 { "Connection Information (c)", "sdp.connection_info",
3006 FT_STRING, BASE_NONE, NULL, 0x0,
3007 NULL, HFILL }
3008 },
3009 { &hf_bandwidth,
3010 { "Bandwidth Information (b)", "sdp.bandwidth",
3011 FT_STRING, BASE_NONE, NULL, 0x0,
3012 NULL, HFILL }
3013 },
3014 { &hf_timezone,
3015 { "Time Zone Adjustments (z)", "sdp.timezone",
3016 FT_STRING, BASE_NONE, NULL, 0x0,
3017 NULL, HFILL }
3018 },
3019 { &hf_encryption_key,
3020 { "Encryption Key (k)", "sdp.encryption_key",
3021 FT_STRING, BASE_NONE, NULL, 0x0,
3022 NULL, HFILL }
3023 },
3024 { &hf_session_attribute,
3025 { "Session Attribute (a)", "sdp.session_attr",
3026 FT_STRING, BASE_NONE, NULL, 0x0,
3027 NULL, HFILL }
3028 },
3029 { &hf_media_attribute,
3030 { "Media Attribute (a)", "sdp.media_attr",
3031 FT_STRING, BASE_NONE, NULL, 0x0,
3032 NULL, HFILL }
3033 },
3034 { &hf_time,
3035 { "Time Description, active time (t)",
3036 "sdp.time", FT_STRING, BASE_NONE, NULL,
3037 0x0, NULL, HFILL }
3038 },
3039 { &hf_repeat_time,
3040 { "Repeat Time (r)", "sdp.repeat_time",
3041 FT_STRING, BASE_NONE, NULL, 0x0,
3042 NULL, HFILL }
3043 },
3044 { &hf_media,
3045 { "Media Description, name and address (m)",
3046 "sdp.media", FT_STRING, BASE_NONE, NULL, 0x0,
3047 NULL, HFILL }
3048 },
3049 { &hf_media_title,
3050 { "Media Title (i)", "sdp.media_title",
3051 FT_STRING, BASE_NONE, NULL, 0x0,
3052 NULL, HFILL }
3053 },
3054 { &hf_unknown,
3055 { "Unknown", "sdp.unknown",
3056 FT_STRING, BASE_NONE, NULL, 0x0,
3057 NULL, HFILL }
3058 },
3059 { &hf_invalid,
3060 { "Invalid line", "sdp.invalid",
3061 FT_STRING, BASE_NONE, NULL, 0x0,
3062 NULL, HFILL }
3063 },
3064 { &hf_owner_username,
3065 { "Owner Username", "sdp.owner.username",
3066 FT_STRING, BASE_NONE, NULL, 0x0,
3067 NULL, HFILL }
3068 },
3069 { &hf_owner_sessionid,
3070 { "Session ID", "sdp.owner.sessionid",
3071 FT_STRING, BASE_NONE, NULL, 0x0,
3072 NULL, HFILL }
3073 },
3074 { &hf_owner_version,
3075 { "Session Version", "sdp.owner.version",
3076 FT_STRING, BASE_NONE, NULL, 0x0,
3077 NULL, HFILL }
3078 },
3079 { &hf_owner_network_type,
3080 { "Owner Network Type", "sdp.owner.network_type",
3081 FT_STRING, BASE_NONE, NULL, 0x0,
3082 NULL, HFILL }
3083 },
3084 { &hf_owner_address_type,
3085 { "Owner Address Type", "sdp.owner.address_type",
3086 FT_STRING, BASE_NONE, NULL, 0x0,
3087 NULL, HFILL }
3088 },
3089 { &hf_owner_address,
3090 { "Owner Address", "sdp.owner.address",
3091 FT_STRING, BASE_NONE, NULL, 0x0,
3092 NULL, HFILL }
3093 },
3094 { &hf_connection_info_network_type,
3095 { "Connection Network Type", "sdp.connection_info.network_type",
3096 FT_STRING, BASE_NONE, NULL, 0x0,
3097 NULL, HFILL }
3098 },
3099 { &hf_connection_info_address_type,
3100 { "Connection Address Type", "sdp.connection_info.address_type",
3101 FT_STRING, BASE_NONE, NULL, 0x0,
3102 NULL, HFILL }
3103 },
3104 { &hf_connection_info_connection_address,
3105 { "Connection Address", "sdp.connection_info.address",
3106 FT_STRING, BASE_NONE, NULL, 0x0,
3107 NULL, HFILL }
3108 },
3109 { &hf_connection_info_ttl,
3110 { "Connection TTL", "sdp.connection_info.ttl",
3111 FT_STRING, BASE_NONE, NULL, 0x0,
3112 NULL, HFILL }
3113 },
3114 { &hf_connection_info_num_addr,
3115 { "Connection Number of Addresses", "sdp.connection_info.num_addr",
3116 FT_STRING, BASE_NONE, NULL, 0x0,
3117 NULL, HFILL }
3118 },
3119 { &hf_bandwidth_modifier,
3120 { "Bandwidth Modifier", "sdp.bandwidth.modifier",
3121 FT_STRING, BASE_NONE, NULL, 0x0,
3122 NULL, HFILL }
3123 },
3124 { &hf_bandwidth_value,
3125 { "Bandwidth Value", "sdp.bandwidth.value",
3126 FT_STRING, BASE_NONE, NULL, 0x0,
3127 "Bandwidth Value (in kbits/s)", HFILL }
3128 },
3129 { &hf_time_start,
3130 { "Session Start Time", "sdp.time.start",
3131 FT_STRING, BASE_NONE, NULL, 0x0,
3132 NULL, HFILL }
3133 },
3134 { &hf_time_stop,
3135 { "Session Stop Time", "sdp.time.stop",
3136 FT_STRING, BASE_NONE, NULL, 0x0,
3137 NULL, HFILL }
3138 },
3139 { &hf_repeat_time_interval,
3140 { "Repeat Interval", "sdp.repeat_time.interval",
3141 FT_STRING, BASE_NONE, NULL, 0x0,
3142 NULL, HFILL }
3143 },
3144 { &hf_repeat_time_duration,
3145 { "Repeat Duration", "sdp.repeat_time.duration",
3146 FT_STRING, BASE_NONE, NULL, 0x0,
3147 NULL, HFILL }
3148 },
3149 { &hf_repeat_time_offset,
3150 { "Repeat Offset", "sdp.repeat_time.offset",
3151 FT_STRING, BASE_NONE, NULL, 0x0,
3152 NULL, HFILL }
3153 },
3154 { &hf_timezone_time,
3155 { "Timezone Time", "sdp.timezone.time",
3156 FT_STRING, BASE_NONE, NULL, 0x0,
3157 NULL, HFILL }
3158 },
3159 { &hf_timezone_offset,
3160 { "Timezone Offset", "sdp.timezone.offset",
3161 FT_STRING, BASE_NONE, NULL, 0x0,
3162 NULL, HFILL }
3163 },
3164 { &hf_encryption_key_type,
3165 { "Key Type", "sdp.encryption_key.type",
3166 FT_STRING, BASE_NONE, NULL, 0x0,
3167 NULL, HFILL }
3168 },
3169 { &hf_encryption_key_data,
3170 { "Key Data", "sdp.encryption_key.data",
3171 FT_STRING, BASE_NONE, NULL, 0x0,
3172 NULL, HFILL }
3173 },
3174 { &hf_session_attribute_field,
3175 { "Session Attribute Fieldname", "sdp.session_attr.field",
3176 FT_STRING, BASE_NONE, NULL, 0x0,
3177 NULL, HFILL }
3178 },
3179 { &hf_session_attribute_value,
3180 { "Session Attribute Value", "sdp.session_attr.value",
3181 FT_STRING, BASE_NONE, NULL, 0x0,
3182 NULL, HFILL }
3183 },
3184 { &hf_media_media,
3185 { "Media Type", "sdp.media.media",
3186 FT_STRING, BASE_NONE, NULL, 0x0,
3187 NULL, HFILL }
3188 },
3189 { &hf_media_port,
3190 { "Media Port", "sdp.media.port",
3191 FT_UINT16, BASE_DEC, NULL, 0x0,
3192 NULL, HFILL }
3193 },
3194 { &hf_media_port_string,
3195 { "Media Port", "sdp.media.port_string",
3196 FT_STRING, BASE_NONE, NULL, 0x0,
3197 NULL, HFILL }
3198 },
3199 { &hf_media_portcount,
3200 { "Media Port Count", "sdp.media.portcount",
3201 FT_STRING, BASE_NONE, NULL, 0x0,
3202 NULL, HFILL }
3203 },
3204 { &hf_media_proto,
3205 { "Media Protocol", "sdp.media.proto",
3206 FT_STRING, BASE_NONE, NULL, 0x0,
3207 NULL, HFILL }
3208 },
3209 { &hf_media_format,
3210 { "Media Format", "sdp.media.format",
3211 FT_STRING, BASE_NONE, NULL, 0x0,
3212 NULL, HFILL }
3213 },
3214 { &hf_media_attribute_field,
3215 { "Media Attribute Fieldname", "sdp.media_attribute.field",
3216 FT_STRING, BASE_NONE, NULL, 0x0,
3217 NULL, HFILL }
3218 },
3219 { &hf_media_attribute_value,
3220 { "Media Attribute Value", "sdp.media_attribute.value",
3221 FT_STRING, BASE_NONE, NULL, 0x0,
3222 NULL, HFILL }
3223 },
3224 { &hf_media_encoding_name,
3225 { "MIME Type", "sdp.mime.type",
3226 FT_STRING, BASE_NONE, NULL, 0x0,
3227 "SDP MIME Type", HFILL }
3228 },
3229 { &hf_media_sample_rate,
3230 { "Sample Rate", "sdp.sample_rate",
3231 FT_STRING, BASE_NONE, NULL, 0x0,
3232 NULL, HFILL }
3233 },
3234 { &hf_media_channels,
3235 { "Audio Channels", "sdp.channels",
3236 FT_STRING, BASE_NONE, NULL, 0x0,
3237 NULL, HFILL }
3238 },
3239 { &hf_media_format_specific_parameter,
3240 { "Media format specific parameters", "sdp.fmtp.parameter",
3241 FT_STRING, BASE_NONE, NULL, 0x0,
3242 "Format specific parameter(fmtp)", HFILL }
3243 },
3244 { &hf_ipbcp_version,
3245 { "IPBCP Protocol Version", "sdp.ipbcp.version",
3246 FT_STRING, BASE_NONE, NULL, 0x0,
3247 NULL, HFILL }
3248 },
3249 { &hf_ipbcp_type,
3250 { "IPBCP Command Type", "sdp.ipbcp.command",
3251 FT_STRING, BASE_NONE, NULL, 0x0,
3252 NULL, HFILL }
3253 },
3254 {&hf_sdp_fmtp_mpeg4_profile_level_id,
3255 { "Level Code", "sdp.fmtp.profile_level_id",
3256 FT_UINT32, BASE_DEC, VALS(mp4ves_level_indication_vals), 0x0,
3257 NULL, HFILL }
3258 },
3259 { &hf_sdp_fmtp_h263_profile,
3260 { "Profile", "sdp.fmtp.h263profile",
3261 FT_UINT32, BASE_DEC, VALS(h263_profile_vals), 0x0,
3262 NULL, HFILL }
3263 },
3264 { &hf_sdp_fmtp_h263_level,
3265 { "Level", "sdp.fmtp.h263level",
3266 FT_UINT32, BASE_DEC, VALS(h263_level_vals), 0x0,
3267 NULL, HFILL }
3268 },
3269 { &hf_sdp_h264_packetization_mode,
3270 { "Packetization mode", "sdp.fmtp.h264_packetization_mode",
3271 FT_UINT32, BASE_DEC, VALS(h264_packetization_mode_vals), 0x0,
3272 NULL, HFILL }
3273 },
3274 { &hf_SDPh223LogicalChannelParameters,
3275 { "h223LogicalChannelParameters", "sdp.h223LogicalChannelParameters",
3276 FT_NONE, BASE_NONE, NULL, 0,
3277 NULL, HFILL }
3278 },
3279 { &hf_key_mgmt_att_value,
3280 { "Key Management", "sdp.key_mgmt",
3281 FT_STRING, BASE_NONE, NULL, 0x0,
3282 NULL, HFILL }
3283 },
3284 { &hf_key_mgmt_prtcl_id,
3285 { "Key Management Protocol (kmpid)", "sdp.key_mgmt.kmpid",
3286 FT_STRING, BASE_NONE, NULL, 0x0,
3287 NULL, HFILL }
3288 },
3289 { &hf_key_mgmt_data,
3290 { "Key Management Data", "sdp.key_mgmt.data",
3291 FT_BYTES, BASE_NONE, NULL, 0x0,
3292 NULL, HFILL }
3293 },
3294 { &hf_sdp_crypto_tag,
3295 { "tag", "sdp.crypto.tag",
3296 FT_UINT32, BASE_DEC, NULL, 0x0,
3297 NULL, HFILL }
3298 },
3299 { &hf_sdp_crypto_crypto_suite,
3300 { "Crypto suite", "sdp.crypto.crypto_suite",
3301 FT_STRING, BASE_NONE, NULL, 0x0,
3302 NULL, HFILL }
3303 },
3304 { &hf_sdp_crypto_master_key,
3305 { "Master Key", "sdp.crypto.master_key",
3306 FT_BYTES, BASE_NONE, NULL, 0x0,
3307 NULL, HFILL }
3308 },
3309 { &hf_sdp_crypto_master_salt,
3310 { "Master salt", "sdp.crypto.master_salt",
3311 FT_BYTES, BASE_NONE, NULL, 0x0,
3312 NULL, HFILL }
3313 },
3314 { &hf_sdp_crypto_lifetime,
3315 { "Lifetime", "sdp.crypto.lifetime",
3316 FT_STRING, BASE_NONE, NULL, 0x0,
3317 NULL, HFILL }
3318 },
3319 { &hf_sdp_crypto_mki,
3320 { "mki-value", "sdp.crypto.mki-valu",
3321 FT_STRING, BASE_NONE, NULL, 0x0,
3322 NULL, HFILL }
3323 },
3324 { &hf_sdp_crypto_mki_length,
3325 { "mki_length", "sdp.crypto.mki_length",
3326 FT_STRING, BASE_NONE, NULL, 0x0,
3327 NULL, HFILL }
3328 },
3329 { &hf_ice_candidate_foundation,
3330 { "Foundation", "sdp.ice_candidate.foundation",
3331 FT_STRING, BASE_NONE, NULL, 0x0,
3332 "Identifier, same for two candidates with same type, base address, protocol and STUN server", HFILL }
3333 },
3334 { &hf_ice_candidate_componentid,
3335 { "Component ID", "sdp.ice_candidate.componentid",
3336 FT_STRING, BASE_NONE, NULL, 0x0,
3337 "Media component identifier (For RTP media, 1 is RTP, 2 is RTCP)", HFILL }
3338 },
3339 { &hf_ice_candidate_transport,
3340 { "Transport", "sdp.ice_candidate.transport",
3341 FT_STRING, BASE_NONE, NULL, 0x0,
3342 "Transport protocol", HFILL }
3343 },
3344 { &hf_ice_candidate_priority,
3345 { "Priority", "sdp.ice_candidate.priority",
3346 FT_STRING, BASE_NONE, NULL, 0x0,
3347 NULL, HFILL }
3348 },
3349 { &hf_ice_candidate_address,
3350 { "Connection Address", "sdp.ice_candidate.address",
3351 FT_STRING, BASE_NONE, NULL, 0x0,
3352 "IP address or FQDN of the candidate", HFILL }
3353 },
3354 { &hf_ice_candidate_port,
3355 { "Candidate Port", "sdp.ice_candidate.port",
3356 FT_STRING, BASE_NONE, NULL, 0x0,
3357 "Port of the candidate", HFILL }
3358 },
3359 { &hf_ice_candidate_type,
3360 { "Candidate Type", "sdp.ice_candidate.type",
3361 FT_STRING, BASE_NONE, NULL, 0x0,
3362 "The origin of the address and port, i.e. where it was learned", HFILL }
3363 },
3364 /* Generated from convert_proto_tree_add_text.pl */
3365 { &hf_sdp_nal_unit_1_string, { "NAL unit 1 string", "sdp.nal_unit_1_string", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
3366 { &hf_sdp_nal_unit_2_string, { "NAL unit 2 string", "sdp.nal_unit_2_string", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
3367 { &hf_sdp_key_and_salt, { "Key and Salt", "sdp.key_and_salt", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
3368 { &hf_sdp_data, { "Data", "sdp.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
3369 };
3370 static int *ett[] = {
3371 &ett_sdp,
3372 &ett_sdp_owner,
3373 &ett_sdp_connection_info,
3374 &ett_sdp_bandwidth,
3375 &ett_sdp_time,
3376 &ett_sdp_repeat_time,
3377 &ett_sdp_timezone,
3378 &ett_sdp_encryption_key,
3379 &ett_sdp_session_attribute,
3380 &ett_sdp_media,
3381 &ett_sdp_media_attribute,
3382 &ett_sdp_fmtp,
3383 &ett_sdp_key_mgmt,
3384 &ett_sdp_crypto_key_parameters,
3385 };
3386
3387 static ei_register_info ei[] = {
3388 { &ei_sdp_invalid_key_param,
3389 { "sdp.invalid_key_param",
3390 PI_MALFORMED, PI_NOTE,
3391 "Invalid key-param (no ':' delimiter)",
3392 EXPFILL
3393 }
3394 },
3395 { &ei_sdp_invalid_line_equal,
3396 { "sdp.invalid_line.no_equal",
3397 PI_MALFORMED, PI_NOTE,
3398 "Invalid SDP line (no '=' delimiter)",
3399 EXPFILL
3400 }
3401 },
3402 { &ei_sdp_invalid_line_fields,
3403 { "sdp.invalid_line.missing_fields",
3404 PI_MALFORMED, PI_ERROR,
3405 "Invalid SDP line (missing required fields)",
3406 EXPFILL
3407 }
3408 },
3409 { &ei_sdp_invalid_line_space,
3410 { "sdp.invalid_line.extra_space",
3411 PI_MALFORMED, PI_ERROR,
3412 "Invalid SDP whitespace (extra space character)",
3413 EXPFILL
3414 }
3415 },
3416 { &ei_sdp_invalid_conversion,
3417 { "sdp.invalid_conversion",
3418 PI_PROTOCOL, PI_WARN,
3419 "Invalid conversion",
3420 EXPFILL
3421 }
3422 },
3423 { &ei_sdp_invalid_media_port,
3424 { "sdp.invalid_media_port",
3425 PI_MALFORMED, PI_ERROR,
3426 "Invalid media port",
3427 EXPFILL
3428 }
3429 },
3430 { &ei_sdp_invalid_sample_rate,
3431 { "sdp.invalid_sample_rate",
3432 PI_MALFORMED, PI_ERROR,
3433 "Invalid sample rate",
3434 EXPFILL
3435 }
3436 },
3437 { &ei_sdp_invalid_channels,
3438 { "sdp.invalid_channels",
3439 PI_MALFORMED, PI_WARN,
3440 "Invalid number of audio channels",
3441 EXPFILL
3442 }
3443 },
3444 { &ei_sdp_invalid_media_format,
3445 { "sdp.invalid_media_format",
3446 PI_MALFORMED, PI_ERROR,
3447 "Invalid media format",
3448 EXPFILL
3449 }
3450 },
3451 { &ei_sdp_invalid_crypto_tag,
3452 { "sdp.invalid_crypto_tag",
3453 PI_MALFORMED, PI_ERROR,
3454 "Invalid crypto tag",
3455 EXPFILL
3456 }
3457 },
3458 { &ei_sdp_invalid_crypto_mki_length,
3459 { "sdp.invalid_crypto_mki_length",
3460 PI_MALFORMED, PI_ERROR,
3461 "Invalid crypto mki length",
3462 EXPFILL
3463 }
3464 }
3465 };
3466
3467 module_t *sdp_module;
3468 expert_module_t* expert_sdp;
3469
3470 proto_sdp = proto_register_protocol("Session Description Protocol",
3471 "SDP", "sdp");
3472 proto_register_field_array(proto_sdp, hf, array_length(hf));
3473 proto_register_subtree_array(ett, array_length(ett));
3474 expert_sdp = expert_register_protocol(proto_sdp);
3475 expert_register_field_array(expert_sdp, ei, array_length(ei));
3476
3477 key_mgmt_dissector_table = register_dissector_table("key_mgmt",
3478 "Key Management", proto_sdp, FT_STRING, STRING_CASE_SENSITIVE);
3479 /*
3480 * Preferences registration
3481 */
3482 sdp_module = prefs_register_protocol(proto_sdp, NULL);
3483 prefs_register_bool_preference(sdp_module, "establish_conversation",
3484 "Establish Media Conversation",
3485 "Specifies that RTP/RTCP/T.38/MSRP/etc streams are decoded based "
3486 "upon port numbers found in SDP payload",
3487 &global_sdp_establish_conversation);
3488
3489 sdp_transport_reqs = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
3490 sdp_transport_rsps = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
3491
3492 /*
3493 * Register the dissector by name, so other dissectors can
3494 * grab it by name rather than just referring to it directly.
3495 */
3496 sdp_handle = register_dissector("sdp", dissect_sdp, proto_sdp);
3497
3498 /* Register for tapping */
3499 sdp_tap = register_tap("sdp");
3500
3501 /* compile patterns */
3502 ws_mempbrk_compile(&pbrk_digits, "0123456789");
3503 ws_mempbrk_compile(&pbrk_alpha, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
3504 }
3505
3506 void
3507 proto_reg_handoff_sdp(void)
3508 {
3509 rtcp_handle = find_dissector_add_dependency("rtcp", proto_sdp);
3510 msrp_handle = find_dissector_add_dependency("msrp", proto_sdp);
3511 sprt_handle = find_dissector_add_dependency("sprt", proto_sdp);
3512 bfcp_handle = find_dissector_add_dependency("bfcp", proto_sdp);
3513 h264_handle = find_dissector_add_dependency("h264", proto_sdp);
3514 h265_handle = find_dissector_add_dependency("h265", proto_sdp);
3515 mp4ves_config_handle = find_dissector_add_dependency("mp4ves_config", proto_sdp);
3516
3517 proto_sprt = dissector_handle_get_protocol_index(find_dissector("sprt"));
3518
3519 dissector_add_string("media_type", "application/sdp", sdp_handle);
3520 dissector_add_uint("bctp.tpi", 0x20, sdp_handle);
3521 }
3522
3523 /*
3524 * Editor modelines - https://www.wireshark.org/tools/modelines.html
3525 *
3526 * Local variables:
3527 * c-basic-offset: 4
3528 * tab-width: 8
3529 * indent-tabs-mode: nil
3530 * End:
3531 *
3532 * vi: set shiftwidth=4 tabstop=8 expandtab:
3533 * :indentSize=4:tabSize=8:noTabs=true:
3534 */
Metzes wireshark repo