apps/streamer/rtsp.c

Go to the documentation of this file.

/*
 * (C)2004 Alexander Melichenko <alexlp@freemail.ru>
 *
 * This file consist a portion of code from Spook Live Video Streamer
 * The Spook webpage at <http://www.litech.org/spook/> where updated releases
 * and documentation may be found.
 *
 * Copyright (C) 2004 Nathan Lutchansky <lutchann@litech.org>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "event.h"
#include "str.h"
#include "rtp.h"
#include "rtsp.h"

#undef  DEBUG

struct param *_param;

struct session {
        struct session *next;
        struct session *prev;
        char id[32];
};

/*
 * Connection states:
 *   CONN_STATE_START: just accepted the connection, protocol is yet unknown
 *   CONN_STATE_RTSP: might get an RTSP request or an interleaved RTP packet
 *   CONN_STATE_RTSP_REQ: definitely getting an RTSP request
 *   CONN_STATE_INTERLEAVED: definitely getting an interleaved RTP packet
 *   CONN_STATE_HTTP: definitely getting an HTTP request
 */

#define CONN_STATE_START        0
#define CONN_STATE_RTSP         1
#define CONN_STATE_RTSP_REQ     2
#define CONN_STATE_INTERLEAVED  3
#define CONN_STATE_HTTP         10

struct conn {
        struct conn *next;
        struct conn *prev;
        int fd;
        struct sockaddr_in client_addr;
        struct event *read_event;
        struct event *write_event;
        int state;
        char req_buf[4096];
        int req_len;
        struct { char *name; char *value; } req_hdr[16];
        unsigned char send_buf[65536];
        int send_buf_r;
        int send_buf_w;
        int drop_after;
        int close_flag;
        struct session *attached_session;
};

struct listener {
        int fd;
};

struct conn *conn_list = NULL;
struct session *sess_list = NULL;

static void do_read( struct event *e, void *d );

static void del_session( struct session *sess )
{
        if( sess->next ) sess->next->prev = sess->prev;
        if( sess->prev ) sess->prev->next = sess->next;
        else sess_list = sess->next;
        free( sess );
}

static struct session *new_session( void )
{
        struct session *sess;
        int len;

        sess = (struct session *)malloc( sizeof( struct session ) );
        sess->next = sess_list;
        sess->prev = NULL;
        if( sess->next ) sess->next->prev = sess;
        sess_list = sess;

        for( len = 0; len < 15; ++len )
                sprintf( sess->id + len * 2, "%02X",
                                (unsigned int)( random() & 0xff ) );
        sess->id[30] = 0;
        return sess;
}

static struct session *get_session( char *id )
{
        struct session *s;

        for( s = sess_list; s; s = s->next )
                if( ! strcmp( s->id, id ) ) break;
        return s;
}

static void close_session( struct session *s )
{
        del_session( s );
}

static void drop_conn(struct conn *c) {
        if(c->attached_session)
                close_session(c->attached_session);
        remove_event(c->read_event);
        remove_event(c->write_event);
        if(c->fd >= 0)
                close(c->fd);
        c->fd = -1;
        if(c->next)
                c->next->prev = c->prev;
        if(c->prev)
                c->prev->next = c->next;
        else
                conn_list = c->next;
        free(c);
}

static void conn_write( struct event *e, void *d )
{
        struct conn *c = (struct conn *)d;
        int ret, len;

        while( c->send_buf_r != c->send_buf_w )
        {
                if( c->send_buf_w < c->send_buf_r )
                        len = sizeof( c->send_buf ) - c->send_buf_r;
                else
                        len = c->send_buf_w - c->send_buf_r;
                ret = write( c->fd, c->send_buf + c->send_buf_r, len );
                if( ret <= 0 )
                {
                        if( ret < 0 && errno == EAGAIN ) return;
                        drop_conn( c );
                        return;
                }
                c->send_buf_r += ret;
                if( c->send_buf_r == sizeof( c->send_buf ) )
                        c->send_buf_r = 0;
        }
        if( c->drop_after ) drop_conn( c );
        else set_event_enabled( c->write_event, 0 );
}

static inline int avail_send_buf( struct conn *c )
{
        if( c->send_buf_r > c->send_buf_w )
                return c->send_buf_r - c->send_buf_w - 1;
        else return sizeof( c->send_buf ) - c->send_buf_w + c->send_buf_r - 1;
}

static int send_data( struct conn *c, unsigned char *d, int len )
{
        if( avail_send_buf( c ) < len ) return 1;

        while( --len >= 0 )
        {
                c->send_buf[c->send_buf_w++] = *(d++);
                if( c->send_buf_w == sizeof( c->send_buf ) )
                        c->send_buf_w = 0;
        }

        set_event_enabled( c->write_event, 1 );

        return 0;
}


