stream/librtsp/rtsp_session.c

   1 /*
   2  * This file was ported to MPlayer from xine CVS rtsp_session.c,v 1.9 2003/02/11 16:20:40
   3  */
   4
   5 /*
   6  * Copyright (C) 2000-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  * high level interface to rtsp servers.
  26  *
  27  *    2006, Benjamin Zores and Vincent Mussard
  28  *      Support for MPEG-TS streaming through RFC compliant RTSP servers
  29  */
  30
  31 #include <sys/types.h>
  32 #include "config.h"
  33 #if !HAVE_WINSOCK2_H
  34 #include <sys/socket.h>
  35 #include <netinet/in.h>
  36 #include <netdb.h>
  37 #else
  38 #include <winsock2.h>
  39 #endif
  40
  41
  42 #include <unistd.h>
  43 #include <stdio.h>
  44 #include <fcntl.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <inttypes.h>
  48
  49 #include "mp_msg.h"
  50 #include "rtsp.h"
  51 #include "rtsp_rtp.h"
  52 #include "rtsp_session.h"
  53 #include "stream/network.h"
  54 #include "stream/url.h"
  55 #include "stream/rtp.h"
  56 #include "stream/realrtsp/real.h"
  57 #include "stream/realrtsp/rmff.h"
  58 #include "stream/realrtsp/asmrp.h"
  59 #include "stream/realrtsp/xbuffer.h"
  60
  61 /*
  62 #define LOG
  63 */
  64
  65 #define RTSP_OPTIONS_PUBLIC "Public"
  66 #define RTSP_OPTIONS_SERVER "Server"
  67 #define RTSP_OPTIONS_LOCATION "Location"
  68 #define RTSP_OPTIONS_REAL "RealChallenge1"
  69 #define RTSP_SERVER_TYPE_REAL "Real"
  70 #define RTSP_SERVER_TYPE_HELIX "Helix"
  71 #define RTSP_SERVER_TYPE_UNKNOWN "unknown"
  72
  73 struct rtsp_session_s {
  74   rtsp_t       *s;
  75   struct real_rtsp_session_t* real_session;
  76   struct rtp_rtsp_session_t* rtp_session;
  77 };
  78
  79 /*
  80  * closes an rtsp connection
  81  */
  82
  83 static void rtsp_close(rtsp_t *s) {
  84
  85   if (s->server_state)
  86   {
  87     if (s->server_state == RTSP_PLAYING)
  88       rtsp_request_teardown (s, NULL);
  89     closesocket (s->s);
  90   }
  91
  92   free(s->path);
  93   free(s->host);
  94   free(s->mrl);
  95   free(s->session);
  96   free(s->user_agent);
  97   free(s->server);
  98   rtsp_free_answers(s);
  99   rtsp_unschedule_all(s);
 100   free(s);
 101 }
 102
 103 //rtsp_session_t *rtsp_session_start(char *mrl) {
 104 rtsp_session_t *rtsp_session_start(int fd, char **mrl, char *path, char *host,
 105   int port, int *redir, uint32_t bandwidth, char *user, char *pass) {
 106
 107   rtsp_session_t *rtsp_session = NULL;
 108   char *server;
 109   char *mrl_line = NULL;
 110
 111   rtsp_session = malloc (sizeof (rtsp_session_t));
 112   rtsp_session->s = NULL;
 113   rtsp_session->real_session = NULL;
 114   rtsp_session->rtp_session = NULL;
 115
 116 //connect:
 117   *redir = 0;
 118
 119   /* connect to server */
 120   rtsp_session->s=rtsp_connect(fd,*mrl,path,host,port,NULL);
 121   if (!rtsp_session->s)
 122   {
 123     mp_msg (MSGT_OPEN, MSGL_ERR,"rtsp_session: failed to connect to server %s\n", path);
 124     free(rtsp_session);
 125     return NULL;
 126   }
 127
 128   /* looking for server type */
 129   if (rtsp_search_answers(rtsp_session->s,RTSP_OPTIONS_SERVER))
 130     server=strdup(rtsp_search_answers(rtsp_session->s,RTSP_OPTIONS_SERVER));
 131   else {
 132     if (rtsp_search_answers(rtsp_session->s,RTSP_OPTIONS_REAL))
 133       server=strdup(RTSP_SERVER_TYPE_REAL);
 134     else
 135       server=strdup(RTSP_SERVER_TYPE_UNKNOWN);
 136   }
 137   if (strstr(server,RTSP_SERVER_TYPE_REAL) || strstr(server,RTSP_SERVER_TYPE_HELIX))
 138   {
 139     /* we are talking to a real server ... */
 140
 141     rmff_header_t *h=real_setup_and_get_header(rtsp_session->s, bandwidth, user, pass);
 142     if (!h || !h->streams[0]) {
 143       rmff_free_header(h);
 144       /* got an redirect? */
 145       if (rtsp_search_answers(rtsp_session->s, RTSP_OPTIONS_LOCATION))
 146       {
 147         free(mrl_line);
 148         mrl_line=strdup(rtsp_search_answers(rtsp_session->s, RTSP_OPTIONS_LOCATION));
 149         mp_msg (MSGT_OPEN, MSGL_INFO,"rtsp_session: redirected to %s\n", mrl_line);
 150         rtsp_close(rtsp_session->s);
 151         free(server);
 152         free(*mrl);
 153         free(rtsp_session);
 154         /* tell the caller to redirect, return url to redirect to in mrl */
 155         *mrl = mrl_line;
 156         *redir = 1;
 157         return NULL;
 158 //      goto connect; /* *shudder* i made a design mistake somewhere */
 159       } else
 160       {
 161         mp_msg (MSGT_OPEN, MSGL_ERR,"rtsp_session: session can not be established.\n");
 162         rtsp_close(rtsp_session->s);
 163         free (server);
 164         free(rtsp_session);
 165         return NULL;
 166       }
 167     }
 168
 169     rtsp_session->real_session = init_real_rtsp_session ();
 170     if(!strncmp(h->streams[0]->mime_type, "application/vnd.rn-rmadriver", h->streams[0]->mime_type_size) ||
 171        !strncmp(h->streams[0]->mime_type, "application/smil", h->streams[0]->mime_type_size)) {
 172       rtsp_session->real_session->header_len = 0;
 173       rtsp_session->real_session->recv_size = 0;
 174       rtsp_session->real_session->rdt_rawdata = 1;
 175       mp_msg(MSGT_OPEN, MSGL_V, "smil-over-realrtsp playlist, switching to raw rdt mode\n");
 176     } else {
 177     rtsp_session->real_session->header_len =
 178       rmff_dump_header (h, (char *) rtsp_session->real_session->header, RTSP_HEADER_SIZE);
 179
 180       if (rtsp_session->real_session->header_len < 0) {
 181         mp_msg (MSGT_OPEN, MSGL_ERR,"rtsp_session: error while dumping RMFF headers, session can not be established.\n");
 182         free_real_rtsp_session(rtsp_session->real_session);
 183         rtsp_close(rtsp_session->s);
 184         free (server);
 185         free (mrl_line);
 186         free(rtsp_session);
 187         return NULL;
 188       }
 189
 190     rtsp_session->real_session->recv =
 191       xbuffer_copyin (rtsp_session->real_session->recv, 0,
 192                       rtsp_session->real_session->header,
 193                       rtsp_session->real_session->header_len);
 194
 195     rtsp_session->real_session->recv_size =
 196       rtsp_session->real_session->header_len;
 197     }
 198     rtsp_session->real_session->recv_read = 0;
 199     rmff_free_header(h);
 200   } else /* not a Real server : try RTP instead */
 201   {
 202     char *public = NULL;
 203
 204     /* look for the Public: field in response to RTSP OPTIONS */
 205     if (!(public = rtsp_search_answers (rtsp_session->s, RTSP_OPTIONS_PUBLIC)))
 206     {
 207       rtsp_close (rtsp_session->s);
 208       free (server);
 209       free (mrl_line);
 210       free (rtsp_session);
 211       return NULL;
 212     }
 213
 214     /* check for minimalistic RTSP RFC compliance */
 215     if (!strstr (public, RTSP_METHOD_DESCRIBE)
 216         || !strstr (public, RTSP_METHOD_SETUP)
 217         || !strstr (public, RTSP_METHOD_PLAY)
 218         || !strstr (public, RTSP_METHOD_TEARDOWN))
 219     {
 220       mp_msg (MSGT_OPEN, MSGL_ERR,
 221               "Remote server does not meet minimal RTSP 1.0 compliance.\n");
 222       rtsp_close (rtsp_session->s);
 223       free (server);
 224       free (mrl_line);
 225       free (rtsp_session);
 226       return NULL;
 227     }
 228
 229     rtsp_session->rtp_session = rtp_setup_and_play (rtsp_session->s);
 230
 231     /* neither a Real or an RTP server */
 232     if (!rtsp_session->rtp_session)
 233     {
 234       mp_msg (MSGT_OPEN, MSGL_ERR, "rtsp_session: unsupported RTSP server. ");
 235       mp_msg (MSGT_OPEN, MSGL_ERR, "Server type is '%s'.\n", server);
 236       rtsp_close (rtsp_session->s);
 237       free (server);
 238       free (mrl_line);
 239       free (rtsp_session);
 240       return NULL;
 241     }
 242   }
 243   free(server);
 244
 245   return rtsp_session;
 246 }
 247
 248 int rtsp_session_read (rtsp_session_t *this, char *data, int len) {
 249
 250   if (this->real_session) {
 251   int to_copy=len;
 252   char *dest=data;
 253   char *source =
 254     (char *) (this->real_session->recv + this->real_session->recv_read);
 255   int fill = this->real_session->recv_size - this->real_session->recv_read;
 256
 257   if(this->real_session->rdteof)
 258     return -1;
 259   if (len < 0) return 0;
 260   if (this->real_session->recv_size < 0) return -1;
 261   while (to_copy > fill) {
 262
 263     memcpy(dest, source, fill);
 264     to_copy -= fill;
 265     dest += fill;
 266     this->real_session->recv_read = 0;
 267     this->real_session->recv_size =
 268       real_get_rdt_chunk (this->s, (char **)&(this->real_session->recv), this->real_session->rdt_rawdata);
 269     if (this->real_session->recv_size < 0) {
 270       this->real_session->rdteof = 1;
 271       this->real_session->recv_size = 0;
 272     }
 273     source = (char *) this->real_session->recv;
 274     fill = this->real_session->recv_size;
 275
 276     if (this->real_session->recv_size == 0) {
 277 #ifdef LOG
 278       mp_msg (MSGT_OPEN, MSGL_INFO, "librtsp: %d of %d bytes provided\n", len-to_copy, len);
 279 #endif
 280       return len-to_copy;
 281     }
 282   }
 283
 284   memcpy(dest, source, to_copy);
 285   this->real_session->recv_read += to_copy;
 286
 287 #ifdef LOG
 288   mp_msg (MSGT_OPEN, MSGL_INFO, "librtsp: %d bytes provided\n", len);
 289 #endif
 290
 291   return len;
 292   }
 293   else if (this->rtp_session)
 294   {
 295     int l = 0;
 296
 297     l = read_rtp_from_server (this->rtp_session->rtp_socket, data, len);
 298     /* send RTSP and RTCP keepalive  */
 299     rtcp_send_rr (this->s, this->rtp_session);
 300
 301     if (l == 0)
 302       rtsp_session_end (this);
 303
 304     return l;
 305   }
 306
 307   return 0;
 308 }
 309
 310 void rtsp_session_end(rtsp_session_t *session) {
 311
 312   rtsp_close(session->s);
 313   if (session->real_session)
 314     free_real_rtsp_session (session->real_session);
 315   if (session->rtp_session)
 316     rtp_session_free (session->rtp_session);
 317   free(session);
 318 }