1999-07-07 00:34:58 +00:00
|
|
|
/* packet-rtsp.c
|
2000-01-13 03:12:07 +00:00
|
|
|
* Routines for RTSP packet disassembly (RFC 2326)
|
1999-07-07 00:34:58 +00:00
|
|
|
*
|
|
|
|
* Jason Lango <jal@netapp.com>
|
2000-01-22 06:22:44 +00:00
|
|
|
* Liberally copied from packet-http.c, by Guy Harris <guy@alum.mit.edu>
|
1999-07-07 00:34:58 +00:00
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
1999-07-07 00:34:58 +00:00
|
|
|
*
|
2006-05-21 04:49:01 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
1999-07-07 00:34:58 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-07-07 00:34:58 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-07-07 00:34:58 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
1999-07-07 00:34:58 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
2004-03-05 10:36:51 +00:00
|
|
|
*
|
|
|
|
* References:
|
|
|
|
* RTSP is defined in RFC 2326, http://www.ietf.org/rfc/rfc2326.txt?number=2326
|
|
|
|
* http://www.iana.org/assignments/rsvp-parameters
|
1999-07-07 00:34:58 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
2000-12-02 06:05:29 +00:00
|
|
|
#include <stdlib.h>
|
1999-07-07 00:34:58 +00:00
|
|
|
|
2004-09-27 22:55:15 +00:00
|
|
|
#include <epan/prefs.h>
|
2003-12-17 21:03:15 +00:00
|
|
|
|
1999-07-07 00:34:58 +00:00
|
|
|
#include <glib.h>
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2004-09-29 00:25:05 +00:00
|
|
|
#include <epan/req_resp_hdrs.h>
|
2000-04-21 01:45:58 +00:00
|
|
|
#include "packet-rtp.h"
|
|
|
|
#include "packet-rtcp.h"
|
2005-02-19 22:43:38 +00:00
|
|
|
#include "packet-rdt.h"
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/conversation.h>
|
|
|
|
#include <epan/strutil.h>
|
2004-03-19 05:33:34 +00:00
|
|
|
#include "packet-e164.h"
|
2005-08-12 10:50:55 +00:00
|
|
|
#include <epan/emem.h>
|
1999-07-07 00:34:58 +00:00
|
|
|
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
#ifdef NEED_G_ASCII_STRCASECMP_H
|
|
|
|
#include "g_ascii_strcasecmp.h"
|
|
|
|
#endif
|
|
|
|
|
2003-12-17 21:03:15 +00:00
|
|
|
static int proto_rtsp = -1;
|
1999-11-16 11:44:20 +00:00
|
|
|
|
2003-12-17 21:03:15 +00:00
|
|
|
static gint ett_rtsp = -1;
|
|
|
|
static gint ett_rtspframe = -1;
|
2004-03-19 05:33:34 +00:00
|
|
|
static gint ett_rtsp_method = -1;
|
2001-01-11 19:30:45 +00:00
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
static int hf_rtsp_request = -1;
|
|
|
|
static int hf_rtsp_response = -1;
|
|
|
|
static int hf_rtsp_content_type = -1;
|
|
|
|
static int hf_rtsp_content_length = -1;
|
2003-12-17 21:03:15 +00:00
|
|
|
static int hf_rtsp_method = -1;
|
|
|
|
static int hf_rtsp_url = -1;
|
|
|
|
static int hf_rtsp_status = -1;
|
2004-03-05 10:36:51 +00:00
|
|
|
static int hf_rtsp_session = -1;
|
2005-07-31 20:42:48 +00:00
|
|
|
static int hf_rtsp_transport = -1;
|
2005-09-01 05:34:52 +00:00
|
|
|
static int hf_rtsp_rdtfeaturelevel = -1;
|
2004-03-05 10:36:51 +00:00
|
|
|
static int hf_rtsp_X_Vig_Msisdn = -1;
|
2000-01-13 03:07:26 +00:00
|
|
|
|
2001-09-08 00:43:51 +00:00
|
|
|
static dissector_handle_t rtp_handle;
|
|
|
|
static dissector_handle_t rtcp_handle;
|
2005-05-26 20:11:35 +00:00
|
|
|
static dissector_handle_t rdt_handle;
|
2007-10-24 21:47:13 +00:00
|
|
|
static dissector_table_t media_type_dissector_table;
|
2001-09-08 00:43:51 +00:00
|
|
|
|
2003-12-17 21:03:15 +00:00
|
|
|
void proto_reg_handoff_rtsp(void);
|
|
|
|
|
2003-12-22 08:58:22 +00:00
|
|
|
/*
|
|
|
|
* desegmentation of RTSP headers
|
|
|
|
* (when we are over TCP or another protocol providing the desegmentation API)
|
|
|
|
*/
|
2005-09-28 22:15:38 +00:00
|
|
|
static gboolean rtsp_desegment_headers = TRUE;
|
2003-12-22 08:58:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* desegmentation of RTSP bodies
|
|
|
|
* (when we are over TCP or another protocol providing the desegmentation API)
|
|
|
|
* TODO let the user filter on content-type the bodies he wants desegmented
|
|
|
|
*/
|
2005-09-28 22:15:38 +00:00
|
|
|
static gboolean rtsp_desegment_body = TRUE;
|
2003-12-22 08:58:22 +00:00
|
|
|
|
2003-12-23 00:01:07 +00:00
|
|
|
/* http://www.iana.org/assignments/port-numberslists two rtsp ports */
|
2000-04-08 07:07:42 +00:00
|
|
|
#define TCP_PORT_RTSP 554
|
2003-12-23 00:01:07 +00:00
|
|
|
#define TCP_ALTERNATE_PORT_RTSP 8554
|
2003-12-17 21:03:15 +00:00
|
|
|
static guint global_rtsp_tcp_port = TCP_PORT_RTSP;
|
2003-12-23 00:01:07 +00:00
|
|
|
static guint global_rtsp_tcp_alternate_port = TCP_ALTERNATE_PORT_RTSP;
|
2003-12-17 21:03:15 +00:00
|
|
|
/*
|
|
|
|
* Variables to allow for proper deletion of dissector registration when
|
|
|
|
* the user changes port from the gui.
|
|
|
|
*/
|
|
|
|
static guint tcp_port = 0;
|
2003-12-23 00:01:07 +00:00
|
|
|
static guint tcp_alternate_port = 0;
|
2000-04-08 07:07:42 +00:00
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
/*
|
|
|
|
* Takes an array of bytes, assumed to contain a null-terminated
|
|
|
|
* string, as an argument, and returns the length of the string -
|
|
|
|
* i.e., the size of the array, minus 1 for the null terminator.
|
|
|
|
*/
|
|
|
|
#define STRLEN_CONST(str) (sizeof (str) - 1)
|
|
|
|
|
2001-01-11 19:30:45 +00:00
|
|
|
#define RTSP_FRAMEHDR ('$')
|
|
|
|
|
2001-09-08 00:43:51 +00:00
|
|
|
typedef struct {
|
|
|
|
dissector_handle_t dissector;
|
|
|
|
} rtsp_interleaved_t;
|
|
|
|
|
|
|
|
#define RTSP_MAX_INTERLEAVED (8)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Careful about dynamically allocating memory in this structure (say
|
|
|
|
* for dynamically increasing the size of the 'interleaved' array) -
|
|
|
|
* the containing structure is garbage collected and contained
|
|
|
|
* pointers will not be freed.
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
rtsp_interleaved_t interleaved[RTSP_MAX_INTERLEAVED];
|
|
|
|
} rtsp_conversation_data_t;
|
|
|
|
|
2001-01-11 19:30:45 +00:00
|
|
|
static int
|
|
|
|
dissect_rtspinterleaved(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
|
|
|
proto_tree *tree)
|
|
|
|
{
|
2003-12-22 23:37:02 +00:00
|
|
|
guint length_remaining;
|
2001-01-11 19:30:45 +00:00
|
|
|
proto_item *ti;
|
2003-12-22 23:43:35 +00:00
|
|
|
proto_tree *rtspframe_tree = NULL;
|
2001-01-11 20:14:24 +00:00
|
|
|
int orig_offset;
|
2004-03-05 10:36:51 +00:00
|
|
|
guint8 rf_start; /* always RTSP_FRAMEHDR */
|
2001-01-11 19:30:45 +00:00
|
|
|
guint8 rf_chan; /* interleaved channel id */
|
|
|
|
guint16 rf_len; /* packet length */
|
|
|
|
tvbuff_t *next_tvb;
|
2001-09-08 00:43:51 +00:00
|
|
|
conversation_t *conv;
|
|
|
|
rtsp_conversation_data_t *data;
|
|
|
|
dissector_handle_t dissector;
|
2001-01-11 19:30:45 +00:00
|
|
|
|
2003-12-22 23:37:02 +00:00
|
|
|
/*
|
|
|
|
* This will throw an exception if we don't have any data left.
|
|
|
|
* That's what we want. (See "tcp_dissect_pdus()", which is
|
|
|
|
* similar.)
|
|
|
|
*/
|
|
|
|
length_remaining = tvb_ensure_length_remaining(tvb, offset);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Can we do reassembly?
|
|
|
|
*/
|
|
|
|
if (rtsp_desegment_headers && pinfo->can_desegment) {
|
|
|
|
/*
|
|
|
|
* Yes - would an RTSP multiplexed header starting at
|
|
|
|
* this offset be split across segment boundaries?
|
|
|
|
*/
|
|
|
|
if (length_remaining < 4) {
|
|
|
|
/*
|
|
|
|
* Yes. Tell the TCP dissector where the data
|
|
|
|
* for this message starts in the data it handed
|
|
|
|
* us, and how many more bytes we need, and return.
|
|
|
|
*/
|
|
|
|
pinfo->desegment_offset = offset;
|
|
|
|
pinfo->desegment_len = 4 - length_remaining;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the "$", channel, and length from the header.
|
|
|
|
*/
|
2001-01-11 19:30:45 +00:00
|
|
|
orig_offset = offset;
|
|
|
|
rf_start = tvb_get_guint8(tvb, offset);
|
|
|
|
rf_chan = tvb_get_guint8(tvb, offset+1);
|
|
|
|
rf_len = tvb_get_ntohs(tvb, offset+2);
|
|
|
|
|
2003-12-22 23:37:02 +00:00
|
|
|
/*
|
|
|
|
* Can we do reassembly?
|
|
|
|
*/
|
|
|
|
if (rtsp_desegment_body && pinfo->can_desegment) {
|
|
|
|
/*
|
|
|
|
* Yes - is the header + encapsulated packet split
|
|
|
|
* across segment boundaries?
|
|
|
|
*/
|
|
|
|
if (length_remaining < 4U + rf_len) {
|
|
|
|
/*
|
|
|
|
* Yes. Tell the TCP dissector where the data
|
|
|
|
* for this message starts in the data it handed
|
|
|
|
* us, and how many more bytes we need, and return.
|
|
|
|
*/
|
|
|
|
pinfo->desegment_offset = offset;
|
|
|
|
pinfo->desegment_len = 4U + rf_len - length_remaining;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
2002-08-28 21:04:11 +00:00
|
|
|
col_add_fstr(pinfo->cinfo, COL_INFO,
|
2001-01-11 19:30:45 +00:00
|
|
|
"Interleaved channel 0x%02x, %u bytes",
|
|
|
|
rf_chan, rf_len);
|
|
|
|
|
2003-12-22 23:43:35 +00:00
|
|
|
if (tree != NULL) {
|
|
|
|
ti = proto_tree_add_protocol_format(tree, proto_rtsp, tvb,
|
|
|
|
offset, 4,
|
|
|
|
"RTSP Interleaved Frame, Channel: 0x%02x, %u bytes",
|
|
|
|
rf_chan, rf_len);
|
|
|
|
rtspframe_tree = proto_item_add_subtree(ti, ett_rtspframe);
|
2001-01-11 19:30:45 +00:00
|
|
|
|
2003-12-22 23:43:35 +00:00
|
|
|
proto_tree_add_text(rtspframe_tree, tvb, offset, 1,
|
|
|
|
"Magic: 0x%02x",
|
|
|
|
rf_start);
|
|
|
|
}
|
2001-01-11 19:30:45 +00:00
|
|
|
offset += 1;
|
|
|
|
|
2003-12-22 23:43:35 +00:00
|
|
|
if (tree != NULL) {
|
|
|
|
proto_tree_add_text(rtspframe_tree, tvb, offset, 1,
|
|
|
|
"Channel: 0x%02x",
|
|
|
|
rf_chan);
|
|
|
|
}
|
2001-01-11 19:30:45 +00:00
|
|
|
offset += 1;
|
|
|
|
|
2003-12-22 23:43:35 +00:00
|
|
|
if (tree != NULL) {
|
|
|
|
proto_tree_add_text(rtspframe_tree, tvb, offset, 2,
|
|
|
|
"Length: %u bytes",
|
|
|
|
rf_len);
|
|
|
|
}
|
2001-01-11 19:30:45 +00:00
|
|
|
offset += 2;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We set the actual length of the tvbuff for the interleaved
|
|
|
|
* stuff to the minimum of what's left in the tvbuff and the
|
|
|
|
* length in the header.
|
|
|
|
*
|
|
|
|
* XXX - what if there's nothing left in the tvbuff?
|
|
|
|
* We'd want a BoundsError exception to be thrown, so
|
|
|
|
* that a Short Frame would be reported.
|
|
|
|
*/
|
2003-12-22 23:37:02 +00:00
|
|
|
if (length_remaining > rf_len)
|
|
|
|
length_remaining = rf_len;
|
|
|
|
next_tvb = tvb_new_subset(tvb, offset, length_remaining, rf_len);
|
2001-09-08 00:43:51 +00:00
|
|
|
|
2005-02-02 20:07:03 +00:00
|
|
|
conv = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype,
|
2001-09-08 00:43:51 +00:00
|
|
|
pinfo->srcport, pinfo->destport, 0);
|
|
|
|
|
|
|
|
if (conv &&
|
|
|
|
(data = conversation_get_proto_data(conv, proto_rtsp)) &&
|
|
|
|
rf_chan < RTSP_MAX_INTERLEAVED &&
|
|
|
|
(dissector = data->interleaved[rf_chan].dissector)) {
|
|
|
|
call_dissector(dissector, next_tvb, pinfo, tree);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(rtspframe_tree, tvb, offset, rf_len,
|
|
|
|
"Data (%u bytes)", rf_len);
|
|
|
|
}
|
|
|
|
|
2001-01-11 19:30:45 +00:00
|
|
|
offset += rf_len;
|
|
|
|
|
|
|
|
return offset - orig_offset;
|
|
|
|
}
|
|
|
|
|
2002-08-02 23:36:07 +00:00
|
|
|
static void process_rtsp_request(tvbuff_t *tvb, int offset, const guchar *data,
|
2005-07-31 20:42:48 +00:00
|
|
|
size_t linelen, size_t next_line_offset,
|
|
|
|
proto_tree *tree);
|
1999-07-07 00:34:58 +00:00
|
|
|
|
2002-08-02 23:36:07 +00:00
|
|
|
static void process_rtsp_reply(tvbuff_t *tvb, int offset, const guchar *data,
|
2005-07-31 20:42:48 +00:00
|
|
|
size_t linelen, size_t next_line_offset,
|
|
|
|
proto_tree *tree);
|
2000-11-09 10:56:33 +00:00
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
RTSP_REQUEST,
|
|
|
|
RTSP_REPLY,
|
2005-07-31 20:42:48 +00:00
|
|
|
RTSP_NOT_FIRST_LINE
|
2000-11-09 10:56:33 +00:00
|
|
|
} rtsp_type_t;
|
|
|
|
|
|
|
|
static const char *rtsp_methods[] = {
|
2004-03-05 10:36:51 +00:00
|
|
|
"DESCRIBE",
|
2004-06-15 18:26:08 +00:00
|
|
|
"ANNOUNCE",
|
|
|
|
"GET_PARAMETER",
|
2004-03-05 10:36:51 +00:00
|
|
|
"OPTIONS",
|
2004-06-15 18:26:08 +00:00
|
|
|
"PAUSE",
|
|
|
|
"PLAY",
|
|
|
|
"RECORD",
|
|
|
|
"REDIRECT",
|
2004-03-05 10:36:51 +00:00
|
|
|
"SETUP",
|
2004-06-15 18:26:08 +00:00
|
|
|
"SET_PARAMETER",
|
2004-03-05 10:36:51 +00:00
|
|
|
"TEARDOWN"
|
2000-11-09 10:56:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define RTSP_NMETHODS (sizeof rtsp_methods / sizeof rtsp_methods[0])
|
|
|
|
|
2003-12-22 08:58:22 +00:00
|
|
|
static gboolean
|
|
|
|
is_rtsp_request_or_reply(const guchar *line, size_t linelen, rtsp_type_t *type)
|
2000-11-09 10:56:33 +00:00
|
|
|
{
|
2001-08-18 04:16:37 +00:00
|
|
|
unsigned ii;
|
2000-11-09 10:56:33 +00:00
|
|
|
|
|
|
|
/* Is this an RTSP reply? */
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
if (linelen >= 5 && g_ascii_strncasecmp("RTSP/", line, 5) == 0) {
|
2000-11-09 10:56:33 +00:00
|
|
|
/*
|
|
|
|
* Yes.
|
|
|
|
*/
|
2003-12-22 08:58:22 +00:00
|
|
|
*type = RTSP_REPLY;
|
|
|
|
return TRUE;
|
2000-11-09 10:56:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Is this an RTSP request?
|
|
|
|
* Check whether the line begins with one of the RTSP request
|
|
|
|
* methods.
|
|
|
|
*/
|
|
|
|
for (ii = 0; ii < RTSP_NMETHODS; ii++) {
|
|
|
|
size_t len = strlen(rtsp_methods[ii]);
|
|
|
|
if (linelen >= len &&
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
g_ascii_strncasecmp(rtsp_methods[ii], line, len) == 0 &&
|
2005-07-31 20:42:48 +00:00
|
|
|
(len == linelen || isspace(line[len])))
|
|
|
|
{
|
2003-12-22 08:58:22 +00:00
|
|
|
*type = RTSP_REQUEST;
|
|
|
|
return TRUE;
|
|
|
|
}
|
2000-11-09 10:56:33 +00:00
|
|
|
}
|
2005-07-31 20:42:48 +00:00
|
|
|
|
|
|
|
/* Wasn't a request or a response */
|
|
|
|
*type = RTSP_NOT_FIRST_LINE;
|
2003-12-22 08:58:22 +00:00
|
|
|
return FALSE;
|
2000-11-09 10:56:33 +00:00
|
|
|
}
|
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
static const char rtsp_content_type[] = "Content-Type:";
|
2000-04-21 01:45:58 +00:00
|
|
|
static const char rtsp_transport[] = "Transport:";
|
|
|
|
static const char rtsp_sps[] = "server_port=";
|
|
|
|
static const char rtsp_cps[] = "client_port=";
|
2001-09-08 00:43:51 +00:00
|
|
|
static const char rtsp_rtp[] = "rtp/";
|
2005-09-01 05:34:52 +00:00
|
|
|
static const char rtsp_rdt_feature_level[] = "RDTFeatureLevel";
|
2005-02-19 22:43:38 +00:00
|
|
|
static const char rtsp_real_rdt[] = "x-real-rdt/";
|
2005-05-26 20:11:35 +00:00
|
|
|
static const char rtsp_real_tng[] = "x-pn-tng/"; /* synonym for x-real-rdt */
|
2001-09-08 00:43:51 +00:00
|
|
|
static const char rtsp_inter[] = "interleaved=";
|
2000-04-21 01:45:58 +00:00
|
|
|
|
|
|
|
static void
|
2002-08-02 23:36:07 +00:00
|
|
|
rtsp_create_conversation(packet_info *pinfo, const guchar *line_begin,
|
2005-09-01 05:34:52 +00:00
|
|
|
size_t line_len, gint rdt_feature_level)
|
2000-04-21 01:45:58 +00:00
|
|
|
{
|
|
|
|
conversation_t *conv;
|
2002-08-02 23:36:07 +00:00
|
|
|
guchar buf[256];
|
|
|
|
guchar *tmp;
|
2005-02-19 22:43:38 +00:00
|
|
|
gboolean rtp_transport = FALSE;
|
|
|
|
gboolean rdt_transport = FALSE;
|
2002-08-02 23:36:07 +00:00
|
|
|
guint c_data_port, c_mon_port;
|
|
|
|
guint s_data_port, s_mon_port;
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2005-09-01 05:34:52 +00:00
|
|
|
/* Copy line into buf */
|
|
|
|
if (line_len > sizeof(buf) - 1)
|
|
|
|
{
|
|
|
|
/* Don't overflow the buffer. */
|
2000-12-02 06:05:29 +00:00
|
|
|
line_len = sizeof(buf) - 1;
|
|
|
|
}
|
|
|
|
memcpy(buf, line_begin, line_len);
|
|
|
|
buf[line_len] = '\0';
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2005-02-19 22:43:38 +00:00
|
|
|
/* Get past "Transport:" and spaces */
|
2000-12-02 06:05:29 +00:00
|
|
|
tmp = buf + STRLEN_CONST(rtsp_transport);
|
2000-04-21 01:45:58 +00:00
|
|
|
while (*tmp && isspace(*tmp))
|
|
|
|
tmp++;
|
2005-05-26 20:11:35 +00:00
|
|
|
|
2005-02-19 22:43:38 +00:00
|
|
|
/* Work out which transport type is here */
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
if (g_ascii_strncasecmp(tmp, rtsp_rtp, strlen(rtsp_rtp)) == 0)
|
2005-02-19 22:43:38 +00:00
|
|
|
rtp_transport = TRUE;
|
|
|
|
else
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
if (g_ascii_strncasecmp(tmp, rtsp_real_rdt, strlen(rtsp_real_rdt)) == 0 ||
|
|
|
|
g_ascii_strncasecmp(tmp, rtsp_real_tng, strlen(rtsp_real_tng)) == 0)
|
2005-02-19 22:43:38 +00:00
|
|
|
rdt_transport = TRUE;
|
|
|
|
else
|
|
|
|
{
|
2005-09-01 05:34:52 +00:00
|
|
|
/* Give up on unknown transport types */
|
2001-09-08 00:43:51 +00:00
|
|
|
return;
|
|
|
|
}
|
2005-02-19 22:43:38 +00:00
|
|
|
|
2000-04-21 01:45:58 +00:00
|
|
|
c_data_port = c_mon_port = 0;
|
|
|
|
s_data_port = s_mon_port = 0;
|
2005-02-19 22:43:38 +00:00
|
|
|
|
|
|
|
/* Look for server port */
|
2000-12-02 06:05:29 +00:00
|
|
|
if ((tmp = strstr(buf, rtsp_sps))) {
|
2000-04-21 01:45:58 +00:00
|
|
|
tmp += strlen(rtsp_sps);
|
2001-09-08 00:43:51 +00:00
|
|
|
if (sscanf(tmp, "%u-%u", &s_data_port, &s_mon_port) < 1) {
|
|
|
|
g_warning("Frame %u: rtsp: bad server_port",
|
|
|
|
pinfo->fd->num);
|
|
|
|
return;
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
2005-02-19 22:43:38 +00:00
|
|
|
/* Look for client port */
|
2000-12-02 06:05:29 +00:00
|
|
|
if ((tmp = strstr(buf, rtsp_cps))) {
|
2000-04-21 01:45:58 +00:00
|
|
|
tmp += strlen(rtsp_cps);
|
2001-09-08 00:43:51 +00:00
|
|
|
if (sscanf(tmp, "%u-%u", &c_data_port, &c_mon_port) < 1) {
|
|
|
|
g_warning("Frame %u: rtsp: bad client_port",
|
|
|
|
pinfo->fd->num);
|
|
|
|
return;
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
2005-09-01 05:34:52 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Deal with RTSP TCP-interleaved conversations. */
|
2001-09-08 00:43:51 +00:00
|
|
|
if (!c_data_port) {
|
|
|
|
rtsp_conversation_data_t *data;
|
2002-08-02 23:36:07 +00:00
|
|
|
guint s_data_chan, s_mon_chan;
|
2001-09-08 00:43:51 +00:00
|
|
|
int i;
|
|
|
|
|
2005-09-01 05:34:52 +00:00
|
|
|
/* Search tranport line for interleaved string */
|
2001-09-08 00:43:51 +00:00
|
|
|
if ((tmp = strstr(buf, rtsp_inter)) == NULL) {
|
|
|
|
/*
|
|
|
|
* No interleaved or server_port - probably a
|
|
|
|
* SETUP request, rather than reply.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
2005-09-01 05:34:52 +00:00
|
|
|
|
|
|
|
/* Move tmp to beyone interleaved string */
|
2001-09-08 00:43:51 +00:00
|
|
|
tmp += strlen(rtsp_inter);
|
2005-09-01 05:34:52 +00:00
|
|
|
/* Look for channel number(s) */
|
2001-09-08 00:43:51 +00:00
|
|
|
i = sscanf(tmp, "%u-%u", &s_data_chan, &s_mon_chan);
|
2005-09-01 05:34:52 +00:00
|
|
|
if (i < 1)
|
|
|
|
{
|
|
|
|
g_warning("Frame %u: rtsp: bad interleaved", pinfo->fd->num);
|
2001-09-08 00:43:51 +00:00
|
|
|
return;
|
|
|
|
}
|
2005-09-01 05:34:52 +00:00
|
|
|
|
|
|
|
/* At least data channel present, look for conversation (presumably TCP) */
|
2005-02-02 20:07:03 +00:00
|
|
|
conv = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype,
|
2005-09-01 05:34:52 +00:00
|
|
|
pinfo->srcport, pinfo->destport, 0);
|
|
|
|
|
|
|
|
/* Create new conversation if necessary */
|
|
|
|
if (!conv)
|
|
|
|
{
|
2005-02-02 20:07:03 +00:00
|
|
|
conv = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst,
|
2005-09-01 05:34:52 +00:00
|
|
|
pinfo->ptype, pinfo->srcport, pinfo->destport,
|
|
|
|
0);
|
2001-09-08 00:43:51 +00:00
|
|
|
}
|
2005-09-01 05:34:52 +00:00
|
|
|
|
|
|
|
/* Look for previous data */
|
2001-09-08 00:43:51 +00:00
|
|
|
data = conversation_get_proto_data(conv, proto_rtsp);
|
2005-09-01 05:34:52 +00:00
|
|
|
|
|
|
|
/* Create new data if necessary */
|
|
|
|
if (!data)
|
|
|
|
{
|
2005-08-12 10:50:55 +00:00
|
|
|
data = se_alloc(sizeof(rtsp_conversation_data_t));
|
2001-09-08 00:43:51 +00:00
|
|
|
conversation_add_proto_data(conv, proto_rtsp, data);
|
|
|
|
}
|
2005-05-26 20:11:35 +00:00
|
|
|
|
2005-09-01 05:34:52 +00:00
|
|
|
/* Now set the dissector handle of the interleaved channel
|
|
|
|
according to the transport protocol used */
|
2005-02-19 22:43:38 +00:00
|
|
|
if (rtp_transport)
|
|
|
|
{
|
|
|
|
if (s_data_chan < RTSP_MAX_INTERLEAVED) {
|
|
|
|
data->interleaved[s_data_chan].dissector =
|
|
|
|
rtp_handle;
|
|
|
|
}
|
|
|
|
if (i > 1 && s_mon_chan < RTSP_MAX_INTERLEAVED) {
|
|
|
|
data->interleaved[s_mon_chan].dissector =
|
|
|
|
rtcp_handle;
|
|
|
|
}
|
2001-09-08 00:43:51 +00:00
|
|
|
}
|
2005-05-26 20:11:35 +00:00
|
|
|
else if (rdt_transport)
|
|
|
|
{
|
|
|
|
if (s_data_chan < RTSP_MAX_INTERLEAVED) {
|
|
|
|
data->interleaved[s_data_chan].dissector =
|
|
|
|
rdt_handle;
|
|
|
|
}
|
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
return;
|
2001-09-08 00:43:51 +00:00
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
|
2001-08-18 04:16:37 +00:00
|
|
|
/*
|
|
|
|
* We only want to match on the destination address, not the
|
|
|
|
* source address, because the server might send back a packet
|
|
|
|
* from an address other than the address to which its client
|
|
|
|
* sent the packet, so we construct a conversation with no
|
|
|
|
* second address.
|
|
|
|
*/
|
2005-02-19 22:43:38 +00:00
|
|
|
if (rtp_transport)
|
|
|
|
{
|
2005-09-01 05:34:52 +00:00
|
|
|
/* There is always data for RTP */
|
2005-02-19 22:43:38 +00:00
|
|
|
rtp_add_address(pinfo, &pinfo->dst, c_data_port, s_data_port,
|
2005-09-01 05:34:52 +00:00
|
|
|
"RTSP", pinfo->fd->num, NULL);
|
2005-02-19 22:43:38 +00:00
|
|
|
|
2005-09-01 05:34:52 +00:00
|
|
|
/* RTCP only if indicated */
|
|
|
|
if (c_mon_port)
|
|
|
|
{
|
|
|
|
rtcp_add_address(pinfo, &pinfo->dst, c_mon_port, s_mon_port,
|
|
|
|
"RTSP", pinfo->fd->num);
|
|
|
|
}
|
2005-02-19 22:43:38 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
if (rdt_transport)
|
|
|
|
{
|
2005-09-01 05:34:52 +00:00
|
|
|
/* Real Data Transport */
|
2005-02-19 22:43:38 +00:00
|
|
|
rdt_add_address(pinfo, &pinfo->dst, c_data_port, s_data_port,
|
2005-09-01 05:34:52 +00:00
|
|
|
"RTSP", rdt_feature_level);
|
2005-02-19 22:43:38 +00:00
|
|
|
}
|
2000-04-21 01:45:58 +00:00
|
|
|
}
|
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
static const char rtsp_content_length[] = "Content-Length:";
|
|
|
|
|
|
|
|
static int
|
2002-08-02 23:36:07 +00:00
|
|
|
rtsp_get_content_length(const guchar *line_begin, size_t line_len)
|
2000-12-02 06:05:29 +00:00
|
|
|
{
|
2002-08-02 23:36:07 +00:00
|
|
|
guchar buf[256];
|
|
|
|
guchar *tmp;
|
2000-12-02 06:05:29 +00:00
|
|
|
long content_length;
|
|
|
|
char *p;
|
2002-08-02 23:36:07 +00:00
|
|
|
guchar *up;
|
2000-12-02 06:05:29 +00:00
|
|
|
|
|
|
|
if (line_len > sizeof(buf) - 1) {
|
|
|
|
/*
|
|
|
|
* Don't overflow the buffer.
|
|
|
|
*/
|
|
|
|
line_len = sizeof(buf) - 1;
|
|
|
|
}
|
|
|
|
memcpy(buf, line_begin, line_len);
|
|
|
|
buf[line_len] = '\0';
|
|
|
|
|
|
|
|
tmp = buf + STRLEN_CONST(rtsp_content_length);
|
|
|
|
while (*tmp && isspace(*tmp))
|
|
|
|
tmp++;
|
|
|
|
content_length = strtol(tmp, &p, 10);
|
|
|
|
up = p;
|
|
|
|
if (up == tmp || (*up != '\0' && !isspace(*up)))
|
|
|
|
return -1; /* not a valid number */
|
|
|
|
return content_length;
|
|
|
|
}
|
|
|
|
|
2004-03-05 10:36:51 +00:00
|
|
|
static const char rtsp_Session[] = "Session:";
|
|
|
|
static const char rtsp_X_Vig_Msisdn[] = "X-Vig-Msisdn";
|
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
static int
|
|
|
|
dissect_rtspmessage(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
|
|
|
proto_tree *tree)
|
1999-07-07 00:34:58 +00:00
|
|
|
{
|
2004-03-05 10:36:51 +00:00
|
|
|
proto_tree *rtsp_tree = NULL;
|
|
|
|
proto_tree *sub_tree = NULL;
|
|
|
|
proto_item *ti = NULL;
|
2004-03-19 05:33:34 +00:00
|
|
|
const guchar *line;
|
2004-03-05 10:36:51 +00:00
|
|
|
gint next_offset;
|
2004-03-19 05:33:34 +00:00
|
|
|
const guchar *linep, *lineend;
|
|
|
|
int orig_offset;
|
|
|
|
int first_linelen, linelen;
|
|
|
|
int line_end_offset;
|
|
|
|
int colon_offset;
|
2004-03-05 10:36:51 +00:00
|
|
|
gboolean is_request_or_reply;
|
|
|
|
gboolean body_requires_content_len;
|
|
|
|
gboolean saw_req_resp_or_header;
|
|
|
|
guchar c;
|
|
|
|
rtsp_type_t rtsp_type;
|
2004-07-09 23:37:40 +00:00
|
|
|
gboolean is_header;
|
2004-03-19 05:33:34 +00:00
|
|
|
int datalen;
|
|
|
|
int content_length;
|
|
|
|
int reported_datalen;
|
|
|
|
int value_offset;
|
|
|
|
int value_len;
|
|
|
|
e164_info_t e164_info;
|
2005-09-01 05:34:52 +00:00
|
|
|
gint rdt_feature_level = 0;
|
2007-10-24 21:47:13 +00:00
|
|
|
char *media_type_str_lower_case = NULL;
|
|
|
|
char *media_type_str = NULL;
|
|
|
|
int semi_colon_offset;
|
|
|
|
int par_end_offset;
|
2005-01-20 04:37:03 +00:00
|
|
|
|
2003-12-22 08:58:22 +00:00
|
|
|
/*
|
|
|
|
* Is this a request or response?
|
|
|
|
*
|
|
|
|
* Note that "tvb_find_line_end()" will return a value that
|
|
|
|
* is not longer than what's in the buffer, so the
|
|
|
|
* "tvb_get_ptr()" call won't throw an exception.
|
|
|
|
*/
|
2004-01-01 23:36:50 +00:00
|
|
|
first_linelen = tvb_find_line_end(tvb, offset,
|
|
|
|
tvb_ensure_length_remaining(tvb, offset), &next_offset,
|
2003-12-22 08:58:22 +00:00
|
|
|
FALSE);
|
2005-01-20 04:37:03 +00:00
|
|
|
|
2004-01-01 23:36:50 +00:00
|
|
|
/*
|
|
|
|
* Is the first line a request or response?
|
|
|
|
*/
|
2003-12-22 08:58:22 +00:00
|
|
|
line = tvb_get_ptr(tvb, offset, first_linelen);
|
|
|
|
is_request_or_reply = is_rtsp_request_or_reply(line, first_linelen,
|
|
|
|
&rtsp_type);
|
|
|
|
if (is_request_or_reply) {
|
|
|
|
/*
|
|
|
|
* Yes, it's a request or response.
|
|
|
|
* Do header desegmentation if we've been told to,
|
|
|
|
* and do body desegmentation if we've been told to and
|
|
|
|
* we find a Content-Length header.
|
|
|
|
*/
|
2005-01-20 04:37:03 +00:00
|
|
|
if (!req_resp_hdrs_do_reassembly(tvb, offset, pinfo,
|
2003-12-23 02:29:11 +00:00
|
|
|
rtsp_desegment_headers, rtsp_desegment_body)) {
|
2003-12-22 08:58:22 +00:00
|
|
|
/*
|
|
|
|
* More data needed for desegmentation.
|
|
|
|
*/
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-01-05 03:51:28 +00:00
|
|
|
/*
|
|
|
|
* RFC 2326 says that a content length must be specified
|
|
|
|
* in requests that have a body, although section 4.4 speaks
|
|
|
|
* of a server closing the connection indicating the end of
|
|
|
|
* a reply body.
|
|
|
|
*
|
|
|
|
* We assume that an absent content length in a request means
|
|
|
|
* that we don't have a body, and that an absent content length
|
|
|
|
* in a reply means that the reply body runs to the end of
|
|
|
|
* the connection. If the first line is neither, we assume
|
|
|
|
* that whatever follows a blank line should be treated as a
|
|
|
|
* body; there's not much else we can do, as we're jumping
|
|
|
|
* into the message in the middle.
|
|
|
|
*
|
|
|
|
* XXX - if there was no Content-Length entity header, we should
|
|
|
|
* accumulate all data until the end of the connection.
|
|
|
|
* That'd require that the TCP dissector call subdissectors
|
|
|
|
* for all frames with FIN, even if they contain no data,
|
|
|
|
* which would require subdissectors to deal intelligently
|
|
|
|
* with empty segments.
|
|
|
|
*/
|
|
|
|
if (rtsp_type == RTSP_REQUEST)
|
|
|
|
body_requires_content_len = TRUE;
|
|
|
|
else
|
|
|
|
body_requires_content_len = FALSE;
|
|
|
|
|
2004-01-01 23:36:50 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RTSP");
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO)) {
|
1999-07-07 00:34:58 +00:00
|
|
|
/*
|
2000-01-13 03:07:26 +00:00
|
|
|
* Put the first line from the buffer into the summary
|
2003-12-22 08:58:22 +00:00
|
|
|
* if it's an RTSP request or reply (but leave out the
|
2000-11-09 10:56:33 +00:00
|
|
|
* line terminator).
|
|
|
|
* Otherwise, just call it a continuation.
|
2004-01-01 23:36:50 +00:00
|
|
|
*
|
|
|
|
* Note that "tvb_find_line_end()" will return a value that
|
|
|
|
* is not longer than what's in the buffer, so the
|
|
|
|
* "tvb_get_ptr()" call won't throw an exception.
|
1999-07-07 00:34:58 +00:00
|
|
|
*/
|
2004-01-01 23:36:50 +00:00
|
|
|
line = tvb_get_ptr(tvb, offset, first_linelen);
|
2003-12-22 08:58:22 +00:00
|
|
|
if (is_request_or_reply)
|
2004-03-05 10:36:51 +00:00
|
|
|
if ( rtsp_type == RTSP_REPLY ) {
|
2007-10-23 05:50:00 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_INFO, "Reply: ");
|
2004-03-05 10:36:51 +00:00
|
|
|
col_append_str(pinfo->cinfo, COL_INFO,
|
|
|
|
format_text(line, first_linelen));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
col_add_str(pinfo->cinfo, COL_INFO,
|
|
|
|
format_text(line, first_linelen));
|
2004-06-15 18:26:08 +00:00
|
|
|
|
2003-12-22 08:58:22 +00:00
|
|
|
else
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_INFO, "Continuation");
|
2004-06-15 18:26:08 +00:00
|
|
|
|
1999-07-07 00:34:58 +00:00
|
|
|
}
|
|
|
|
|
2004-01-01 23:36:50 +00:00
|
|
|
orig_offset = offset;
|
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_item(tree, proto_rtsp, tvb, offset, -1,
|
|
|
|
FALSE);
|
|
|
|
rtsp_tree = proto_item_add_subtree(ti, ett_rtsp);
|
|
|
|
}
|
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
/*
|
|
|
|
* We haven't yet seen a Content-Length header.
|
|
|
|
*/
|
|
|
|
content_length = -1;
|
|
|
|
|
2000-11-09 10:56:33 +00:00
|
|
|
/*
|
|
|
|
* Process the packet data, a line at a time.
|
|
|
|
*/
|
2004-01-01 23:36:50 +00:00
|
|
|
saw_req_resp_or_header = FALSE; /* haven't seen anything yet */
|
|
|
|
while (tvb_reported_length_remaining(tvb, offset) != 0) {
|
2000-12-02 06:05:29 +00:00
|
|
|
/*
|
2004-07-09 23:37:40 +00:00
|
|
|
* We haven't yet concluded that this is a header.
|
2000-12-02 06:05:29 +00:00
|
|
|
*/
|
2004-07-09 23:37:40 +00:00
|
|
|
is_header = FALSE;
|
2000-12-02 06:05:29 +00:00
|
|
|
|
1999-07-07 00:34:58 +00:00
|
|
|
/*
|
|
|
|
* Find the end of the line.
|
|
|
|
*/
|
2004-01-01 23:36:50 +00:00
|
|
|
linelen = tvb_find_line_end(tvb, offset,
|
|
|
|
tvb_ensure_length_remaining(tvb, offset), &next_offset,
|
2002-07-17 06:55:29 +00:00
|
|
|
FALSE);
|
2004-01-01 23:36:50 +00:00
|
|
|
if (linelen < 0)
|
|
|
|
return -1;
|
2004-03-05 10:36:51 +00:00
|
|
|
line_end_offset = offset + linelen;
|
|
|
|
/*
|
2004-06-15 18:26:08 +00:00
|
|
|
* colon_offset may be -1
|
2004-03-05 10:36:51 +00:00
|
|
|
*/
|
|
|
|
colon_offset = tvb_find_guint8(tvb, offset, linelen, ':');
|
|
|
|
|
2000-11-09 10:56:33 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a buffer that refers to the line.
|
|
|
|
*/
|
|
|
|
line = tvb_get_ptr(tvb, offset, linelen);
|
|
|
|
lineend = line + linelen;
|
1999-07-07 00:34:58 +00:00
|
|
|
|
|
|
|
/*
|
2004-01-01 23:36:50 +00:00
|
|
|
* OK, does it look like an RTSP request or response?
|
1999-07-07 00:34:58 +00:00
|
|
|
*/
|
2005-07-31 20:42:48 +00:00
|
|
|
is_request_or_reply = is_rtsp_request_or_reply(line, linelen, &rtsp_type);
|
2003-12-22 08:58:22 +00:00
|
|
|
if (is_request_or_reply)
|
1999-07-07 00:34:58 +00:00
|
|
|
goto is_rtsp;
|
|
|
|
|
|
|
|
/*
|
2004-01-01 23:36:50 +00:00
|
|
|
* No. Does it look like a blank line (as would appear
|
|
|
|
* at the end of an RTSP request)?
|
1999-07-07 00:34:58 +00:00
|
|
|
*/
|
2000-11-09 10:56:33 +00:00
|
|
|
if (linelen == 0)
|
|
|
|
goto is_rtsp; /* Yes. */
|
1999-07-07 00:34:58 +00:00
|
|
|
|
|
|
|
/*
|
2004-01-01 23:36:50 +00:00
|
|
|
* No. Does it look like a header?
|
1999-07-07 00:34:58 +00:00
|
|
|
*/
|
2000-11-09 10:56:33 +00:00
|
|
|
linep = line;
|
1999-07-07 00:34:58 +00:00
|
|
|
while (linep < lineend) {
|
|
|
|
c = *linep++;
|
2004-07-09 23:37:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This must be a CHAR to be part of a token; that
|
|
|
|
* means it must be ASCII.
|
|
|
|
*/
|
|
|
|
if (!isascii(c))
|
|
|
|
break; /* not ASCII, thus not a CHAR */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This mustn't be a CTL to be part of a token.
|
|
|
|
*
|
|
|
|
* XXX - what about leading LWS on continuation
|
|
|
|
* lines of a header?
|
|
|
|
*/
|
|
|
|
if (iscntrl(c))
|
|
|
|
break; /* CTL, not part of a header */
|
|
|
|
|
1999-07-07 00:34:58 +00:00
|
|
|
switch (c) {
|
|
|
|
|
|
|
|
case '(':
|
|
|
|
case ')':
|
|
|
|
case '<':
|
|
|
|
case '>':
|
|
|
|
case '@':
|
|
|
|
case ',':
|
|
|
|
case ';':
|
|
|
|
case '\\':
|
|
|
|
case '"':
|
|
|
|
case '/':
|
|
|
|
case '[':
|
|
|
|
case ']':
|
|
|
|
case '?':
|
|
|
|
case '=':
|
|
|
|
case '{':
|
|
|
|
case '}':
|
|
|
|
/*
|
|
|
|
* It's a tspecial, so it's not
|
|
|
|
* part of a token, so it's not
|
|
|
|
* a field name for the beginning
|
2004-07-09 23:37:40 +00:00
|
|
|
* of a header.
|
1999-07-07 00:34:58 +00:00
|
|
|
*/
|
|
|
|
goto not_rtsp;
|
|
|
|
|
|
|
|
case ':':
|
|
|
|
/*
|
|
|
|
* This ends the token; we consider
|
2004-07-09 23:37:40 +00:00
|
|
|
* this to be a header.
|
1999-07-07 00:34:58 +00:00
|
|
|
*/
|
2004-07-09 23:37:40 +00:00
|
|
|
is_header = TRUE;
|
1999-07-07 00:34:58 +00:00
|
|
|
goto is_rtsp;
|
2001-05-31 20:40:29 +00:00
|
|
|
|
|
|
|
case ' ':
|
|
|
|
case '\t':
|
|
|
|
/*
|
|
|
|
* LWS (RFC-2616, 4.2); continue the previous
|
|
|
|
* header.
|
|
|
|
*/
|
|
|
|
goto is_rtsp;
|
1999-07-07 00:34:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-01-01 23:36:50 +00:00
|
|
|
/*
|
|
|
|
* We haven't seen the colon, but everything else looks
|
|
|
|
* OK for a header line.
|
|
|
|
*
|
|
|
|
* If we've already seen an RTSP request or response
|
|
|
|
* line, or a header line, and we're at the end of
|
|
|
|
* the tvbuff, we assume this is an incomplete header
|
|
|
|
* line. (We quit this loop after seeing a blank line,
|
|
|
|
* so if we've seen a request or response line, or a
|
|
|
|
* header line, this is probably more of the request
|
|
|
|
* or response we're presumably seeing. There is some
|
|
|
|
* risk of false positives, but the same applies for
|
|
|
|
* full request or response lines or header lines,
|
|
|
|
* although that's less likely.)
|
|
|
|
*
|
|
|
|
* We throw an exception in that case, by checking for
|
|
|
|
* the existence of the next byte after the last one
|
|
|
|
* in the line. If it exists, "tvb_ensure_bytes_exist()"
|
|
|
|
* throws no exception, and we fall through to the
|
|
|
|
* "not RTSP" case. If it doesn't exist,
|
|
|
|
* "tvb_ensure_bytes_exist()" will throw the appropriate
|
|
|
|
* exception.
|
|
|
|
*/
|
|
|
|
if (saw_req_resp_or_header)
|
|
|
|
tvb_ensure_bytes_exist(tvb, offset, linelen + 1);
|
|
|
|
|
1999-07-07 00:34:58 +00:00
|
|
|
not_rtsp:
|
|
|
|
/*
|
|
|
|
* We don't consider this part of an RTSP request or
|
|
|
|
* reply, so we don't display it.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
|
|
|
|
is_rtsp:
|
|
|
|
/*
|
2003-12-22 08:58:22 +00:00
|
|
|
* Process this line.
|
1999-07-07 00:34:58 +00:00
|
|
|
*/
|
2004-01-01 23:36:50 +00:00
|
|
|
if (linelen == 0) {
|
|
|
|
/*
|
|
|
|
* This is a blank line, which means that
|
|
|
|
* whatever follows it isn't part of this
|
|
|
|
* request or reply.
|
|
|
|
*/
|
|
|
|
proto_tree_add_text(rtsp_tree, tvb, offset,
|
2005-07-31 20:42:48 +00:00
|
|
|
next_offset - offset, "%s",
|
|
|
|
tvb_format_text(tvb, offset, next_offset - offset));
|
2004-01-01 23:36:50 +00:00
|
|
|
offset = next_offset;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Not a blank line - either a request, a reply, or a header
|
|
|
|
* line.
|
2004-06-15 18:26:08 +00:00
|
|
|
*/
|
2004-01-01 23:36:50 +00:00
|
|
|
saw_req_resp_or_header = TRUE;
|
2000-04-21 07:43:53 +00:00
|
|
|
if (rtsp_tree) {
|
2003-12-22 08:58:22 +00:00
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
switch (rtsp_type)
|
|
|
|
{
|
|
|
|
case RTSP_REQUEST:
|
|
|
|
process_rtsp_request(tvb, offset, line, linelen, next_offset, rtsp_tree);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RTSP_REPLY:
|
|
|
|
process_rtsp_reply(tvb, offset, line, linelen, next_offset, rtsp_tree);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RTSP_NOT_FIRST_LINE:
|
|
|
|
/* Drop through, it may well be a header line */
|
|
|
|
break;
|
2003-12-22 08:58:22 +00:00
|
|
|
}
|
2000-04-21 07:43:53 +00:00
|
|
|
}
|
2005-07-31 20:42:48 +00:00
|
|
|
|
|
|
|
if (is_header)
|
|
|
|
{
|
|
|
|
/* We know that colon_offset must be set */
|
|
|
|
|
|
|
|
/* Skip whitespace after the colon. */
|
|
|
|
value_offset = colon_offset + 1;
|
|
|
|
while ((value_offset < line_end_offset) &&
|
|
|
|
((c = tvb_get_guint8(tvb, value_offset)) == ' ' || c == '\t'))
|
|
|
|
{
|
|
|
|
value_offset++;
|
|
|
|
}
|
|
|
|
value_len = line_end_offset - value_offset;
|
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
/*
|
2004-07-09 23:37:40 +00:00
|
|
|
* Process some headers specially.
|
2000-12-02 06:05:29 +00:00
|
|
|
*/
|
2004-07-09 23:37:40 +00:00
|
|
|
#define HDR_MATCHES(header) \
|
2004-12-25 13:49:30 +00:00
|
|
|
( (size_t)linelen > STRLEN_CONST(header) && \
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
g_ascii_strncasecmp(line, (header), STRLEN_CONST(header)) == 0)
|
2000-12-02 06:05:29 +00:00
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
if (HDR_MATCHES(rtsp_transport))
|
|
|
|
{
|
|
|
|
proto_tree_add_string(rtsp_tree, hf_rtsp_transport, tvb,
|
|
|
|
offset, linelen,
|
|
|
|
tvb_format_text(tvb, value_offset,
|
|
|
|
value_len));
|
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
/*
|
|
|
|
* Based on the port numbers specified
|
|
|
|
* in the Transport: header, set up
|
|
|
|
* a conversation that will be dissected
|
|
|
|
* with the appropriate dissector.
|
|
|
|
*/
|
2005-09-01 05:34:52 +00:00
|
|
|
rtsp_create_conversation(pinfo, line, linelen, rdt_feature_level);
|
2005-07-31 20:42:48 +00:00
|
|
|
} else if (HDR_MATCHES(rtsp_content_type))
|
|
|
|
{
|
|
|
|
proto_tree_add_string(rtsp_tree, hf_rtsp_content_type,
|
|
|
|
tvb, offset, linelen,
|
|
|
|
tvb_format_text(tvb, value_offset,
|
|
|
|
value_len));
|
|
|
|
|
2007-10-24 21:47:13 +00:00
|
|
|
offset = offset + STRLEN_CONST(rtsp_content_type);
|
|
|
|
/* Skip wsp */
|
|
|
|
offset = tvb_skip_wsp(tvb, offset, value_len);
|
|
|
|
semi_colon_offset = tvb_find_guint8(tvb, value_offset, value_len, ';');
|
|
|
|
if ( semi_colon_offset != -1) {
|
|
|
|
/* m-parameter present */
|
|
|
|
par_end_offset = tvb_skip_wsp_return(tvb, semi_colon_offset-1);
|
|
|
|
value_len = par_end_offset - offset;
|
2005-07-31 20:42:48 +00:00
|
|
|
}
|
2007-10-24 21:47:13 +00:00
|
|
|
|
|
|
|
media_type_str = tvb_get_ephemeral_string(tvb, offset,
|
|
|
|
value_len);
|
|
|
|
#if GLIB_MAJOR_VERSION < 2
|
|
|
|
media_type_str_lower_case = ep_strdup(media_type_str);
|
|
|
|
g_strdown(media_type_str_lower_case);
|
|
|
|
#else
|
|
|
|
media_type_str_lower_case = g_ascii_strdown(media_type_str, -1);
|
|
|
|
#endif
|
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
} else if (HDR_MATCHES(rtsp_content_length))
|
|
|
|
{
|
|
|
|
proto_tree_add_uint(rtsp_tree, hf_rtsp_content_length,
|
|
|
|
tvb, offset, linelen,
|
|
|
|
atoi(tvb_format_text(tvb, value_offset,
|
|
|
|
value_len)));
|
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
/*
|
|
|
|
* Only the amount specified by the
|
|
|
|
* Content-Length: header should be treated
|
|
|
|
* as payload.
|
|
|
|
*/
|
2005-07-31 20:42:48 +00:00
|
|
|
content_length = rtsp_get_content_length(line, linelen);
|
2004-06-15 18:26:08 +00:00
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
} else if (HDR_MATCHES(rtsp_Session))
|
|
|
|
{
|
|
|
|
/* Put the value into the protocol tree */
|
|
|
|
proto_tree_add_string(rtsp_tree, hf_rtsp_session, tvb,
|
|
|
|
offset, linelen,
|
|
|
|
tvb_format_text(tvb, value_offset, value_len));
|
2004-06-15 18:26:08 +00:00
|
|
|
|
2004-07-09 23:37:40 +00:00
|
|
|
} else if (HDR_MATCHES(rtsp_X_Vig_Msisdn)) {
|
2004-03-05 10:36:51 +00:00
|
|
|
/*
|
|
|
|
* Extract the X_Vig_Msisdn string
|
|
|
|
*/
|
2005-07-31 20:42:48 +00:00
|
|
|
if (colon_offset != -1)
|
|
|
|
{
|
|
|
|
/* Put the value into the protocol tree */
|
|
|
|
ti = proto_tree_add_string(rtsp_tree, hf_rtsp_X_Vig_Msisdn,tvb,
|
|
|
|
offset, linelen ,
|
|
|
|
tvb_format_text(tvb, value_offset, value_len));
|
|
|
|
sub_tree = proto_item_add_subtree(ti, ett_rtsp_method);
|
2004-03-19 05:33:34 +00:00
|
|
|
|
|
|
|
e164_info.e164_number_type = CALLING_PARTY_NUMBER;
|
|
|
|
e164_info.nature_of_address = 0;
|
|
|
|
|
2005-08-10 13:41:13 +00:00
|
|
|
e164_info.E164_number_str = tvb_get_ephemeral_string(tvb, value_offset,
|
2005-07-31 20:42:48 +00:00
|
|
|
value_len);
|
2004-03-19 05:33:34 +00:00
|
|
|
e164_info.E164_number_length = value_len;
|
|
|
|
dissect_e164_number(tvb, sub_tree, value_offset,
|
2005-07-31 20:42:48 +00:00
|
|
|
value_len, e164_info);
|
2004-03-05 10:36:51 +00:00
|
|
|
}
|
2005-09-01 05:34:52 +00:00
|
|
|
} else if (HDR_MATCHES(rtsp_rdt_feature_level))
|
|
|
|
{
|
|
|
|
rdt_feature_level = atoi(tvb_format_text(tvb, value_offset,
|
|
|
|
value_len));
|
|
|
|
proto_tree_add_uint(rtsp_tree, hf_rtsp_rdtfeaturelevel,
|
|
|
|
tvb, offset, linelen,
|
|
|
|
atoi(tvb_format_text(tvb, value_offset,
|
|
|
|
value_len)));
|
2000-12-02 06:05:29 +00:00
|
|
|
}
|
2005-07-31 20:42:48 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Default case for headers. Show line as text */
|
|
|
|
proto_tree_add_text(rtsp_tree, tvb, offset,
|
|
|
|
next_offset - offset, "%s",
|
|
|
|
tvb_format_text(tvb, offset, next_offset - offset));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (rtsp_type == RTSP_NOT_FIRST_LINE)
|
|
|
|
{
|
|
|
|
/* Catch-all for all other lines... Show line as text.
|
|
|
|
TODO: should these be shown as errors? */
|
|
|
|
proto_tree_add_text(rtsp_tree, tvb, offset,
|
|
|
|
next_offset - offset, "%s",
|
|
|
|
tvb_format_text(tvb, offset, next_offset - offset));
|
2000-12-02 06:05:29 +00:00
|
|
|
}
|
2005-07-31 20:42:48 +00:00
|
|
|
|
2000-11-09 10:56:33 +00:00
|
|
|
offset = next_offset;
|
1999-07-07 00:34:58 +00:00
|
|
|
}
|
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
/*
|
2005-07-31 20:42:48 +00:00
|
|
|
* Have now read all of the lines of this message.
|
|
|
|
*
|
2000-12-02 06:05:29 +00:00
|
|
|
* If a content length was supplied, the amount of data to be
|
|
|
|
* processed as RTSP payload is the minimum of the content
|
|
|
|
* length and the amount of data remaining in the frame.
|
|
|
|
*
|
2004-01-01 23:36:50 +00:00
|
|
|
* If no content length was supplied (or if a bad content length
|
|
|
|
* was supplied), the amount of data to be processed is the amount
|
|
|
|
* of data remaining in the frame.
|
2000-12-02 06:05:29 +00:00
|
|
|
*/
|
2000-11-09 10:56:33 +00:00
|
|
|
datalen = tvb_length_remaining(tvb, offset);
|
2004-01-05 03:51:28 +00:00
|
|
|
reported_datalen = tvb_reported_length_remaining(tvb, offset);
|
2000-12-02 06:05:29 +00:00
|
|
|
if (content_length != -1) {
|
2004-01-05 03:51:28 +00:00
|
|
|
/*
|
|
|
|
* Content length specified; display only that amount
|
|
|
|
* as payload.
|
|
|
|
*/
|
2000-12-02 06:05:29 +00:00
|
|
|
if (datalen > content_length)
|
|
|
|
datalen = content_length;
|
|
|
|
|
|
|
|
/*
|
2003-12-23 01:25:23 +00:00
|
|
|
* XXX - limit the reported length in the tvbuff we'll
|
|
|
|
* hand to a subdissector to be no greater than the
|
2000-12-02 06:05:29 +00:00
|
|
|
* content length.
|
2003-12-23 01:25:23 +00:00
|
|
|
*
|
|
|
|
* We really need both unreassembled and "how long it'd
|
|
|
|
* be if it were reassembled" lengths for tvbuffs, so
|
|
|
|
* that we throw the appropriate exceptions for
|
|
|
|
* "not enough data captured" (running past the length),
|
|
|
|
* "packet needed reassembly" (within the length but
|
|
|
|
* running past the unreassembled length), and
|
|
|
|
* "packet is malformed" (running past the reassembled
|
|
|
|
* length).
|
2000-12-02 06:05:29 +00:00
|
|
|
*/
|
2003-12-23 01:25:23 +00:00
|
|
|
if (reported_datalen > content_length)
|
|
|
|
reported_datalen = content_length;
|
2004-01-05 03:51:28 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* No content length specified; if this message doesn't
|
|
|
|
* have a body if no content length is specified, process
|
|
|
|
* nothing as payload.
|
|
|
|
*/
|
|
|
|
if (body_requires_content_len)
|
|
|
|
datalen = 0;
|
|
|
|
}
|
2000-12-02 06:05:29 +00:00
|
|
|
|
2000-11-30 02:06:30 +00:00
|
|
|
if (datalen > 0) {
|
|
|
|
/*
|
|
|
|
* There's stuff left over; process it.
|
|
|
|
*/
|
2007-10-24 21:47:13 +00:00
|
|
|
tvbuff_t *new_tvb;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now create a tvbuff for the Content-type stuff and
|
|
|
|
* dissect it.
|
|
|
|
*
|
|
|
|
* The amount of data to be processed that's
|
|
|
|
* available in the tvbuff is "datalen", which
|
|
|
|
* is the minimum of the amount of data left in
|
|
|
|
* the tvbuff and any specified content length.
|
|
|
|
*
|
|
|
|
* The amount of data to be processed that's in
|
|
|
|
* this frame, regardless of whether it was
|
|
|
|
* captured or not, is "reported_datalen",
|
|
|
|
* which, if no content length was specified,
|
|
|
|
* is -1, i.e. "to the end of the frame.
|
|
|
|
*/
|
|
|
|
new_tvb = tvb_new_subset(tvb, offset, datalen,
|
|
|
|
reported_datalen);
|
2000-11-09 10:56:33 +00:00
|
|
|
|
2007-10-27 14:57:46 +00:00
|
|
|
if (media_type_str_lower_case &&
|
|
|
|
dissector_try_string(media_type_dissector_table,
|
2007-10-24 21:47:13 +00:00
|
|
|
media_type_str_lower_case,
|
|
|
|
new_tvb, pinfo, rtsp_tree)){
|
|
|
|
|
|
|
|
}else {
|
2000-11-09 10:56:33 +00:00
|
|
|
/*
|
|
|
|
* Fix up the top-level item so that it doesn't
|
|
|
|
* include the SDP stuff.
|
|
|
|
*/
|
|
|
|
if (ti != NULL)
|
|
|
|
proto_item_set_len(ti, offset);
|
|
|
|
|
2001-01-11 19:30:45 +00:00
|
|
|
if (tvb_get_guint8(tvb, offset) == RTSP_FRAMEHDR) {
|
|
|
|
/*
|
|
|
|
* This is interleaved stuff; don't
|
|
|
|
* treat it as raw data - set "datalen"
|
|
|
|
* to 0, so we won't skip the offset
|
|
|
|
* past it, which will cause our
|
|
|
|
* caller to process that stuff itself.
|
|
|
|
*/
|
|
|
|
datalen = 0;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(rtsp_tree, tvb, offset,
|
2004-01-05 03:51:28 +00:00
|
|
|
datalen, "Data (%d bytes)",
|
|
|
|
reported_datalen);
|
2001-01-11 19:30:45 +00:00
|
|
|
}
|
2000-11-09 10:56:33 +00:00
|
|
|
}
|
2000-12-02 06:05:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We've processed "datalen" bytes worth of data
|
|
|
|
* (which may be no data at all); advance the
|
2004-01-01 23:36:50 +00:00
|
|
|
* offset past whatever data we've processed.
|
2000-12-02 06:05:29 +00:00
|
|
|
*/
|
|
|
|
offset += datalen;
|
1999-07-07 00:34:58 +00:00
|
|
|
}
|
2000-12-02 06:05:29 +00:00
|
|
|
return offset - orig_offset;
|
1999-07-07 00:34:58 +00:00
|
|
|
}
|
|
|
|
|
2000-11-09 10:56:33 +00:00
|
|
|
static void
|
2002-08-02 23:36:07 +00:00
|
|
|
process_rtsp_request(tvbuff_t *tvb, int offset, const guchar *data,
|
2005-07-31 20:42:48 +00:00
|
|
|
size_t linelen, size_t next_line_offset, proto_tree *tree)
|
1999-07-07 00:34:58 +00:00
|
|
|
{
|
2005-07-31 20:42:48 +00:00
|
|
|
proto_tree *sub_tree = NULL;
|
|
|
|
proto_item *ti = NULL;
|
2002-08-02 23:36:07 +00:00
|
|
|
const guchar *lineend = data + linelen;
|
2004-03-05 10:36:51 +00:00
|
|
|
unsigned ii;
|
2002-08-02 23:36:07 +00:00
|
|
|
const guchar *url;
|
|
|
|
const guchar *url_start;
|
2004-03-05 10:36:51 +00:00
|
|
|
guchar *tmp_url;
|
1999-07-07 00:34:58 +00:00
|
|
|
|
|
|
|
/* Request Methods */
|
2000-11-09 10:56:33 +00:00
|
|
|
for (ii = 0; ii < RTSP_NMETHODS; ii++) {
|
2000-01-13 03:07:26 +00:00
|
|
|
size_t len = strlen(rtsp_methods[ii]);
|
2004-05-11 10:55:42 +00:00
|
|
|
if (linelen >= len &&
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
g_ascii_strncasecmp(rtsp_methods[ii], data, len) == 0 &&
|
2004-05-11 10:55:42 +00:00
|
|
|
(len == linelen || isspace(data[len])))
|
2000-01-13 03:07:26 +00:00
|
|
|
break;
|
1999-07-07 00:34:58 +00:00
|
|
|
}
|
2000-11-09 10:56:33 +00:00
|
|
|
if (ii == RTSP_NMETHODS) {
|
|
|
|
/*
|
|
|
|
* We got here because "is_rtsp_request_or_reply()" returned
|
|
|
|
* RTSP_REQUEST, so we know one of the request methods
|
|
|
|
* matched, so we "can't get here".
|
|
|
|
*/
|
2005-06-10 18:28:22 +00:00
|
|
|
DISSECTOR_ASSERT_NOT_REACHED();
|
2000-01-13 03:07:26 +00:00
|
|
|
}
|
2000-11-09 10:56:33 +00:00
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
/* Add a tree for this request */
|
|
|
|
ti = proto_tree_add_string(tree, hf_rtsp_request, tvb, offset,
|
|
|
|
next_line_offset - offset,
|
|
|
|
tvb_format_text(tvb, offset, next_line_offset - offset));
|
|
|
|
sub_tree = proto_item_add_subtree(ti, ett_rtsp_method);
|
2004-06-15 18:26:08 +00:00
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
|
|
|
|
/* Add method name to tree */
|
|
|
|
proto_tree_add_string(sub_tree, hf_rtsp_method, tvb, offset,
|
|
|
|
strlen(rtsp_methods[ii]), rtsp_methods[ii]);
|
2000-11-09 10:56:33 +00:00
|
|
|
|
|
|
|
/* URL */
|
|
|
|
url = data;
|
2005-07-31 20:42:48 +00:00
|
|
|
/* Skip method name again */
|
2000-11-09 10:56:33 +00:00
|
|
|
while (url < lineend && !isspace(*url))
|
|
|
|
url++;
|
2005-07-31 20:42:48 +00:00
|
|
|
/* Skip spaces */
|
2000-11-09 10:56:33 +00:00
|
|
|
while (url < lineend && isspace(*url))
|
|
|
|
url++;
|
2005-07-31 20:42:48 +00:00
|
|
|
/* URL starts here */
|
2000-11-09 10:56:33 +00:00
|
|
|
url_start = url;
|
2005-07-31 20:42:48 +00:00
|
|
|
/* Scan to end of URL */
|
2000-11-09 10:56:33 +00:00
|
|
|
while (url < lineend && !isspace(*url))
|
|
|
|
url++;
|
2005-07-31 20:42:48 +00:00
|
|
|
/* Create a URL-sized buffer and copy contents */
|
2005-08-19 08:03:28 +00:00
|
|
|
tmp_url = ep_alloc(url - url_start + 1);
|
2000-11-09 10:56:33 +00:00
|
|
|
memcpy(tmp_url, url_start, url - url_start);
|
2005-07-31 20:42:48 +00:00
|
|
|
tmp_url[url - url_start] = '\0';
|
|
|
|
|
|
|
|
/* Add URL to tree */
|
|
|
|
proto_tree_add_string(sub_tree, hf_rtsp_url, tvb,
|
|
|
|
offset + (url_start - data), url - url_start, tmp_url);
|
2000-11-09 10:56:33 +00:00
|
|
|
}
|
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
/* Read first line of a reply message */
|
2000-11-09 10:56:33 +00:00
|
|
|
static void
|
2002-08-02 23:36:07 +00:00
|
|
|
process_rtsp_reply(tvbuff_t *tvb, int offset, const guchar *data,
|
2005-07-31 20:42:48 +00:00
|
|
|
size_t linelen, size_t next_line_offset, proto_tree *tree)
|
2000-11-09 10:56:33 +00:00
|
|
|
{
|
2005-07-31 20:42:48 +00:00
|
|
|
proto_tree *sub_tree = NULL;
|
|
|
|
proto_item *ti = NULL;
|
2002-08-02 23:36:07 +00:00
|
|
|
const guchar *lineend = data + linelen;
|
|
|
|
const guchar *status = data;
|
|
|
|
const guchar *status_start;
|
2000-11-09 10:56:33 +00:00
|
|
|
unsigned int status_i;
|
|
|
|
|
2005-07-31 20:42:48 +00:00
|
|
|
/* Add a tree for this request */
|
|
|
|
ti = proto_tree_add_string(tree, hf_rtsp_response, tvb, offset,
|
|
|
|
next_line_offset - offset,
|
|
|
|
tvb_format_text(tvb, offset, next_line_offset - offset));
|
|
|
|
sub_tree = proto_item_add_subtree(ti, ett_rtsp_method);
|
|
|
|
|
|
|
|
|
2000-11-09 10:56:33 +00:00
|
|
|
/* status code */
|
2005-07-31 20:42:48 +00:00
|
|
|
|
|
|
|
/* Skip protocol/version */
|
2000-11-09 10:56:33 +00:00
|
|
|
while (status < lineend && !isspace(*status))
|
|
|
|
status++;
|
2005-07-31 20:42:48 +00:00
|
|
|
/* Skip spaces */
|
2000-11-09 10:56:33 +00:00
|
|
|
while (status < lineend && isspace(*status))
|
|
|
|
status++;
|
2005-07-31 20:42:48 +00:00
|
|
|
|
|
|
|
/* Actual code number now */
|
2000-11-09 10:56:33 +00:00
|
|
|
status_start = status;
|
|
|
|
status_i = 0;
|
|
|
|
while (status < lineend && isdigit(*status))
|
|
|
|
status_i = status_i * 10 + *status++ - '0';
|
2005-07-31 20:42:48 +00:00
|
|
|
|
|
|
|
/* Add field to tree */
|
|
|
|
proto_tree_add_uint(sub_tree, hf_rtsp_status, tvb,
|
|
|
|
offset + (status_start - data),
|
|
|
|
status - status_start, status_i);
|
1999-07-07 00:34:58 +00:00
|
|
|
}
|
1999-07-29 05:47:07 +00:00
|
|
|
|
2000-12-02 06:05:29 +00:00
|
|
|
static void
|
|
|
|
dissect_rtsp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
|
|
{
|
|
|
|
int offset = 0;
|
|
|
|
int len;
|
|
|
|
|
2003-12-22 23:43:35 +00:00
|
|
|
while (tvb_reported_length_remaining(tvb, offset) != 0) {
|
2001-01-11 19:30:45 +00:00
|
|
|
len = (tvb_get_guint8(tvb, offset) == RTSP_FRAMEHDR)
|
|
|
|
? dissect_rtspinterleaved(tvb, offset, pinfo, tree)
|
|
|
|
: dissect_rtspmessage(tvb, offset, pinfo, tree);
|
2000-12-02 06:05:29 +00:00
|
|
|
if (len == -1)
|
|
|
|
break;
|
|
|
|
offset += len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* OK, we've set the Protocol and Info columns for the
|
|
|
|
* first RTSP message; make the columns non-writable,
|
|
|
|
* so that we don't change it for subsequent RTSP messages.
|
|
|
|
*/
|
2001-12-10 00:26:21 +00:00
|
|
|
col_set_writable(pinfo->cinfo, FALSE);
|
2000-12-02 06:05:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-07-29 05:47:07 +00:00
|
|
|
void
|
|
|
|
proto_register_rtsp(void)
|
|
|
|
{
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint *ett[] = {
|
2001-01-11 19:30:45 +00:00
|
|
|
&ett_rtspframe,
|
1999-11-16 11:44:20 +00:00
|
|
|
&ett_rtsp,
|
2004-03-05 10:36:51 +00:00
|
|
|
&ett_rtsp_method,
|
1999-11-16 11:44:20 +00:00
|
|
|
};
|
2000-01-13 03:07:26 +00:00
|
|
|
static hf_register_info hf[] = {
|
2005-07-31 20:42:48 +00:00
|
|
|
{ &hf_rtsp_request,
|
|
|
|
{ "Request", "rtsp.request", FT_STRING, BASE_NONE, NULL, 0,
|
|
|
|
"", HFILL }},
|
|
|
|
{ &hf_rtsp_response,
|
|
|
|
{ "Response", "rtsp.response", FT_STRING, BASE_NONE, NULL, 0,
|
|
|
|
"", HFILL }},
|
2004-03-05 10:36:51 +00:00
|
|
|
{ &hf_rtsp_method,
|
2004-06-15 18:26:08 +00:00
|
|
|
{ "Method", "rtsp.method", FT_STRING, BASE_NONE, NULL, 0,
|
2004-03-05 10:36:51 +00:00
|
|
|
"", HFILL }},
|
2005-07-31 20:42:48 +00:00
|
|
|
{ &hf_rtsp_content_type,
|
|
|
|
{ "Content-type", "rtsp.content-type", FT_STRING, BASE_NONE, NULL, 0,
|
|
|
|
"", HFILL }},
|
|
|
|
{ &hf_rtsp_content_length,
|
|
|
|
{ "Content-length", "rtsp.content-length", FT_UINT32, BASE_DEC, NULL, 0,
|
|
|
|
"", HFILL }},
|
2004-03-05 10:36:51 +00:00
|
|
|
{ &hf_rtsp_url,
|
2004-06-15 18:26:08 +00:00
|
|
|
{ "URL", "rtsp.url", FT_STRING, BASE_NONE, NULL, 0,
|
2004-03-05 10:36:51 +00:00
|
|
|
"", HFILL }},
|
|
|
|
{ &hf_rtsp_status,
|
2004-06-15 18:26:08 +00:00
|
|
|
{ "Status", "rtsp.status", FT_UINT32, BASE_DEC, NULL, 0,
|
2004-03-05 10:36:51 +00:00
|
|
|
"", HFILL }},
|
|
|
|
{ &hf_rtsp_session,
|
2004-06-15 18:26:08 +00:00
|
|
|
{ "Session", "rtsp.session", FT_STRING, BASE_NONE, NULL, 0,
|
2004-03-05 10:36:51 +00:00
|
|
|
"", HFILL }},
|
2005-07-31 20:42:48 +00:00
|
|
|
{ &hf_rtsp_transport,
|
|
|
|
{ "Transport", "rtsp.transport", FT_STRING, BASE_NONE, NULL, 0,
|
|
|
|
"", HFILL }},
|
2005-09-01 05:34:52 +00:00
|
|
|
{ &hf_rtsp_rdtfeaturelevel,
|
|
|
|
{ "RDTFeatureLevel", "rtsp.rdt-feature-level", FT_UINT32, BASE_DEC, NULL, 0,
|
|
|
|
"", HFILL }},
|
2004-03-05 10:36:51 +00:00
|
|
|
{ &hf_rtsp_X_Vig_Msisdn,
|
2004-06-15 18:26:08 +00:00
|
|
|
{ "X-Vig-Msisdn", "X_Vig_Msisdn", FT_STRING, BASE_NONE, NULL, 0,
|
2004-03-05 10:36:51 +00:00
|
|
|
"", HFILL }},
|
|
|
|
|
|
|
|
|
2000-01-13 03:07:26 +00:00
|
|
|
};
|
2003-12-17 21:03:15 +00:00
|
|
|
module_t *rtsp_module;
|
1999-07-29 05:47:07 +00:00
|
|
|
|
2007-10-24 21:47:13 +00:00
|
|
|
proto_rtsp = proto_register_protocol("Real Time Streaming Protocol",
|
2001-01-03 06:56:03 +00:00
|
|
|
"RTSP", "rtsp");
|
2007-10-24 21:47:13 +00:00
|
|
|
media_type_dissector_table = find_dissector_table("media_type");
|
|
|
|
|
2000-01-13 03:07:26 +00:00
|
|
|
proto_register_field_array(proto_rtsp, hf, array_length(hf));
|
1999-11-16 11:44:20 +00:00
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2001-09-08 00:43:51 +00:00
|
|
|
|
2003-12-17 21:03:15 +00:00
|
|
|
/* Register our configuration options, particularly our ports */
|
|
|
|
|
|
|
|
rtsp_module = prefs_register_protocol(proto_rtsp, proto_reg_handoff_rtsp);
|
|
|
|
prefs_register_uint_preference(rtsp_module, "tcp.port",
|
|
|
|
"RTSP TCP Port",
|
|
|
|
"Set the TCP port for RTSP messages",
|
|
|
|
10, &global_rtsp_tcp_port);
|
2003-12-23 00:01:07 +00:00
|
|
|
prefs_register_uint_preference(rtsp_module, "tcp.alternate_port",
|
|
|
|
"Alternate RTSP TCP Port",
|
|
|
|
"Set the alternate TCP port for RTSP messages",
|
|
|
|
10, &global_rtsp_tcp_alternate_port);
|
2003-12-31 09:58:56 +00:00
|
|
|
prefs_register_bool_preference(rtsp_module, "desegment_headers",
|
2004-08-21 09:02:52 +00:00
|
|
|
"Reassemble RTSP headers spanning multiple TCP segments",
|
|
|
|
"Whether the RTSP dissector should reassemble headers "
|
|
|
|
"of a request spanning multiple TCP segments. "
|
|
|
|
" To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
|
2003-12-22 08:58:22 +00:00
|
|
|
&rtsp_desegment_headers);
|
2003-12-31 09:58:56 +00:00
|
|
|
prefs_register_bool_preference(rtsp_module, "desegment_body",
|
2004-01-17 12:51:00 +00:00
|
|
|
"Trust the \"Content-length:\" header and\ndesegment RTSP "
|
|
|
|
"bodies\nspanning multiple TCP segments",
|
2003-12-22 08:58:22 +00:00
|
|
|
"Whether the RTSP dissector should use the "
|
|
|
|
"\"Content-length:\" value to desegment the body "
|
|
|
|
"of a request spanning multiple TCP segments",
|
|
|
|
&rtsp_desegment_body);
|
2003-12-17 21:03:15 +00:00
|
|
|
|
1999-07-29 05:47:07 +00:00
|
|
|
}
|
2000-04-08 07:07:42 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_rtsp(void)
|
|
|
|
{
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_handle_t rtsp_handle;
|
2003-12-17 21:03:15 +00:00
|
|
|
static int rtsp_prefs_initialized = FALSE;
|
2001-12-03 04:00:26 +00:00
|
|
|
|
|
|
|
rtsp_handle = create_dissector_handle(dissect_rtsp, proto_rtsp);
|
2003-12-17 21:03:15 +00:00
|
|
|
|
|
|
|
if (!rtsp_prefs_initialized) {
|
|
|
|
rtsp_prefs_initialized = TRUE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
dissector_delete("tcp.port", tcp_port, rtsp_handle);
|
2003-12-23 00:01:07 +00:00
|
|
|
dissector_delete("tcp.port", tcp_alternate_port, rtsp_handle);
|
2003-12-17 21:03:15 +00:00
|
|
|
}
|
|
|
|
/* Set our port number for future use */
|
2004-06-15 18:26:08 +00:00
|
|
|
|
2003-12-17 21:03:15 +00:00
|
|
|
tcp_port = global_rtsp_tcp_port;
|
2003-12-23 00:01:07 +00:00
|
|
|
tcp_alternate_port = global_rtsp_tcp_alternate_port;
|
2004-06-15 18:26:08 +00:00
|
|
|
|
2003-12-17 21:03:15 +00:00
|
|
|
dissector_add("tcp.port", tcp_port, rtsp_handle);
|
2003-12-23 00:01:07 +00:00
|
|
|
dissector_add("tcp.port", tcp_alternate_port, rtsp_handle);
|
Add a mechanism by which a dissector can be registered by name, another
dissector can get a "handle" for that dissector by name and then call
that dissector through the handle.
This allows dissectors that can't be called through a port table or a
heuristic table to be called from other dissectors without directly
referring to the dissector function - dynamically-loaded modules, under
Windows, cannot directly call functions in the main program, and
non-plugin dissectors are in the main program and thus cannot be called
from plugin dissectors unless either
1) a pointer to the dissector is put in the Big Transfer Vector
or
2) some other mechanism for getting a pointer to the dissector
is provided.
This mechanism could also support registering old-style dissectors and
calling them from new-style dissectors without the new-style dissector
having to do the argument translation itself (I didn't add support for
registering old-style dissectors because I'd prefer to have people
tvbuffify their code if they have to register a dissector...).
It could also, in the future, perhaps support
disabling of protocols;
setting "pinfo->current_proto";
inside "call_dissector()" - and inside "{old_}dissector_try_port()" and
"{old_"dissector_try_heuristic()" - allowing a pile of stuff that
currently has to be done in every dissector be done by common code.
(I have some ideas about how to do this, by
having "proto_register_protocol()" take an abbreviation - of the
sort that would be put in, for example, "pinfo->current_proto" -
as an argument;
having the calls to register dissectors take an index returned
by "proto_register_protocol()" as an argument.
The abbreviation could be used elsewhere as well, e.g. in the "Decoding"
tab of the "Edit->Protocols" dialog box, and in a GUI for constructing
protocol filters. Watch this space.)
Make "dissect_sdp()" the first client of this mechanism; it's now static
to "packet-sdp.c", and all dissectors that call it - including the MGCP
plugin - now call it through a dissector handle fetched by
"find_dissector()". (Next step - see if Ethereal can now compile on
Windows as a result of this.)
svn path=/trunk/; revision=2647
2000-11-15 07:07:52 +00:00
|
|
|
|
2001-09-08 00:43:51 +00:00
|
|
|
rtp_handle = find_dissector("rtp");
|
|
|
|
rtcp_handle = find_dissector("rtcp");
|
2005-05-26 20:11:35 +00:00
|
|
|
rdt_handle = find_dissector("rdt");
|
2000-04-08 07:07:42 +00:00
|
|
|
}
|