static char *get_header( struct conn *c, char *name )
{
        int i;
        static char *empty = "";

        for( i = 0; c->req_hdr[i].name; ++i )
                if( ! strcasecmp( c->req_hdr[i].name, name ) )
                        return c->req_hdr[i].value;
        return empty;
}

static int handle_OPTIONS( struct conn *c )
{
        unsigned char rep[8192];

        send_data( c, rep, sprintf( rep, "RTSP/1.0 200 OK\r\nCSeq: %s\r\nPublic: DESCRIBE, SETUP, TEARDOWN, PLAY\r\n\r\n", get_header( c, "CSeq" ) ) );
        return 0;
}

static int handle_DESCRIBE( struct conn *c )
{
        char rep[8192], sdp[8192];
        int rep_len;
        
        if((_param->rtsp_use_cmd_addr && !ismulticast(_param) && str_count) ||
             (!_param->rtsp_use_cmd_addr && str_count)){
            c->close_flag = 1; 
            send_data( c, rep, sprintf( rep, "RTSP/1.0 455 Server is busy\r\nCSeq: %s\r\n\r\n", get_header( c, "CSeq" ) ) );
            return 0;
        }

        write_sdp(_param, 0, sdp);
        rep_len = sprintf( rep,
            "RTSP/1.0 200 OK\r\nCSeq: %s\r\n"
            "Content-Type: application/sdp\r\nContent-Length: %d\r\n\r\n", 
                    get_header( c, "CSeq" ), strlen(sdp));
#ifdef DEBUG
        fprintf(stderr, "DESCRIBE reply:\n%s", rep);
        fprintf(stderr,  "%s", sdp);
#endif
        send_data( c, rep, rep_len );
        send_data( c, sdp, strlen(sdp) );
        return 0;
}

static int rtsp_udp_setup( struct conn *c, char *t )
{
        char *p, *end;
        int cport;
        struct session *s;
        unsigned char rep[8192];
        char mode_u[] = "unicast", mode_m[] = "multicast", *mode;
        
        memset(rep, 0, 8192);

        if( ! ( p = strstr( t, "client_port" ) ) || *(p + 11) != '=' )
                return -1;
        cport = strtol( p + 12, &end, 10 );
        if( end == p + 12 ) return -1;

fprintf(stderr, "t == |%s|\r\n", t);

#ifdef DEBUG
        fprintf(stderr, "client port is %d\n", cport);
#endif
        s = new_session();

        if((mode = strstr( t, "multicast" ))){
            mode = mode_m;
        } else {
            mode = mode_u;
        }
        
        if(!_param->rtsp_use_cmd_port){
            if(str_count<1){
                _param->dport  = cport;
            }
        }
        
        if(!_param->rtsp_use_cmd_addr){
            if(str_count<1){
                _param->dst = strdup(inet_ntoa(c->client_addr.sin_addr));
            }
        }

        if(!str_count++) str_setup = 1;
        usleep(10);

        c->attached_session = s;
        sprintf( rep,   "RTSP/1.0 200 OK\r\nCSeq: %s\r\n"
                        "Session: %s\r\nTransport: RTP/AVP;"
                        "%s;destination=%s;port=%d\r\n\r\n", 
                            get_header( c, "CSeq" ), s->id, mode, _param->dst,  cport);
#ifdef DEBUG    
        fprintf(stderr, "SETUP reply:\n%s", rep);
#endif
        send_data( c, rep, strlen(rep) );
        
        return 0;
}

static int handle_SETUP( struct conn *c )
{
        char *t;
        unsigned char rep[8192];

        memset(rep, 0, 8192);

        t = get_header( c, "Transport" );

        if( ( ! strncasecmp( t, "RTP/AVP", 7 ) && t[7] != '/' ) ||
                        ! strncasecmp( t, "RTP/AVP/UDP", 11 ) )
        {
                if( rtsp_udp_setup( c, t ) == 0 ) return 0;
        }

        send_data( c, rep, sprintf( rep, "RTSP/1.0 461 Unsupported Transport\r\nCSeq: %s\r\n\r\n", get_header( c, "CSeq" ) ) );

        return 0;
}

