modules/access/rtsp/rtsp.c

   1 /*****************************************************************************
   2  * rtsp.c: minimalistic implementation of rtsp protocol.
   3  *         Not RFC 2326 compilant yet and only handle REAL RTSP.
   4  *****************************************************************************
   5  * Copyright (C) 2002-2004 the xine project
   6  * Copyright (C) 2005 VideoLAN
   7  * $Id$
   8  *
   9  * Authors: Gildas Bazin <gbazin@videolan.org>
  10  *          Adapted from xine which itself adapted it from joschkas real tools.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc_common.h>
  32 #include <vlc_access.h>
  33 #include <vlc_messages.h>
  34
  35 #include "rtsp.h"
  36
  37 #define BUF_SIZE 4096
  38 #define HEADER_SIZE 1024
  39 #define MAX_FIELDS 256
  40
  41 struct rtsp_s {
  42
  43   int           s;
  44
  45   char         *host;
  46   int           port;
  47   char         *path;
  48   char         *mrl;
  49   char         *user_agent;
  50
  51   char         *server;
  52   unsigned int  server_state;
  53   uint32_t      server_caps;
  54
  55   unsigned int  cseq;
  56   char         *session;
  57
  58   char        *answers[MAX_FIELDS];   /* data of last message */
  59   char        *scheduled[MAX_FIELDS]; /* will be sent with next message */
  60 };
  61
  62 /*
  63  * constants
  64  */
  65
  66 const char rtsp_protocol_version[]="RTSP/1.0";
  67
  68 /* server states */
  69 #define RTSP_CONNECTED 1
  70 #define RTSP_INIT      2
  71 #define RTSP_READY     4
  72 #define RTSP_PLAYING   8
  73 #define RTSP_RECORDING 16
  74
  75 /* server capabilities */
  76 #define RTSP_OPTIONS       0x001
  77 #define RTSP_DESCRIBE      0x002
  78 #define RTSP_ANNOUNCE      0x004
  79 #define RTSP_SETUP         0x008
  80 #define RTSP_GET_PARAMETER 0x010
  81 #define RTSP_SET_PARAMETER 0x020
  82 #define RTSP_TEARDOWN      0x040
  83 #define RTSP_PLAY          0x080
  84 #define RTSP_RECORD        0x100
  85
  86 /*
  87  * rtsp_get gets a line from stream
  88  * and returns a null terminated string (must be freed).
  89  */
  90
  91 static char *rtsp_get( rtsp_client_t *rtsp )
  92 {
  93   char *psz_buffer = xmalloc( BUF_SIZE );
  94   char *psz_string = NULL;
  95
  96   if( rtsp->pf_read_line( rtsp->p_userdata, (uint8_t*)psz_buffer, (unsigned int)BUF_SIZE ) >= 0 )
  97   {
  98     //printf( "<< '%s'\n", psz_buffer );
  99       psz_string = strdup( psz_buffer );
 100   }
 101
 102   free( psz_buffer );
 103   return psz_string;
 104 }
 105
 106
 107 /*
 108  * rtsp_put puts a line on stream
 109  */
 110
 111 static int rtsp_put( rtsp_client_t *rtsp, const char *psz_string )
 112 {
 113     unsigned int i_buffer = strlen( psz_string );
 114     uint8_t *psz_buffer = xmalloc( i_buffer + 2 );
 115     int i_ret;
 116
 117     memcpy( psz_buffer, psz_string, i_buffer );
 118     psz_buffer[i_buffer] = '\r'; psz_buffer[i_buffer+1] = '\n';
 119
 120     i_ret = rtsp->pf_write( rtsp->p_userdata, psz_buffer, i_buffer + 2 );
 121
 122     free( psz_buffer );
 123     return i_ret;
 124 }
 125
 126 /*
 127  * extract server status code
 128  */
 129
 130 static int rtsp_get_status_code( rtsp_client_t *rtsp, const char *psz_string )
 131 {
 132     VLC_UNUSED(rtsp);
 133     char psz_buffer[4] = {0,0,0,0};
 134     int i_code = 0;
 135
 136     if( !strncmp( psz_string, "RTSP/1.0", sizeof("RTSP/1.0") - 1 ) )
 137     {
 138         strncpy(psz_buffer, psz_string + sizeof("RTSP/1.0"), 3);
 139         i_code = atoi( psz_buffer );
 140     }
 141     else if( !strncmp( psz_string, "SET_PARAMETER", sizeof("SET_PARAMETER") - 1 ) )
 142     {
 143         return RTSP_STATUS_SET_PARAMETER;
 144     }
 145
 146     if( i_code != 200 )
 147     {
 148         //fprintf( stderr, "librtsp: server responds: '%s'\n", psz_string );
 149     }
 150
 151     return i_code;
 152 }
 153
 154 /*
 155  * send a request
 156  */
 157
 158 static int rtsp_send_request( rtsp_client_t *rtsp, const char *psz_type,
 159                               const char *psz_what )
 160 {
 161     char **ppsz_payload;
 162     char *psz_buffer;
 163     int i_ret, i;
 164
 165     if (rtsp->p_private == NULL)
 166       return -1;
 167
 168     ppsz_payload = rtsp->p_private->scheduled;
 169
 170     psz_buffer = xmalloc( strlen(psz_type) + strlen(psz_what) +
 171                          sizeof("RTSP/1.0") + 2 );
 172
 173     sprintf( psz_buffer, "%s %s %s", psz_type, psz_what, "RTSP/1.0" );
 174     i_ret = rtsp_put( rtsp, psz_buffer );
 175     free( psz_buffer );
 176
 177     for (i = 0; i < MAX_FIELDS; ++i) {
 178       if (!ppsz_payload[i])
 179         break;
 180
 181       rtsp_put (rtsp, ppsz_payload[i]);
 182     }
 183
 184     rtsp_put( rtsp, "" );
 185     rtsp_unschedule_all( rtsp );
 186
 187     return i_ret;
 188 }
 189
 190 /*
 191  * schedule standard fields
 192  */
 193
 194 static void rtsp_schedule_standard( rtsp_client_t *rtsp )
 195 {
 196     char tmp[sizeof("CSeq: ") + 3 * sizeof(int)];
 197
 198     sprintf( tmp, "CSeq: %u", rtsp->p_private->cseq);
 199     rtsp_schedule_field( rtsp, tmp );
 200
 201     if( rtsp->p_private->session )
 202     {
 203         char *buf;
 204         buf = xmalloc( strlen(rtsp->p_private->session) + 15 );
 205         sprintf( buf, "Session: %s", rtsp->p_private->session );
 206         rtsp_schedule_field( rtsp, buf );
 207         free( buf );
 208     }
 209 }
 210
 211 /*
 212  * get the answers, if server responses with something != 200, return NULL
 213  */
 214
 215 static int rtsp_get_answers( rtsp_client_t *rtsp )
 216 {
 217     access_t *p_access = (access_t*)rtsp->p_userdata;
 218     char *answer = NULL;
 219     unsigned int answer_seq;
 220     char **answer_ptr = rtsp->p_private->answers;
 221     int code;
 222     int ans_count = 0;
 223
 224     answer = rtsp_get( rtsp );
 225     if( !answer ) return 0;
 226     code = rtsp_get_status_code( rtsp, answer );
 227     free( answer );
 228
 229     rtsp_free_answers( rtsp );
 230
 231     do { /* while we get answer lines */
 232
 233       answer = rtsp_get( rtsp );
 234       if( !answer ) return 0;
 235
 236       if( !strncasecmp( answer, "CSeq:", 5 ) )
 237       {
 238           if (sscanf( answer, "%*s %u", &answer_seq ) == 1) {
 239               if( rtsp->p_private->cseq != answer_seq )
 240               {
 241                 msg_Warn (p_access, "Cseq mismatch, got %u, assumed %u", answer_seq, rtsp->p_private->cseq);
 242                 rtsp->p_private->cseq = answer_seq;
 243               }
 244           } else {
 245             msg_Warn (p_access, "remote server sent CSeq without payload, ignoring.");
 246           }
 247       }
 248       if( !strncasecmp( answer, "Server:", 7 ) )
 249       {
 250           char *buf = xmalloc( strlen(answer) );
 251           if (sscanf( answer, "%*s %s", buf ) == 1) {
 252             free( rtsp->p_private->server );
 253             rtsp->p_private->server = buf;
 254           } else {
 255             msg_Warn(p_access, "remote server sent Server without payload, ignoring.");
 256           }
 257       }
 258       if( !strncasecmp( answer, "Session:", 8 ) )
 259       {
 260           char *buf = xmalloc( strlen(answer) );
 261           if (sscanf( answer, "%*s %s", buf ) == 1) { // TODO: ignore attributes "Session: ${session-id};${attribute=value...}"
 262               if( rtsp->p_private->session )
 263               {
 264                   if( strcmp( buf, rtsp->p_private->session ) )
 265                   {
 266                       msg_Warn (p_access, "setting NEW session: %s", buf);
 267                       free( rtsp->p_private->session );
 268                       rtsp->p_private->session = strdup( buf );
 269                   }
 270               }
 271               else
 272               {
 273                   msg_Dbg (p_access, "session id: '%s'", buf);
 274                   rtsp->p_private->session = strdup( buf );
 275               }
 276           } else {
 277             msg_Warn(p_access, "remote server sent Session without payload, ignoring.");
 278           }
 279           free( buf );
 280       }
 281
 282       *answer_ptr = answer;
 283       answer_ptr++;
 284     } while( (strlen(answer) != 0) && (++ans_count < MAX_FIELDS) );
 285
 286     rtsp->p_private->cseq++;
 287
 288     if (ans_count != MAX_FIELDS) {
 289       *answer_ptr = NULL;
 290     }
 291
 292     rtsp_schedule_standard( rtsp );
 293
 294     return code;
 295 }
 296
 297 /*
 298  * send an ok message
 299  */
 300
 301 int rtsp_send_ok( rtsp_client_t *rtsp )
 302 {
 303     char cseq[sizeof("CSeq: ") + 3 * sizeof(int)];
 304
 305     rtsp_put( rtsp, "RTSP/1.0 200 OK" );
 306     sprintf( cseq, "CSeq: %u", rtsp->p_private->cseq );
 307     rtsp_put( rtsp, cseq );
 308     rtsp_put( rtsp, "" );
 309     return 0;
 310 }
 311
 312 /*
 313  * implementation of must-have rtsp requests; functions return
 314  * server status code.
 315  */
 316
 317 int rtsp_request_options( rtsp_client_t *rtsp, const char *what )
 318 {
 319     char *buf;
 320
 321     if( what ) buf = strdup(what);
 322     else
 323     {
 324         buf = xmalloc( strlen(rtsp->p_private->host) + 16 );
 325         sprintf( buf, "rtsp://%s:%i", rtsp->p_private->host,
 326                  rtsp->p_private->port );
 327     }
 328     rtsp_send_request( rtsp, "OPTIONS", buf );
 329     free( buf );
 330
 331     return rtsp_get_answers( rtsp );
 332 }
 333
 334 int rtsp_request_describe( rtsp_client_t *rtsp, const char *what )
 335 {
 336     char *buf;
 337
 338     if( what )
 339     {
 340         buf = strdup(what);
 341     }
 342     else
 343     {
 344         buf = xmalloc( strlen(rtsp->p_private->host) +
 345                       strlen(rtsp->p_private->path) + 16 );
 346         sprintf( buf, "rtsp://%s:%i/%s", rtsp->p_private->host,
 347                  rtsp->p_private->port, rtsp->p_private->path );
 348     }
 349     rtsp_send_request( rtsp, "DESCRIBE", buf );
 350     free( buf );
 351
 352     return rtsp_get_answers( rtsp );
 353 }
 354
 355 int rtsp_request_setup( rtsp_client_t *rtsp, const char *what )
 356 {
 357     rtsp_send_request( rtsp, "SETUP", what );
 358     return rtsp_get_answers( rtsp );
 359 }
 360
 361 int rtsp_request_setparameter( rtsp_client_t *rtsp, const char *what )
 362 {
 363     char *buf;
 364
 365     if( what )
 366     {
 367         buf = strdup(what);
 368     }
 369     else
 370     {
 371         buf = xmalloc( strlen(rtsp->p_private->host) +
 372                       strlen(rtsp->p_private->path) + 16 );
 373         sprintf( buf, "rtsp://%s:%i/%s", rtsp->p_private->host,
 374                  rtsp->p_private->port, rtsp->p_private->path );
 375     }
 376
 377     rtsp_send_request( rtsp, "SET_PARAMETER", buf );
 378     free( buf );
 379
 380     return rtsp_get_answers( rtsp );
 381 }
 382
 383 int rtsp_request_play( rtsp_client_t *rtsp, const char *what )
 384 {
 385     char *buf;
 386
 387     if( what )
 388     {
 389         buf = strdup( what );
 390     }
 391     else
 392     {
 393         buf = xmalloc( strlen(rtsp->p_private->host) +
 394                       strlen(rtsp->p_private->path) + 16 );
 395         sprintf( buf, "rtsp://%s:%i/%s", rtsp->p_private->host,
 396                  rtsp->p_private->port, rtsp->p_private->path );
 397     }
 398
 399     rtsp_send_request( rtsp, "PLAY", buf );
 400     free( buf );
 401
 402     return rtsp_get_answers( rtsp );
 403 }
 404
 405 int rtsp_request_tearoff( rtsp_client_t *rtsp, const char *what )
 406 {
 407     rtsp_send_request( rtsp, "TEAROFF", what );
 408     return rtsp_get_answers( rtsp );
 409 }
 410
 411 /*
 412  * read opaque data from stream
 413  */
 414
 415 int rtsp_read_data( rtsp_client_t *rtsp, uint8_t *buffer, unsigned int size )
 416 {
 417     int i, seq;
 418
 419     if( size >= 4 )
 420     {
 421         i = rtsp->pf_read( rtsp->p_userdata, (uint8_t*)buffer, (unsigned int) 4 );
 422         if( i < 4 ) return i;
 423
 424         if( buffer[0]=='S' && buffer[1]=='E' && buffer[2]=='T' &&
 425             buffer[3]=='_' )
 426         {
 427             char *rest = rtsp_get( rtsp );
 428             if( !rest ) return -1;
 429
 430             seq = -1;
 431             do
 432             {
 433                 free( rest );
 434                 rest = rtsp_get( rtsp );
 435                 if( !rest ) return -1;
 436
 437                 if( !strncasecmp( rest, "CSeq:", 5 ) )
 438                     sscanf( rest, "%*s %u", &seq );
 439             } while( *rest );
 440             free( rest );
 441
 442             if( seq < 0 )
 443             {
 444                 //fprintf(stderr, "warning: cseq not recognized!\n");
 445                 seq = 1;
 446             }
 447
 448             /* lets make the server happy */
 449             rtsp_put( rtsp, "RTSP/1.0 451 Parameter Not Understood" );
 450             rest = xmalloc(sizeof("Cseq: ") + 3 * sizeof(int));
 451             sprintf( rest,"CSeq: %u", seq );
 452             rtsp_put( rtsp, rest );
 453             rtsp_put( rtsp, "" );
 454             free( rest );
 455             i = rtsp->pf_read( rtsp->p_userdata, (unsigned char*)buffer, size );
 456         }
 457         else
 458         {
 459             i = rtsp->pf_read( rtsp->p_userdata, (unsigned char*)buffer + 4, size - 4 );
 460             i += 4;
 461         }
 462     }
 463     else i = rtsp->pf_read( rtsp->p_userdata, (unsigned char*)buffer, size );
 464
 465     //fprintf( stderr, "<< %d of %d bytes\n", i, size );
 466
 467     return i;
 468 }
 469
 470 /*
 471  * connect to a rtsp server
 472  */
 473
 474 int rtsp_connect( rtsp_client_t *rtsp, const char *psz_mrl,
 475                   const char *psz_user_agent )
 476 {
 477     rtsp_t *s;
 478     char *mrl_ptr;
 479     char *slash, *colon;
 480     unsigned int hostend, pathbegin, i;
 481
 482     if( !psz_mrl ) return -1;
 483     s = xmalloc( sizeof(rtsp_t) );
 484     rtsp->p_private = s;
 485
 486     if( !strncmp( psz_mrl, "rtsp://", 7 ) ) psz_mrl += 7;
 487     mrl_ptr = strdup( psz_mrl );
 488
 489     for( i=0; i<MAX_FIELDS; i++ )
 490     {
 491         s->answers[i]=NULL;
 492         s->scheduled[i]=NULL;
 493     }
 494
 495     s->host = NULL;
 496     s->port = 554; /* rtsp standard port */
 497     s->path = NULL;
 498     s->mrl  = strdup(psz_mrl);
 499
 500     s->server = NULL;
 501     s->server_state = 0;
 502     s->server_caps = 0;
 503
 504     s->cseq = 0;
 505     s->session = NULL;
 506
 507     if( psz_user_agent ) s->user_agent = strdup( psz_user_agent );
 508     else s->user_agent = strdup( "User-Agent: RealMedia Player Version "
 509                                  "6.0.9.1235 (linux-2.0-libc6-i386-gcc2.95)" );
 510
 511     slash = strchr( mrl_ptr, '/' );
 512     colon = strchr( mrl_ptr, ':' );
 513
 514     if( !slash ) slash = mrl_ptr + strlen(mrl_ptr) + 1;
 515     if( !colon ) colon = slash;
 516     if( colon > slash ) colon = slash;
 517
 518     pathbegin = slash - mrl_ptr;
 519     hostend = colon - mrl_ptr;
 520
 521     s->host = xmalloc(hostend+1);
 522     strncpy( s->host, mrl_ptr, hostend );
 523     s->host[hostend] = 0;
 524
 525     if( pathbegin < strlen(mrl_ptr) ) s->path = strdup(mrl_ptr+pathbegin+1);
 526     if( colon != slash )
 527     {
 528         char buffer[pathbegin-hostend];
 529
 530         strncpy( buffer, mrl_ptr+hostend+1, pathbegin-hostend-1 );
 531         buffer[pathbegin-hostend-1] = 0;
 532         s->port = atoi(buffer);
 533         if( s->port < 0 || s->port > 65535 ) s->port = 554;
 534     }
 535
 536     free( mrl_ptr );
 537     //fprintf( stderr, "got mrl: %s %i %s\n", s->host, s->port, s->path );
 538
 539     s->s = rtsp->pf_connect( rtsp->p_userdata, s->host, s->port );
 540
 541     if( s->s < 0 )
 542     {
 543         //fprintf(stderr, "rtsp: failed to connect to '%s'\n", s->host);
 544         rtsp_close( rtsp );
 545         return -1;
 546     }
 547
 548     s->server_state = RTSP_CONNECTED;
 549
 550     /* now lets send an options request. */
 551     rtsp_schedule_field( rtsp, "CSeq: 1");
 552     rtsp_schedule_field( rtsp, s->user_agent);
 553     rtsp_schedule_field( rtsp, "ClientChallenge: "
 554                                "9e26d33f2984236010ef6253fb1887f7");
 555     rtsp_schedule_field( rtsp, "PlayerStarttime: [28/03/2003:22:50:23 00:00]");
 556     rtsp_schedule_field( rtsp, "CompanyID: KnKV4M4I/B2FjJ1TToLycw==" );
 557     rtsp_schedule_field( rtsp, "GUID: 00000000-0000-0000-0000-000000000000" );
 558     rtsp_schedule_field( rtsp, "RegionData: 0" );
 559     rtsp_schedule_field( rtsp, "ClientID: "
 560                                "Linux_2.4_6.0.9.1235_play32_RN01_EN_586" );
 561     /*rtsp_schedule_field( rtsp, "Pragma: initiate-session" );*/
 562     rtsp_request_options( rtsp, NULL );
 563
 564     return 0;
 565 }
 566
 567 /*
 568  * closes an rtsp connection
 569  */
 570
 571 void rtsp_close( rtsp_client_t *rtsp )
 572 {
 573     if( rtsp->p_private->server_state )
 574     {
 575         /* TODO: send a TEAROFF */
 576         rtsp->pf_disconnect( rtsp->p_userdata );
 577     }
 578
 579     free( rtsp->p_private->path );
 580     free( rtsp->p_private->host );
 581     free( rtsp->p_private->mrl );
 582     free( rtsp->p_private->session );
 583     free( rtsp->p_private->user_agent );
 584     free( rtsp->p_private->server );
 585     rtsp_free_answers( rtsp );
 586     rtsp_unschedule_all( rtsp );
 587     free( rtsp->p_private );
 588 }
 589
 590 /*
 591  * search in answers for tags. returns a pointer to the content
 592  * after the first matched tag. returns NULL if no match found.
 593  */
 594
 595 char *rtsp_search_answers( rtsp_client_t *rtsp, const char *tag )
 596 {
 597     char **answers;
 598     char *ptr;
 599     int i;
 600
 601     if(rtsp->p_private->answers == NULL || tag == NULL)
 602       return NULL;
 603
 604     answers = rtsp->p_private->answers;
 605
 606     for (i = 0; i < MAX_FIELDS; ++i) {
 607       if (answers[i] == NULL)
 608         break;
 609
 610       if (!strncasecmp(answers[i], tag, strlen(tag))){
 611         ptr = strchr(answers[i], ':');
 612
 613         if (ptr == NULL)
 614           return answers[i] + strlen(answers[i]); /* no payload => empty string */
 615
 616         for (++ptr; *ptr == ' '; ++ptr)
 617           ;
 618
 619         return ptr;
 620       }
 621     }
 622
 623     return NULL;
 624 }
 625
 626 /*
 627  * session id management
 628  */
 629
 630 void rtsp_set_session( rtsp_client_t *rtsp, const char *id )
 631 {
 632     free( rtsp->p_private->session );
 633     rtsp->p_private->session = strdup(id);
 634 }
 635
 636 char *rtsp_get_session( rtsp_client_t *rtsp )
 637 {
 638     return rtsp->p_private->session;
 639 }
 640
 641 char *rtsp_get_mrl( rtsp_client_t *rtsp )
 642 {
 643     return rtsp->p_private->mrl;
 644 }
 645
 646 /*
 647  * schedules a field for transmission
 648  */
 649
 650 void rtsp_schedule_field( rtsp_client_t *rtsp, const char *data )
 651 {
 652     access_t * p_access = (access_t*)rtsp->p_userdata;
 653     char **pptr;
 654     int i = 0;
 655
 656     if( rtsp->p_private == NULL || data == NULL)
 657       return;
 658
 659     pptr = rtsp->p_private->scheduled;
 660
 661     for (i = 0; i < MAX_FIELDS; ++i) {
 662       if (pptr[i] == NULL) {
 663         pptr[i] = strdup(data);
 664         break;
 665       }
 666     }
 667
 668     if (i == MAX_FIELDS) {
 669       msg_Warn (p_access, "Unable to schedule '%s': the buffer is full!", data);
 670     }
 671 }
 672
 673 /*
 674  * removes the first scheduled field which prefix matches string.
 675  */
 676
 677 void rtsp_unschedule_field( rtsp_client_t *rtsp, const char *needle )
 678 {
 679     char **pptr;
 680     int i;
 681
 682     if (rtsp->p_private == NULL || needle == NULL)
 683       return;
 684
 685     pptr = rtsp->p_private->scheduled;
 686
 687     for (i = 0; i < MAX_FIELDS; ++i) {
 688       if (pptr[i] == NULL)
 689         break;
 690
 691       if (!strncmp (pptr[i], needle, strlen(needle))) {
 692         free (pptr[i]);
 693         pptr[i] = NULL;
 694         break;
 695       }
 696     }
 697
 698     for (i++; i < MAX_FIELDS && pptr[i]; ++i) {
 699       pptr[i-1] = pptr[i];
 700     }
 701
 702     if (i < MAX_FIELDS) {
 703       pptr[i] = NULL;
 704     }
 705 }
 706
 707 static void pp_free_helper_ (char **pptr, int max_length) {
 708   int i;
 709
 710   for (i = 0; i < max_length; ++i) {
 711     if (pptr[i] == NULL)
 712       break;
 713
 714     free (pptr[i]);
 715     pptr[i] = NULL;
 716   }
 717 }
 718
 719 /*
 720  * unschedule all fields
 721  */
 722
 723 void rtsp_unschedule_all( rtsp_client_t *rtsp )
 724 {
 725   if (rtsp->p_private == NULL)
 726     return;
 727
 728   pp_free_helper_ (rtsp->p_private->scheduled, MAX_FIELDS);
 729 }
 730 /*
 731  * free answers
 732  */
 733
 734 void rtsp_free_answers( rtsp_client_t *rtsp )
 735 {
 736   if (rtsp->p_private == NULL)
 737     return;
 738
 739   pp_free_helper_ (rtsp->p_private->answers, MAX_FIELDS);
 740 }