packet-rtsp.c

   1 /* packet-rtsp.c
   2  * Routines for RTSP packet disassembly
   3  *
   4  * Jason Lango <jal@netapp.com>
   5  * Liberally copied from packet-http.c, by Guy Harris <guy@netapp.com>
   6  *
   7  * $Id: packet-rtsp.c,v 1.4 1999/11/16 11:42:53 guy Exp $
   8  *
   9  * Ethereal - Network traffic analyzer
  10  * By Gerald Combs <gerald@zing.org>
  11  * Copyright 1998 Gerald Combs
  12  *
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  27  *
  28  *
  29  */
  30
  31 #include "config.h"
  32
  33 #ifdef HAVE_SYS_TYPES_H
  34 #include <sys/types.h>
  35 #endif
  36
  37 #include <string.h>
  38 #include <ctype.h>
  39
  40 #include <glib.h>
  41 #include "packet.h"
  42
  43 static int proto_rtsp = -1;
  44
  45 static gint ett_rtsp = -1;
  46
  47 static int is_rtsp_request_or_reply(const u_char *data, int linelen);
  48
  49 static int
  50 is_content_sdp(const u_char *line, int linelen)
  51 {
  52         const char      *hdr = "Content-Type:";
  53         size_t          hdrlen = strlen(hdr);
  54         const char      *type = "application/sdp";
  55         size_t          typelen = strlen(type);
  56
  57         if (linelen < hdrlen || strncasecmp(hdr, line, hdrlen))
  58                 return 0;
  59
  60         line += hdrlen;
  61         linelen -= hdrlen;
  62         while (linelen > 0 && (*line == ' ' || *line == '\t')) {
  63                 line++;
  64                 linelen--;
  65         }
  66
  67         if (linelen < typelen || strncasecmp(type, line, typelen))
  68                 return 0;
  69
  70         line += typelen;
  71         linelen -= typelen;
  72         if (linelen > 0 && !isspace(*line))
  73                 return 0;
  74
  75         return 1;
  76 }
  77
  78 void dissect_rtsp(const u_char *pd, int offset, frame_data *fd,
  79         proto_tree *tree)
  80 {
  81         proto_tree      *rtsp_tree;
  82         proto_item      *ti;
  83         const u_char    *data, *dataend;
  84         const u_char    *linep, *lineend, *eol;
  85         int             linelen;
  86         u_char          c;
  87         int             is_sdp = 0;
  88
  89         data = &pd[offset];
  90         dataend = data + END_OF_FRAME;
  91
  92         if (check_col(fd, COL_PROTOCOL))
  93                 col_add_str(fd, COL_PROTOCOL, "RTSP");
  94         if (check_col(fd, COL_INFO)) {
  95                 /*
  96                  * Put the first line from the buffer into the summary,
  97                  * if it's an RTSP request or reply.
  98                  * Otherwise, just call it a continuation.
  99                  */
 100                 lineend = find_line_end(data, dataend, &eol);
 101                 linelen = lineend - data;
 102                 if (is_rtsp_request_or_reply(data, linelen))
 103                         col_add_str(fd, COL_INFO, format_text(data, linelen));
 104                 else
 105                         col_add_str(fd, COL_INFO, "Continuation");
 106         }
 107
 108         rtsp_tree = NULL;
 109
 110         if (tree) {
 111                 ti = proto_tree_add_item(tree, proto_rtsp, offset, END_OF_FRAME, NULL);
 112                 rtsp_tree = proto_item_add_subtree(ti, ett_rtsp);
 113         }
 114
 115         while (data < dataend) {
 116                 /*
 117                  * Find the end of the line.
 118                  */
 119                 lineend = find_line_end(data, dataend, &eol);
 120                 linelen = lineend - data;
 121
 122                 /*
 123                  * OK, does it look like an RTSP request or
 124                  * response?
 125                  */
 126                 if (is_rtsp_request_or_reply(data, linelen))
 127                         goto is_rtsp;
 128
 129                 /*
 130                  * No.  Does it look like a blank line (as would
 131                  * appear at the end of an RTSP request)?
 132                  */
 133                 if (linelen == 1) {
 134                         if (*data == '\n')
 135                                 goto is_rtsp;
 136                 }
 137                 if (linelen == 2) {
 138                         if (strncmp(data, "\r\n", 2) == 0 ||
 139                             strncmp(data, "\n\r", 2) == 0)
 140                                 goto is_rtsp;
 141                 }
 142
 143                 /*
 144                  * No.  Does it look like a MIME header?
 145                  */
 146                 linep = data;
 147                 while (linep < lineend) {
 148                         c = *linep++;
 149                         if (!isprint(c))
 150                                 break;  /* not printable, not a MIME header */
 151                         switch (c) {
 152
 153                         case '(':
 154                         case ')':
 155                         case '<':
 156                         case '>':
 157                         case '@':
 158                         case ',':
 159                         case ';':
 160                         case '\\':
 161                         case '"':
 162                         case '/':
 163                         case '[':
 164                         case ']':
 165                         case '?':
 166                         case '=':
 167                         case '{':
 168                         case '}':
 169                                 /*
 170                                  * It's a tspecial, so it's not
 171                                  * part of a token, so it's not
 172                                  * a field name for the beginning
 173                                  * of a MIME header.
 174                                  */
 175                                 goto not_rtsp;
 176
 177                         case ':':
 178                                 /*
 179                                  * This ends the token; we consider
 180                                  * this to be a MIME header.
 181                                  */
 182                                 if (is_content_sdp(data, linelen))
 183                                         is_sdp = 1;
 184                                 goto is_rtsp;
 185                         }
 186                 }
 187
 188         not_rtsp:
 189                 /*
 190                  * We don't consider this part of an RTSP request or
 191                  * reply, so we don't display it.
 192                  */
 193                 break;
 194
 195         is_rtsp:
 196                 /*
 197                  * Put this line.
 198                  */
 199                 if (rtsp_tree) {
 200                         proto_tree_add_text(rtsp_tree, offset, linelen, "%s",
 201                             format_text(data, linelen));
 202                 }
 203                 offset += linelen;
 204                 data = lineend;
 205         }
 206
 207         if (is_sdp) {
 208                 dissect_sdp(pd, offset, fd, tree);
 209                 if (check_col(fd, COL_PROTOCOL))
 210                         col_add_str(fd, COL_PROTOCOL, "RTSP/SDP");
 211         }
 212         else if (rtsp_tree && data < dataend) {
 213                 proto_tree_add_text(rtsp_tree, offset, END_OF_FRAME,
 214                     "Data (%d bytes)", END_OF_FRAME);
 215         }
 216 }
 217
 218 const char *rtsp_methods[] = {
 219         "DESCRIBE", "ANNOUNCE", "GET_PARAMETER", "OPTIONS",
 220         "PAUSE", "PLAY", "RECORD", "REDIRECT", "SETUP",
 221         "SET_PARAMETER", "TEARDOWN"
 222 };
 223 const int rtsp_nmethods = sizeof(rtsp_methods) / sizeof(*rtsp_methods);
 224
 225 static int
 226 is_rtsp_request_or_reply(const u_char *data, int linelen)
 227 {
 228         int             ii;
 229         size_t          len;
 230
 231         /* Reply */
 232         if (linelen >= 5 && !strncasecmp("RTSP/", data, 5))
 233                 return TRUE;
 234
 235         /* Request Methods */
 236         for (ii = 0; ii < rtsp_nmethods; ii++) {
 237                 len = strlen(rtsp_methods[ii]);
 238                 if (linelen >= len && !strncasecmp(rtsp_methods[ii], data, len))
 239                         return TRUE;
 240         }
 241
 242         return FALSE;
 243 }
 244
 245 void
 246 proto_register_rtsp(void)
 247 {
 248 /*        static hf_register_info hf[] = {
 249                 { &variable,
 250                 { "Name",           "rtsp.abbreviation", TYPE, VALS_POINTER }},
 251         };*/
 252         static gint *ett[] = {
 253                 &ett_rtsp,
 254         };
 255
 256         proto_rtsp = proto_register_protocol("Real Time Streaming Protocol", "rtsp");
 257  /*       proto_register_field_array(proto_rtsp, hf, array_length(hf));*/
 258         proto_register_subtree_array(ett, array_length(ett));
 259 }