static int handle_PLAY( struct conn *c )
{
        struct session *s;
        unsigned char rep[8192];

        memset(rep, 0, 8192);

        if( ! ( s = get_session( get_header( c, "Session" ) ) ) )
        {
                send_data( c, rep, sprintf( rep, "RTSP/1.0 454 Session Not Found\r\nCSeq: %s\r\n\r\n", get_header( c, "CSeq" ) ) );
                return 0;
        }
        
        
        sprintf( rep,   "RTSP/1.0 200 OK\r\nCSeq: %s\r\nSession: %s"
                        "\r\n\r\n", 
                            get_header( c, "CSeq" ), s->id );
#ifdef DEBUG
        fprintf(stderr,  "PLAY reply:\n%s", rep);
#endif
        send_data( c, rep, strlen(rep) );
        str_play = 1;

        return 0;
}

static int handle_PAUSE( struct conn *c )
{
        struct session *s;
        unsigned char rep[8192];

        memset(rep, 0, 8192);

        if( ! ( s = get_session( get_header( c, "Session" ) ) ) )
        {
                send_data( c, rep, sprintf( rep, "RTSP/1.0 454 Session Not Found\r\nCSeq: %s\r\n\r\n", get_header( c, "CSeq" ) ) );
                return 0;
        }
        
        
        sprintf( rep,   "RTSP/1.0 200 OK\r\nCSeq: %s\r\nSession: %s"
                        "\r\n\r\n", 
                            get_header( c, "CSeq" ), s->id );
#ifdef DEBUG
        fprintf(stderr,  "PAUSE reply:\n%s", rep);
#endif
        send_data( c, rep, strlen(rep) );
        if(str_count<2){
            if(!_param->rtsp_qt_compat){
                str_play = 0;
            }
        }

        return 0;
}


static int handle_TEARDOWN( struct conn *c )
{
        struct session *s;
        unsigned char rep[8192];

        if( ! ( s = get_session( get_header( c, "Session" ) ) ) )
        {
                send_data( c, rep, sprintf( rep, "RTSP/1.0 454 Session Not Found\r\nCSeq: %s\r\n\r\n", get_header( c, "CSeq" ) ) );
                return 0;
        }
        send_data( c, rep, sprintf( rep, "RTSP/1.0 200 OK\r\nCSeq: %s\r\nSession: %s\r\n\r\n", get_header( c, "CSeq" ), s->id ) );
        if( c->attached_session == s ) c->attached_session = NULL;
        close_session( s );

        if(--str_count<=0){
            str_count = 0;
            if(!_param->rtsp_qt_compat){
                str_teardown = 1;
            }
        }
        c->close_flag = 1;
        return 0;
}

static int handle_unknown( struct conn *c )
{
        unsigned char rep[8192];

        send_data( c, rep, sprintf( rep, "RTSP/1.0 501 Not Implemented\r\nCSeq: %s\r\n\r\n", get_header( c, "CSeq" ) ) );
        return 0;
}

static int handle_request( struct conn *c )
{
        char *t;
        int i = 0;

        if( c->req_buf[0] == 0 ) return -1;

#ifdef DEBUG
        fprintf(stderr, "Request:\n%s\n", c->req_buf);
#endif

        /* Terminate the first line of the request */
        for( t = c->req_buf; *t != '\r' && *t != '\n'; ++t )
                if( *t == 0 ) return -1;
        *(t++) = 0;
        if( *t == '\n' ) *(t++) = 0;
        /* Find the name and content of each header line */
        for( i = 0; i < 15; ++i )
        {
                /* We should be sitting on the header name */
                c->req_hdr[i].name = t;
                /* Terminate where the colon is */
                for( ; *t != ':'; ++t )
                        if( *t == 0 || *t == '\r' || *t == '\n' ) return -1;
                *(t++) = 0;
                /* Skip any spaces after the colon */
                for( ; *t == ' '; ++t )
                        if( *t == 0 ) return -1;
                /* Should be the start of the header content */
                c->req_hdr[i].value = t;
                for( ; *t != '\r' && *t != '\n'; ++t )
                        if( *t == 0 ) return -1;
                /* Terminate the content string */
                *(t++) = 0;
                if( *t == '\n' ) *(t++) = 0;
                /* Are we at the end of the header? */
                if( *t == 0 || *t == '\r' || *t == '\n' ) break;
        }
        if( i == 15 ) return -1; /* Too many headers */
        c->req_hdr[i + 1].name = NULL;

#if 0
        for( i = 0; i < 16 && c->req_hdr[i].name; ++i )
        {
                printf( "Header name = %s\n", c->req_hdr[i].name );
                printf( "Header value = %s\n", c->req_hdr[i].value );
        }
#endif

        if( ! strncasecmp( c->req_buf, "OPTIONS ", 8 ) )
                return handle_OPTIONS( c );
        else if( ! strncasecmp( c->req_buf, "DESCRIBE ", 9 ) )
                return handle_DESCRIBE( c );
        else if( ! strncasecmp( c->req_buf, "SETUP ", 6 ) )
                return handle_SETUP( c );
        else if( ! strncasecmp( c->req_buf, "PLAY ", 5 ) )
                return handle_PLAY( c );
        else if( ! strncasecmp( c->req_buf, "PAUSE ", 6 ) )
                return handle_PAUSE( c );
        else if( ! strncasecmp( c->req_buf, "TEARDOWN ", 9 ) )
                return handle_TEARDOWN( c );
        else return handle_unknown( c );
}

