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