stream/realrtsp/real.c

   1 /*
   2  * This file was ported to MPlayer from xine CVS real.c,v 1.8 2003/03/30 17:11:50
   3  */
   4
   5 /*
   6  * Copyright (C) 2002 the xine project
   7  *
   8  * This file is part of xine, a free video player.
   9  *
  10  * xine is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * xine is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  23  *
  24  *
  25  * special functions for real streams.
  26  * adopted from joschkas real tools.
  27  *
  28  */
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32
  33 #include "config.h"
  34 #include "libavutil/common.h"
  35 #include "real.h"
  36 #include "asmrp.h"
  37 #include "sdpplin.h"
  38 #include "xbuffer.h"
  39 #include "libavutil/md5.h"
  40 #include "ffmpeg_files/intreadwrite.h"
  41 #include "stream/http.h"
  42 #include "mp_msg.h"
  43
  44 /*
  45 #define LOG
  46 */
  47
  48 #define XOR_TABLE_SIZE 37
  49
  50 static const unsigned char xor_table[XOR_TABLE_SIZE] = {
  51     0x05, 0x18, 0x74, 0xd0, 0x0d, 0x09, 0x02, 0x53,
  52     0xc0, 0x01, 0x05, 0x05, 0x67, 0x03, 0x19, 0x70,
  53     0x08, 0x27, 0x66, 0x10, 0x10, 0x72, 0x08, 0x09,
  54     0x63, 0x11, 0x03, 0x71, 0x08, 0x08, 0x70, 0x02,
  55     0x10, 0x57, 0x05, 0x18, 0x54 };
  56
  57
  58 #define BUF_SIZE 4096
  59
  60 #ifdef LOG
  61 static void hexdump (const char *buf, int length) {
  62
  63   int i;
  64
  65   printf (" hexdump> ");
  66   for (i = 0; i < length; i++) {
  67     unsigned char c = buf[i];
  68
  69     printf ("%02x", c);
  70
  71     if ((i % 16) == 15)
  72       printf ("\n         ");
  73
  74     if ((i % 2) == 1)
  75       printf (" ");
  76
  77   }
  78   printf ("\n");
  79 }
  80 #endif
  81
  82
  83 static void real_calc_response_and_checksum (char *response, char *chksum, char *challenge) {
  84
  85   int   ch_len;
  86   int   i;
  87   unsigned char zres[16], buf[64];
  88
  89   /* initialize buffer */
  90   AV_WB32(buf, 0xa1e9149d);
  91   AV_WB32(buf+4, 0x0e6b3b59);
  92
  93   /* some (length) checks */
  94   if (challenge != NULL)
  95   {
  96     ch_len = strlen (challenge);
  97
  98     if (ch_len == 40) /* what a hack... */
  99       ch_len=32;
 100     if ( ch_len > 56 ) ch_len=56;
 101
 102     /* copy challenge to buf */
 103     memcpy(buf+8, challenge, ch_len);
 104     memset(buf+8+ch_len, 0, 56-ch_len);
 105   }
 106
 107     /* xor challenge bytewise with xor_table */
 108     for (i=0; i<XOR_TABLE_SIZE; i++)
 109       buf[8+i] ^= xor_table[i];
 110
 111   av_md5_sum(zres, buf, 64);
 112
 113   /* convert zres to ascii string */
 114   for (i=0; i<16; i++ )
 115     sprintf(response+i*2, "%02x", zres[i]);
 116
 117   /* add tail */
 118   strcpy (&response[32], "01d0a8e3");
 119
 120   /* calculate checksum */
 121   for (i=0; i<8; i++)
 122     chksum[i] = response[i*4];
 123   chksum[8] = 0;
 124 }
 125
 126
 127 /*
 128  * takes a MLTI-Chunk and a rule number got from match_asm_rule,
 129  * returns a pointer to selected data and number of bytes in that.
 130  */
 131
 132 static int select_mlti_data(const char *mlti_chunk, int mlti_size, int selection, char **out) {
 133
 134   int numrules, codec, size;
 135   int i;
 136
 137   /* MLTI chunk should begin with MLTI */
 138
 139   if ((mlti_chunk[0] != 'M')
 140       ||(mlti_chunk[1] != 'L')
 141       ||(mlti_chunk[2] != 'T')
 142       ||(mlti_chunk[3] != 'I'))
 143   {
 144 #ifdef LOG
 145     printf("libreal: MLTI tag not detected, copying data\n");
 146 #endif
 147     *out = xbuffer_copyin(*out, 0, mlti_chunk, mlti_size);
 148     return mlti_size;
 149   }
 150
 151   mlti_chunk+=4;
 152
 153   /* next 16 bits are the number of rules */
 154   numrules=AV_RB16(mlti_chunk);
 155   if (selection >= numrules) return 0;
 156
 157   /* now <numrules> indices of codecs follows */
 158   /* we skip to selection                     */
 159   mlti_chunk+=(selection+1)*2;
 160
 161   /* get our index */
 162   codec=AV_RB16(mlti_chunk);
 163
 164   /* skip to number of codecs */
 165   mlti_chunk+=(numrules-selection)*2;
 166
 167   /* get number of codecs */
 168   numrules=AV_RB16(mlti_chunk);
 169
 170   if (codec >= numrules) {
 171     mp_msg(MSGT_STREAM, MSGL_WARN, "realrtsp: codec index >= number of codecs. %i %i\n",
 172       codec, numrules);
 173     return 0;
 174   }
 175
 176   mlti_chunk+=2;
 177
 178   /* now seek to selected codec */
 179   for (i=0; i<codec; i++) {
 180     size=AV_RB32(mlti_chunk);
 181     mlti_chunk+=size+4;
 182   }
 183
 184   size=AV_RB32(mlti_chunk);
 185
 186 #ifdef LOG
 187   hexdump(mlti_chunk+4, size);
 188 #endif
 189   *out = xbuffer_copyin(*out, 0, mlti_chunk+4, size);
 190   return size;
 191 }
 192
 193 /*
 194  * looking at stream description.
 195  */
 196
 197 static rmff_header_t *real_parse_sdp(char *data, char **stream_rules, uint32_t bandwidth) {
 198
 199   sdpplin_t *desc;
 200   rmff_header_t *header;
 201   char *buf;
 202   int len, i;
 203   int max_bit_rate=0;
 204   int avg_bit_rate=0;
 205   int max_packet_size=0;
 206   int avg_packet_size=0;
 207   int duration=0;
 208
 209
 210   if (!data) return NULL;
 211
 212   desc=sdpplin_parse(data);
 213
 214   if (!desc) return NULL;
 215
 216   buf = xbuffer_init(2048);
 217   header=calloc(1,sizeof(rmff_header_t));
 218
 219   header->fileheader=rmff_new_fileheader(4+desc->stream_count);
 220   header->cont=rmff_new_cont(
 221       desc->title,
 222       desc->author,
 223       desc->copyright,
 224       desc->abstract);
 225   header->data=rmff_new_dataheader(0,0);
 226   header->streams=calloc(1,sizeof(rmff_mdpr_t*)*(desc->stream_count+1));
 227 #ifdef LOG
 228     printf("number of streams: %u\n", desc->stream_count);
 229 #endif
 230
 231   for (i=0; i<desc->stream_count; i++) {
 232
 233     int j=0;
 234     int n;
 235     char b[64];
 236     int rulematches[MAX_RULEMATCHES];
 237
 238     if (!desc->stream[i])
 239       continue;
 240 #ifdef LOG
 241     printf("calling asmrp_match with:\n%s\n%u\n", desc->stream[i]->asm_rule_book, bandwidth);
 242 #endif
 243     n=asmrp_match(desc->stream[i]->asm_rule_book, bandwidth, rulematches);
 244     for (j=0; j<n; j++) {
 245 #ifdef LOG
 246       printf("asmrp rule match: %u for stream %u\n", rulematches[j], desc->stream[i]->stream_id);
 247 #endif
 248       sprintf(b,"stream=%u;rule=%u,", desc->stream[i]->stream_id, rulematches[j]);
 249       *stream_rules = xbuffer_strcat(*stream_rules, b);
 250     }
 251
 252     if (!desc->stream[i]->mlti_data) {
 253         len = 0;
 254         buf = xbuffer_free(buf);
 255     } else
 256     len=select_mlti_data(desc->stream[i]->mlti_data, desc->stream[i]->mlti_data_size, rulematches[0], &buf);
 257
 258     header->streams[i]=rmff_new_mdpr(
 259         desc->stream[i]->stream_id,
 260         desc->stream[i]->max_bit_rate,
 261         desc->stream[i]->avg_bit_rate,
 262         desc->stream[i]->max_packet_size,
 263         desc->stream[i]->avg_packet_size,
 264         desc->stream[i]->start_time,
 265         desc->stream[i]->preroll,
 266         desc->stream[i]->duration,
 267         desc->stream[i]->stream_name,
 268         desc->stream[i]->mime_type,
 269         len,
 270         buf);
 271
 272     duration=FFMAX(duration,desc->stream[i]->duration);
 273     max_bit_rate+=desc->stream[i]->max_bit_rate;
 274     avg_bit_rate+=desc->stream[i]->avg_bit_rate;
 275     max_packet_size=FFMAX(max_packet_size, desc->stream[i]->max_packet_size);
 276     if (avg_packet_size)
 277       avg_packet_size=(avg_packet_size + desc->stream[i]->avg_packet_size) / 2;
 278     else
 279       avg_packet_size=desc->stream[i]->avg_packet_size;
 280   }
 281
 282   if (*stream_rules && strlen(*stream_rules) && (*stream_rules)[strlen(*stream_rules)-1] == ',')
 283     (*stream_rules)[strlen(*stream_rules)-1]=0; /* delete last ',' in stream_rules */
 284
 285   header->prop=rmff_new_prop(
 286       max_bit_rate,
 287       avg_bit_rate,
 288       max_packet_size,
 289       avg_packet_size,
 290       0,
 291       duration,
 292       0,
 293       0,
 294       0,
 295       desc->stream_count,
 296       desc->flags);
 297
 298   rmff_fix_header(header);
 299   buf = xbuffer_free(buf);
 300   sdpplin_free(desc);
 301
 302   return header;
 303 }
 304
 305 int real_get_rdt_chunk(rtsp_t *rtsp_session, char **buffer, int rdt_rawdata) {
 306
 307   int n=1;
 308   uint8_t header[8];
 309   rmff_pheader_t ph;
 310   int size;
 311   int flags1, flags2;
 312   int unknown1;
 313   uint32_t ts;
 314   static uint32_t prev_ts = -1;
 315   static int prev_stream_number = -1;
 316
 317   n=rtsp_read_data(rtsp_session, header, 8);
 318   if (n<8) return 0;
 319   if (header[0] != 0x24)
 320   {
 321     mp_msg(MSGT_STREAM, MSGL_WARN, "realrtsp: rdt chunk not recognized: got 0x%02x\n",
 322       header[0]);
 323     return 0;
 324   }
 325   /* header[1] is channel, normally 0, ignored */
 326   size=(header[2]<<8)+header[3];
 327   flags1=header[4];
 328   if ((flags1 & 0xc0) != 0x40)
 329   {
 330 #ifdef LOG
 331     printf("got flags1: 0x%02x\n",flags1);
 332 #endif
 333     if(header[6] == 0x06) { // eof packet
 334       rtsp_read_data(rtsp_session, header, 7); // Skip the rest of the eof packet
 335       /* Some files have short auxiliary streams, we must ignore eof packets
 336        * for these streams to avoid premature eof.
 337        * Now the code declares eof only if the stream with id == 0 gets eof
 338        * (old code was: eof on the first eof packet received).
 339        */
 340       if(flags1 & 0x7c) // ignore eof for streams with id != 0
 341         return 0;
 342       mp_msg(MSGT_STREAM, MSGL_INFO, "realrtsp: Stream EOF detected\n");
 343       return -1;
 344     }
 345     header[0]=header[5];
 346     header[1]=header[6];
 347     header[2]=header[7];
 348     n=rtsp_read_data(rtsp_session, header+3, 5);
 349     if (n<5) return 0;
 350 #ifdef LOG
 351     printf("ignoring bytes:\n");
 352     hexdump(header, 8);
 353 #endif
 354     n=rtsp_read_data(rtsp_session, header+4, 4);
 355     if (n<4) return 0;
 356     flags1=header[4];
 357     size-=9;
 358   }
 359   flags2=header[7];
 360   // header[5..6] == frame number in stream
 361   unknown1=(header[5]<<16)+(header[6]<<8)+(header[7]);
 362   n=rtsp_read_data(rtsp_session, header, 6);
 363   if (n<6) return 0;
 364   ts=AV_RB32(header);
 365
 366 #ifdef LOG
 367   printf("ts: %u, size: %u, flags: 0x%02x, unknown values: 0x%06x 0x%02x 0x%02x\n",
 368           ts, size, flags1, unknown1, header[4], header[5]);
 369 #endif
 370   size+=2;
 371
 372   ph.object_version=0;
 373   ph.length=size;
 374   ph.stream_number=(flags1>>1)&0x1f;
 375   ph.timestamp=ts;
 376   ph.reserved=0;
 377   if ((flags2&1) == 0 && (prev_ts != ts || prev_stream_number != ph.stream_number))
 378   {
 379     prev_ts = ts;
 380     prev_stream_number = ph.stream_number;
 381     ph.flags=2;
 382   }
 383   else
 384     ph.flags=0;
 385   *buffer = xbuffer_ensure_size(*buffer, 12+size);
 386   if(rdt_rawdata) {
 387       if (size < 12)
 388           return 0;
 389     n=rtsp_read_data(rtsp_session, *buffer, size-12);
 390     return (n <= 0) ? 0 : n;
 391   }
 392   rmff_dump_pheader(&ph, *buffer);
 393   if (size < 12)
 394       return 0;
 395   size-=12;
 396   n=rtsp_read_data(rtsp_session, (*buffer)+12, size);
 397
 398   return (n <= 0) ? 0 : n+12;
 399 }
 400
 401 static int convert_timestamp(char *str, int *sec, int *msec) {
 402   int hh, mm, ss, ms = 0;
 403
 404   // Timestamp may be optionally quoted with ", skip it
 405   // Since the url is escaped when we get here, we skip the string "%22"
 406   if (!strncmp(str, "%22", 3))
 407     str += 3;
 408   if (sscanf(str, "%d:%d:%d.%d", &hh, &mm, &ss, &ms) < 3) {
 409     hh = 0;
 410     if (sscanf(str, "%d:%d.%d", &mm, &ss, &ms) < 2) {
 411       mm = 0;
 412       if (sscanf(str, "%d.%d", &ss, &ms) < 1) {
 413         ss = 0;
 414         ms = 0;
 415       }
 416     }
 417   }
 418   if (sec)
 419     *sec = hh * 3600 + mm * 60 + ss;
 420   if (msec)
 421     *msec = ms;
 422   return 1;
 423 }
 424
 425 //! maximum size of the rtsp description, must be < INT_MAX
 426 #define MAX_DESC_BUF (20 * 1024 * 1024)
 427 rmff_header_t *real_setup_and_get_header(rtsp_t *rtsp_session, uint32_t bandwidth,
 428   char *username, char *password) {
 429
 430   char *description=NULL;
 431   char *session_id=NULL;
 432   rmff_header_t *h = NULL;
 433   char *challenge1 = NULL;
 434   char challenge2[41];
 435   char checksum[9];
 436   char *subscribe = NULL;
 437   char *buf = xbuffer_init(256);
 438   char *mrl=rtsp_get_mrl(rtsp_session);
 439   unsigned int size;
 440   int status;
 441   uint32_t maxbandwidth = bandwidth;
 442   char* authfield = NULL;
 443   int i;
 444
 445   /* get challenge */
 446   challenge1=rtsp_search_answers(rtsp_session,"RealChallenge1");
 447   if (!challenge1)
 448       goto out;
 449   challenge1=strdup(challenge1);
 450 #ifdef LOG
 451   printf("real: Challenge1: %s\n", challenge1);
 452 #endif
 453
 454   /* set a reasonable default to get the best stream, unless bandwidth given */
 455   if (!bandwidth)
 456       bandwidth = 10485800;
 457
 458   /* request stream description */
 459 rtsp_send_describe:
 460   rtsp_schedule_field(rtsp_session, "Accept: application/sdp");
 461   sprintf(buf, "Bandwidth: %u", bandwidth);
 462   rtsp_schedule_field(rtsp_session, buf);
 463   rtsp_schedule_field(rtsp_session, "GUID: 00000000-0000-0000-0000-000000000000");
 464   rtsp_schedule_field(rtsp_session, "RegionData: 0");
 465   rtsp_schedule_field(rtsp_session, "ClientID: Linux_2.4_6.0.9.1235_play32_RN01_EN_586");
 466   rtsp_schedule_field(rtsp_session, "SupportsMaximumASMBandwidth: 1");
 467   rtsp_schedule_field(rtsp_session, "Language: en-US");
 468   rtsp_schedule_field(rtsp_session, "Require: com.real.retain-entity-for-setup");
 469   if(authfield)
 470     rtsp_schedule_field(rtsp_session, authfield);
 471   status=rtsp_request_describe(rtsp_session,NULL);
 472
 473   if (status == 401) {
 474     int authlen, b64_authlen;
 475     char *authreq;
 476     char* authstr = NULL;
 477
 478     if (authfield) {
 479       mp_msg(MSGT_STREAM, MSGL_ERR, "realrtsp: authorization failed, check your credentials\n");
 480       goto autherr;
 481     }
 482     if (!(authreq = rtsp_search_answers(rtsp_session,"WWW-Authenticate"))) {
 483       mp_msg(MSGT_STREAM, MSGL_ERR, "realrtsp: 401 but no auth request, aborting\n");
 484       goto autherr;
 485     }
 486     if (!username) {
 487       mp_msg(MSGT_STREAM, MSGL_ERR, "realrtsp: auth required but no username supplied\n");
 488       goto autherr;
 489     }
 490     if (!strstr(authreq, "Basic")) {
 491       mp_msg(MSGT_STREAM, MSGL_ERR, "realrtsp: authenticator not supported (%s)\n", authreq);
 492       goto autherr;
 493     }
 494     authlen = strlen(username) + (password ? strlen(password) : 0) + 2;
 495     authstr = malloc(authlen);
 496     sprintf(authstr, "%s:%s", username, password ? password : "");
 497     authfield = malloc(authlen*2+22);
 498     strcpy(authfield, "Authorization: Basic ");
 499     b64_authlen = base64_encode(authstr, authlen, authfield+21, authlen*2);
 500     free(authstr);
 501     if (b64_authlen < 0) {
 502       mp_msg(MSGT_STREAM, MSGL_ERR, "realrtsp: base64 output overflow, this should never happen\n");
 503       goto autherr;
 504     }
 505     authfield[b64_authlen+21] = 0;
 506     goto rtsp_send_describe;
 507   }
 508 autherr:
 509
 510   if (authfield)
 511      free(authfield);
 512
 513   if ( status<200 || status>299 )
 514   {
 515     char *alert=rtsp_search_answers(rtsp_session,"Alert");
 516     if (alert) {
 517       mp_msg(MSGT_STREAM, MSGL_WARN, "realrtsp: got message from server:\n%s\n",
 518         alert);
 519     }
 520     rtsp_send_ok(rtsp_session);
 521     goto out;
 522   }
 523
 524   /* receive description */
 525   size=0;
 526   if (!rtsp_search_answers(rtsp_session,"Content-length"))
 527     mp_msg(MSGT_STREAM, MSGL_WARN, "real: got no Content-length!\n");
 528   else
 529     size=atoi(rtsp_search_answers(rtsp_session,"Content-length"));
 530
 531   // as size is unsigned this also catches the case (size < 0)
 532   if (size > MAX_DESC_BUF) {
 533     mp_msg(MSGT_STREAM, MSGL_ERR, "realrtsp: Content-length for description too big (> %uMB)!\n",
 534             MAX_DESC_BUF/(1024*1024) );
 535     goto out;
 536   }
 537
 538   if (!rtsp_search_answers(rtsp_session,"ETag"))
 539     mp_msg(MSGT_STREAM, MSGL_WARN, "realrtsp: got no ETag!\n");
 540   else
 541     session_id=strdup(rtsp_search_answers(rtsp_session,"ETag"));
 542
 543 #ifdef LOG
 544   printf("real: Stream description size: %u\n", size);
 545 #endif
 546
 547   description=malloc(size+1);
 548
 549   if( rtsp_read_data(rtsp_session, description, size) <= 0) {
 550     goto out;
 551   }
 552   description[size]=0;
 553
 554   /* parse sdp (sdpplin) and create a header and a subscribe string */
 555   subscribe = xbuffer_init(256);
 556   strcpy(subscribe, "Subscribe: ");
 557   h=real_parse_sdp(description, &subscribe, bandwidth);
 558   if (!h) {
 559     goto out;
 560   }
 561   rmff_fix_header(h);
 562
 563 #ifdef LOG
 564   printf("Title: %s\nCopyright: %s\nAuthor: %s\nStreams: %i\n",
 565     h->cont->title, h->cont->copyright, h->cont->author, h->prop->num_streams);
 566 #endif
 567
 568   /* setup our streams */
 569   real_calc_response_and_checksum (challenge2, checksum, challenge1);
 570   buf = xbuffer_ensure_size(buf, strlen(challenge2) + strlen(checksum) + 32);
 571   sprintf(buf, "RealChallenge2: %s, sd=%s", challenge2, checksum);
 572   rtsp_schedule_field(rtsp_session, buf);
 573   buf = xbuffer_ensure_size(buf, strlen(session_id) + 32);
 574   sprintf(buf, "If-Match: %s", session_id);
 575   rtsp_schedule_field(rtsp_session, buf);
 576   rtsp_schedule_field(rtsp_session, "Transport: x-pn-tng/tcp;mode=play,rtp/avp/tcp;unicast;mode=play");
 577   buf = xbuffer_ensure_size(buf, strlen(mrl) + 32);
 578   sprintf(buf, "%s/streamid=0", mrl);
 579   rtsp_request_setup(rtsp_session,buf,NULL);
 580
 581   /* Do setup for all the other streams we subscribed to */
 582   for (i = 1; i < h->prop->num_streams; i++) {
 583     rtsp_schedule_field(rtsp_session, "Transport: x-pn-tng/tcp;mode=play,rtp/avp/tcp;unicast;mode=play");
 584     buf = xbuffer_ensure_size(buf, strlen(session_id) + 32);
 585     sprintf(buf, "If-Match: %s", session_id);
 586     rtsp_schedule_field(rtsp_session, buf);
 587
 588     buf = xbuffer_ensure_size(buf, strlen(mrl) + 32);
 589     sprintf(buf, "%s/streamid=%d", mrl, i);
 590     rtsp_request_setup(rtsp_session,buf,NULL);
 591   }
 592   /* set stream parameter (bandwidth) with our subscribe string */
 593   rtsp_schedule_field(rtsp_session, subscribe);
 594   rtsp_request_setparameter(rtsp_session,NULL);
 595
 596   /* set delivery bandwidth */
 597   if (maxbandwidth) {
 598       sprintf(buf, "SetDeliveryBandwidth: Bandwidth=%u;BackOff=0", maxbandwidth);
 599       rtsp_schedule_field(rtsp_session, buf);
 600       rtsp_request_setparameter(rtsp_session,NULL);
 601   }
 602
 603   {
 604     int s_ss = 0, s_ms = 0, e_ss = 0, e_ms = 0;
 605     char *str;
 606     if ((str = rtsp_get_param(rtsp_session, "start"))) {
 607       convert_timestamp(str, &s_ss, &s_ms);
 608       free(str);
 609     }
 610     if ((str = rtsp_get_param(rtsp_session, "end"))) {
 611       convert_timestamp(str, &e_ss, &e_ms);
 612       free(str);
 613     }
 614     str = buf + sprintf(buf, s_ms ? "%s%d.%d-" : "%s%d-", "Range: npt=", s_ss, s_ms);
 615     if (e_ss || e_ms)
 616       sprintf(str, e_ms ? "%d.%d" : "%d", e_ss, e_ms);
 617   }
 618   rtsp_schedule_field(rtsp_session, buf);
 619   /* and finally send a play request */
 620   rtsp_request_play(rtsp_session,NULL);
 621
 622 out:
 623   subscribe = xbuffer_free(subscribe);
 624   buf = xbuffer_free(buf);
 625   free(description);
 626   free(session_id);
 627   free(challenge1);
 628   return h;
 629 }
 630
 631 struct real_rtsp_session_t *
 632 init_real_rtsp_session (void)
 633 {
 634   struct real_rtsp_session_t *real_rtsp_session = NULL;
 635
 636   real_rtsp_session = malloc (sizeof (struct real_rtsp_session_t));
 637   real_rtsp_session->recv = xbuffer_init (BUF_SIZE);
 638   real_rtsp_session->rdteof = 0;
 639   real_rtsp_session->rdt_rawdata = 0;
 640
 641   return real_rtsp_session;
 642 }
 643
 644 void
 645 free_real_rtsp_session (struct real_rtsp_session_t* real_session)
 646 {
 647   if (!real_session)
 648     return;
 649
 650   xbuffer_free (real_session->recv);
 651   free (real_session);
 652 }