static int parse_client_data( struct conn *c )
{
        char *t;

        switch( c->state )
        {
        case CONN_STATE_START:
                if( strchr( c->req_buf, '\n' ) )
                {
                    c->state = CONN_STATE_RTSP;
                    return 1;
                }
                break;
        case CONN_STATE_RTSP:
                if( c->req_len < 4 ) return 0;
                c->state = CONN_STATE_RTSP_REQ;
                return 1;
        case CONN_STATE_RTSP_REQ:
                if( ! ( t = strstr( c->req_buf, "\r\n\r\n" ) ) ) return 0;
                t[2] = 0;
                if( handle_request( c ) < 0 ) return -1;
                /* should really just delete the request from the
                 * buffer, not the entire buffer */
                c->req_len = 0;
                if( c->state == CONN_STATE_RTSP_REQ )
                        c->state = CONN_STATE_RTSP;
                break;
        }
        return 0;
}

static void do_read( struct event *e, void *d )
{
        struct conn *c = (struct conn *)d;
        int ret;

        for(;;)
        {
                ret = read( c->fd,
                                c->req_buf + c->req_len,
                                sizeof( c->req_buf ) - c->req_len - 1 );
                if( ret <= 0 )
                {
                        if( ret < 0 )
                        {
                                if( errno == EAGAIN ) return;
                                fprintf( stderr, "read error%s: %s\n",
                                        "",
                                        strerror( errno ) );
                        } else{
#ifdef DEBUG
                            fprintf( stderr, "connection closed\n" );
#endif
                        }

                        if(!c->close_flag){
                            str_count--;
                        }
                        if(str_count<=0){
                            str_count = 0;
                            if(!_param->rtsp_qt_compat){
                                str_teardown = 1;
                            }
                        }
                        drop_conn( c );
                        return;
                }

                c->req_len += ret;

                if( c->req_len == sizeof( c->req_buf ) - 1 )
                {
                        fprintf( stderr, "malformed request from client\n" );
                        drop_conn( c );
                        return;
                }

                c->req_buf[c->req_len] = 0;
                while( ( ret = parse_client_data( c ) ) > 0 );
                if( ret < 0 ) return;
        }
}

static void do_accept(struct event *e, void *d) {
        struct listener *listener = (struct listener *)d;
        int fd;
        socklen_t addrlen;
        struct sockaddr_in addr;
        struct conn *c;

        addrlen = sizeof(addr);
        if((fd = accept( listener->fd, (struct sockaddr *)&addr, &addrlen)) < 0) {
                perror("accept");
                exit(1);
        }

#ifdef DEBUG    
        fprintf(stderr, "accepted connection\n");
#endif

        fcntl(fd, F_SETFL, O_NONBLOCK);

        c = (struct conn *)malloc(sizeof(struct conn));
        c->next = conn_list;
        if(c->next)
                c->next->prev = c;
        c->prev = NULL;
        c->fd = fd;
        c->client_addr = addr;
        c->state = CONN_STATE_START;
        c->req_len = 0;
        c->read_event = add_fd_event(fd, 0, 0, do_read, c);
        c->write_event = add_fd_event(fd, 1, 0, conn_write, c);
        set_event_enabled(c->write_event, 0);
        c->send_buf_r = c->send_buf_w = 0;
        c->drop_after = 0;
        c->attached_session = NULL;
        conn_list = c;
        c->close_flag = 0;
}



int rtsp_listen(struct param *p) {
        int port;
        struct sockaddr_in addr;
        struct listener *listener;
        int opt, fd;
        
        _param = p;
        port = p->rtsp_port;

        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = 0;
        addr.sin_port = htons(port);

        if((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
                perror("socket");
                return -1;
        }
        opt = 1;
        if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
                perror("setsockopt");
        if(bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
                perror("bind");
                close(fd);
                return -1;
        }
        if(listen(fd, 5) < 0) {
                perror("listen");
                close(fd);
                return -1;
        }

        listener = (struct listener *)malloc(sizeof(struct listener));
        listener->fd = fd;

        add_fd_event(fd, 0, 0, do_accept, listener);
#ifdef DEBUG
        fprintf(stderr, "listening on port %d\n", port);
#endif
        return 0;
}

---