~ubuntu-branches/ubuntu/maverick/ffmpeg/maverick-security

/*

 * Multiple format streaming server

 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#define _XOPEN_SOURCE 600

#include "config.h"

#if !HAVE_CLOSESOCKET

#define closesocket close

#endif

#include <string.h>

#include <strings.h>

#include <stdlib.h>

#include "libavformat/avformat.h"

#include "libavformat/network.h"

#include "libavformat/os_support.h"

#include "libavformat/rtpdec.h"

#include "libavformat/rtsp.h"

#include "libavutil/avstring.h"

#include "libavutil/lfg.h"

#include "libavutil/random_seed.h"

#include "libavcodec/opt.h"

#include <stdarg.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#if HAVE_POLL_H

#include <poll.h>

#endif

#include <errno.h>

#include <sys/time.h>

#include <time.h>

#include <sys/wait.h>

#include <signal.h>

#if HAVE_DLFCN_H

#include <dlfcn.h>

#endif

#include "cmdutils.h"

const char program_name[] = "FFserver";

const int program_birth_year = 2000;

static const OptionDef options[];

enum HTTPState {

    HTTPSTATE_WAIT_REQUEST,

    HTTPSTATE_SEND_HEADER,

    HTTPSTATE_SEND_DATA_HEADER,

    HTTPSTATE_SEND_DATA,          /* sending TCP or UDP data */

    HTTPSTATE_SEND_DATA_TRAILER,

    HTTPSTATE_RECEIVE_DATA,

    HTTPSTATE_WAIT_FEED,          /* wait for data from the feed */

    HTTPSTATE_READY,

    RTSPSTATE_WAIT_REQUEST,

    RTSPSTATE_SEND_REPLY,

    RTSPSTATE_SEND_PACKET,

};

static const char *http_state[] = {

    "HTTP_WAIT_REQUEST",

    "HTTP_SEND_HEADER",

    "SEND_DATA_HEADER",

    "SEND_DATA",

    "SEND_DATA_TRAILER",

    "RECEIVE_DATA",

    "WAIT_FEED",

    "READY",

    "RTSP_WAIT_REQUEST",

    "RTSP_SEND_REPLY",

    "RTSP_SEND_PACKET",

};

#define IOBUFFER_INIT_SIZE 8192

/* timeouts are in ms */

#define HTTP_REQUEST_TIMEOUT (15 * 1000)

#define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)

#define SYNC_TIMEOUT (10 * 1000)

typedef struct RTSPActionServerSetup {

    uint32_t ipaddr;

    char transport_option[512];

} RTSPActionServerSetup;

typedef struct {

    int64_t count1, count2;

    int64_t time1, time2;

} DataRateData;

/* context associated with one connection */

typedef struct HTTPContext {

    enum HTTPState state;

    int fd; /* socket file descriptor */

    struct sockaddr_in from_addr; /* origin */

    struct pollfd *poll_entry; /* used when polling */

    int64_t timeout;

    uint8_t *buffer_ptr, *buffer_end;

    int http_error;

    int post;

    int chunked_encoding;

    int chunk_size;               /* 0 if it needs to be read */

    struct HTTPContext *next;

    int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */

    int64_t data_count;

    /* feed input */

    int feed_fd;

    /* input format handling */

    AVFormatContext *fmt_in;

    int64_t start_time;            /* In milliseconds - this wraps fairly often */

    int64_t first_pts;            /* initial pts value */

    int64_t cur_pts;             /* current pts value from the stream in us */

    int64_t cur_frame_duration;  /* duration of the current frame in us */

    int cur_frame_bytes;       /* output frame size, needed to compute

                                  the time at which we send each

                                  packet */

    int pts_stream_index;        /* stream we choose as clock reference */

    int64_t cur_clock;           /* current clock reference value in us */

    /* output format handling */

    struct FFStream *stream;

    /* -1 is invalid stream */

    int feed_streams[MAX_STREAMS]; /* index of streams in the feed */

    int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */

    int switch_pending;

    AVFormatContext fmt_ctx; /* instance of FFStream for one user */

    int last_packet_sent; /* true if last data packet was sent */

    int suppress_log;

    DataRateData datarate;

    int wmp_client_id;

    char protocol[16];

    char method[16];

    char url[128];

    int buffer_size;

    uint8_t *buffer;

    int is_packetized; /* if true, the stream is packetized */

    int packet_stream_index; /* current stream for output in state machine */

    /* RTSP state specific */

    uint8_t *pb_buffer; /* XXX: use that in all the code */

    ByteIOContext *pb;

    int seq; /* RTSP sequence number */

    /* RTP state specific */

    enum RTSPLowerTransport rtp_protocol;

    char session_id[32]; /* session id */

    AVFormatContext *rtp_ctx[MAX_STREAMS];

    /* RTP/UDP specific */

    URLContext *rtp_handles[MAX_STREAMS];

    /* RTP/TCP specific */

    struct HTTPContext *rtsp_c;

    uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;

} HTTPContext;

/* each generated stream is described here */

enum StreamType {

    STREAM_TYPE_LIVE,

    STREAM_TYPE_STATUS,

    STREAM_TYPE_REDIRECT,

};

enum IPAddressAction {

    IP_ALLOW = 1,

    IP_DENY,

};

typedef struct IPAddressACL {

    struct IPAddressACL *next;

    enum IPAddressAction action;

    /* These are in host order */

    struct in_addr first;

    struct in_addr last;

} IPAddressACL;

/* description of each stream of the ffserver.conf file */

typedef struct FFStream {

    enum StreamType stream_type;

    char filename[1024];     /* stream filename */

    struct FFStream *feed;   /* feed we are using (can be null if

                                coming from file) */

    AVFormatParameters *ap_in; /* input parameters */

    AVInputFormat *ifmt;       /* if non NULL, force input format */

    AVOutputFormat *fmt;

    IPAddressACL *acl;

    char dynamic_acl[1024];

    int nb_streams;

    int prebuffer;      /* Number of millseconds early to start */

    int64_t max_time;      /* Number of milliseconds to run */

    int send_on_key;

    AVStream *streams[MAX_STREAMS];

    int feed_streams[MAX_STREAMS]; /* index of streams in the feed */

    char feed_filename[1024]; /* file name of the feed storage, or

                                 input file name for a stream */

    char author[512];

    char title[512];

    char copyright[512];

    char comment[512];

    pid_t pid;  /* Of ffmpeg process */

    time_t pid_start;  /* Of ffmpeg process */

    char **child_argv;

    struct FFStream *next;

    unsigned bandwidth; /* bandwidth, in kbits/s */

    /* RTSP options */

    char *rtsp_option;

    /* multicast specific */

    int is_multicast;

    struct in_addr multicast_ip;

    int multicast_port; /* first port used for multicast */

    int multicast_ttl;

    int loop; /* if true, send the stream in loops (only meaningful if file) */

    /* feed specific */

    int feed_opened;     /* true if someone is writing to the feed */

    int is_feed;         /* true if it is a feed */

    int readonly;        /* True if writing is prohibited to the file */

    int truncate;        /* True if feeder connection truncate the feed file */

    int conns_served;

    int64_t bytes_served;

    int64_t feed_max_size;      /* maximum storage size, zero means unlimited */

    int64_t feed_write_index;   /* current write position in feed (it wraps around) */

    int64_t feed_size;          /* current size of feed */

    struct FFStream *next_feed;

} FFStream;

typedef struct FeedData {

    long long data_count;

    float avg_frame_size;   /* frame size averaged over last frames with exponential mean */

} FeedData;

static struct sockaddr_in my_http_addr;

static struct sockaddr_in my_rtsp_addr;

static char logfilename[1024];

static HTTPContext *first_http_ctx;

static FFStream *first_feed;   /* contains only feeds */

static FFStream *first_stream; /* contains all streams, including feeds */

static void new_connection(int server_fd, int is_rtsp);

static void close_connection(HTTPContext *c);

/* HTTP handling */

static int handle_connection(HTTPContext *c);

static int http_parse_request(HTTPContext *c);

static int http_send_data(HTTPContext *c);

static void compute_status(HTTPContext *c);

static int open_input_stream(HTTPContext *c, const char *info);

static int http_start_receive_data(HTTPContext *c);

static int http_receive_data(HTTPContext *c);

/* RTSP handling */

static int rtsp_parse_request(HTTPContext *c);

static void rtsp_cmd_describe(HTTPContext *c, const char *url);

static void rtsp_cmd_options(HTTPContext *c, const char *url);

static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);

static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);

static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);

static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);

/* SDP handling */

static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,

                                   struct in_addr my_ip);

/* RTP handling */

static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,

                                       FFStream *stream, const char *session_id,

                                       enum RTSPLowerTransport rtp_protocol);

static int rtp_new_av_stream(HTTPContext *c,

                             int stream_index, struct sockaddr_in *dest_addr,

                             HTTPContext *rtsp_c);

static const char *my_program_name;

static const char *my_program_dir;

static const char *config_filename = "/etc/ffserver.conf";

static int ffserver_debug;

static int ffserver_daemon;

static int no_launch;

static int need_to_start_children;

/* maximum number of simultaneous HTTP connections */

static unsigned int nb_max_http_connections = 2000;

static unsigned int nb_max_connections = 5;

static unsigned int nb_connections;

static uint64_t max_bandwidth = 1000;

static uint64_t current_bandwidth;

static int64_t cur_time;           // Making this global saves on passing it around everywhere

static AVLFG random_state;

static FILE *logfile = NULL;

/* FIXME: make ffserver work with IPv6 */

/* resolve host with also IP address parsing */

static int resolve_host(struct in_addr *sin_addr, const char *hostname)

{

    if (!ff_inet_aton(hostname, sin_addr)) {

#if HAVE_GETADDRINFO

        struct addrinfo *ai, *cur;

        struct addrinfo hints;

        memset(&hints, 0, sizeof(hints));

        hints.ai_family = AF_INET;

        if (getaddrinfo(hostname, NULL, &hints, &ai))

            return -1;

        /* getaddrinfo returns a linked list of addrinfo structs.

         * Even if we set ai_family = AF_INET above, make sure

         * that the returned one actually is of the correct type. */

        for (cur = ai; cur; cur = cur->ai_next) {

            if (cur->ai_family == AF_INET) {

                *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;

                freeaddrinfo(ai);

                return 0;

            }

        }

        freeaddrinfo(ai);

        return -1;

#else

        struct hostent *hp;

        hp = gethostbyname(hostname);

        if (!hp)

            return -1;

        memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));

#endif

    }

    return 0;

}

static char *ctime1(char *buf2)

{

    time_t ti;

    char *p;

    ti = time(NULL);

    p = ctime(&ti);

    strcpy(buf2, p);

    p = buf2 + strlen(p) - 1;

    if (*p == '\n')

        *p = '\0';

    return buf2;

}

static void http_vlog(const char *fmt, va_list vargs)

{

    static int print_prefix = 1;

    if (logfile) {

        if (print_prefix) {

            char buf[32];

            ctime1(buf);

            fprintf(logfile, "%s ", buf);

        }

        print_prefix = strstr(fmt, "\n") != NULL;

        vfprintf(logfile, fmt, vargs);

        fflush(logfile);

    }

}

static void __attribute__ ((format (printf, 1, 2))) http_log(const char *fmt, ...)

{

    va_list vargs;

    va_start(vargs, fmt);

    http_vlog(fmt, vargs);

    va_end(vargs);

}

static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)

{

    static int print_prefix = 1;

    AVClass *avc = ptr ? *(AVClass**)ptr : NULL;

    if (level > av_log_get_level())

        return;

    if (print_prefix && avc)

        http_log("[%s @ %p]", avc->item_name(ptr), ptr);

    print_prefix = strstr(fmt, "\n") != NULL;

    http_vlog(fmt, vargs);

}

static void log_connection(HTTPContext *c)

{

    if (c->suppress_log)

        return;

    http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",

             inet_ntoa(c->from_addr.sin_addr), c->method, c->url,

             c->protocol, (c->http_error ? c->http_error : 200), c->data_count);

}

static void update_datarate(DataRateData *drd, int64_t count)

{

    if (!drd->time1 && !drd->count1) {

        drd->time1 = drd->time2 = cur_time;

        drd->count1 = drd->count2 = count;

    } else if (cur_time - drd->time2 > 5000) {

        drd->time1 = drd->time2;

        drd->count1 = drd->count2;

        drd->time2 = cur_time;

        drd->count2 = count;

    }

}

/* In bytes per second */

static int compute_datarate(DataRateData *drd, int64_t count)

{

    if (cur_time == drd->time1)

        return 0;

    return ((count - drd->count1) * 1000) / (cur_time - drd->time1);

}

static void start_children(FFStream *feed)

{

    if (no_launch)

        return;

    for (; feed; feed = feed->next) {

        if (feed->child_argv && !feed->pid) {

            feed->pid_start = time(0);

            feed->pid = fork();

            if (feed->pid < 0) {

                http_log("Unable to create children\n");

                exit(1);

            }

            if (!feed->pid) {

                /* In child */

                char pathname[1024];

                char *slash;

                int i;

                av_strlcpy(pathname, my_program_name, sizeof(pathname));

                slash = strrchr(pathname, '/');

                if (!slash)

                    slash = pathname;

                else

                    slash++;

                strcpy(slash, "ffmpeg");

                http_log("Launch commandline: ");

                http_log("%s ", pathname);

                for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)

                    http_log("%s ", feed->child_argv[i]);

                http_log("\n");

                for (i = 3; i < 256; i++)

                    close(i);

                if (!ffserver_debug) {

                    i = open("/dev/null", O_RDWR);

                    if (i != -1) {

                        dup2(i, 0);

                        dup2(i, 1);

                        dup2(i, 2);

                        close(i);

                    }

                }

                /* This is needed to make relative pathnames work */

                chdir(my_program_dir);

                signal(SIGPIPE, SIG_DFL);

                execvp(pathname, feed->child_argv);

                _exit(1);

            }

        }

    }

}

/* open a listening socket */

static int socket_open_listen(struct sockaddr_in *my_addr)

{

    int server_fd, tmp;

    server_fd = socket(AF_INET,SOCK_STREAM,0);

    if (server_fd < 0) {

        perror ("socket");

        return -1;

    }

    tmp = 1;

    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));

    if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {

        char bindmsg[32];

        snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));

        perror (bindmsg);

        closesocket(server_fd);

        return -1;

    }

    if (listen (server_fd, 5) < 0) {

        perror ("listen");

        closesocket(server_fd);

        return -1;

    }

    ff_socket_nonblock(server_fd, 1);

    return server_fd;

}

/* start all multicast streams */

static void start_multicast(void)

{

    FFStream *stream;

    char session_id[32];

    HTTPContext *rtp_c;

    struct sockaddr_in dest_addr;

    int default_port, stream_index;

    default_port = 6000;

    for(stream = first_stream; stream != NULL; stream = stream->next) {

        if (stream->is_multicast) {

            /* open the RTP connection */

            snprintf(session_id, sizeof(session_id), "%08x%08x",

                     av_lfg_get(&random_state), av_lfg_get(&random_state));

            /* choose a port if none given */

            if (stream->multicast_port == 0) {

                stream->multicast_port = default_port;

                default_port += 100;

            }

            dest_addr.sin_family = AF_INET;

            dest_addr.sin_addr = stream->multicast_ip;

            dest_addr.sin_port = htons(stream->multicast_port);

            rtp_c = rtp_new_connection(&dest_addr, stream, session_id,

                                       RTSP_LOWER_TRANSPORT_UDP_MULTICAST);

            if (!rtp_c)

                continue;

            if (open_input_stream(rtp_c, "") < 0) {

                http_log("Could not open input stream for stream '%s'\n",

                         stream->filename);

                continue;

            }

            /* open each RTP stream */

            for(stream_index = 0; stream_index < stream->nb_streams;

                stream_index++) {

                dest_addr.sin_port = htons(stream->multicast_port +

                                           2 * stream_index);

                if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {

                    http_log("Could not open output stream '%s/streamid=%d'\n",

                             stream->filename, stream_index);

                    exit(1);

                }

            }

            /* change state to send data */

            rtp_c->state = HTTPSTATE_SEND_DATA;

        }

    }

}

/* main loop of the http server */

static int http_server(void)

{

    int server_fd = 0, rtsp_server_fd = 0;

    int ret, delay, delay1;

    struct pollfd *poll_table, *poll_entry;

    HTTPContext *c, *c_next;

    if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {

        http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);

        return -1;

    }

    if (my_http_addr.sin_port) {

        server_fd = socket_open_listen(&my_http_addr);

        if (server_fd < 0)

            return -1;

    }

    if (my_rtsp_addr.sin_port) {

        rtsp_server_fd = socket_open_listen(&my_rtsp_addr);

        if (rtsp_server_fd < 0)

            return -1;

    }

    if (!rtsp_server_fd && !server_fd) {

        http_log("HTTP and RTSP disabled.\n");

        return -1;

    }

    http_log("FFserver started.\n");

    start_children(first_feed);

    start_multicast();

    for(;;) {

        poll_entry = poll_table;

        if (server_fd) {

            poll_entry->fd = server_fd;

            poll_entry->events = POLLIN;

            poll_entry++;

        }

        if (rtsp_server_fd) {

            poll_entry->fd = rtsp_server_fd;

            poll_entry->events = POLLIN;

            poll_entry++;

        }

        /* wait for events on each HTTP handle */

        c = first_http_ctx;

        delay = 1000;

        while (c != NULL) {

            int fd;

            fd = c->fd;

            switch(c->state) {

            case HTTPSTATE_SEND_HEADER:

            case RTSPSTATE_SEND_REPLY:

            case RTSPSTATE_SEND_PACKET:

                c->poll_entry = poll_entry;

                poll_entry->fd = fd;

                poll_entry->events = POLLOUT;

                poll_entry++;

                break;

            case HTTPSTATE_SEND_DATA_HEADER:

            case HTTPSTATE_SEND_DATA:

            case HTTPSTATE_SEND_DATA_TRAILER:

                if (!c->is_packetized) {

                    /* for TCP, we output as much as we can (may need to put a limit) */

                    c->poll_entry = poll_entry;

                    poll_entry->fd = fd;

                    poll_entry->events = POLLOUT;

                    poll_entry++;

                } else {

                    /* when ffserver is doing the timing, we work by

                       looking at which packet need to be sent every

                       10 ms */

                    delay1 = 10; /* one tick wait XXX: 10 ms assumed */

                    if (delay1 < delay)

                        delay = delay1;

                }

                break;

            case HTTPSTATE_WAIT_REQUEST:

            case HTTPSTATE_RECEIVE_DATA:

            case HTTPSTATE_WAIT_FEED:

            case RTSPSTATE_WAIT_REQUEST:

                /* need to catch errors */

                c->poll_entry = poll_entry;

                poll_entry->fd = fd;

                poll_entry->events = POLLIN;/* Maybe this will work */

                poll_entry++;

                break;

            default:

                c->poll_entry = NULL;

                break;

            }

            c = c->next;

        }

        /* wait for an event on one connection. We poll at least every

           second to handle timeouts */

        do {

            ret = poll(poll_table, poll_entry - poll_table, delay);

            if (ret < 0 && ff_neterrno() != FF_NETERROR(EAGAIN) &&

                ff_neterrno() != FF_NETERROR(EINTR))

                return -1;

        } while (ret < 0);

        cur_time = av_gettime() / 1000;

        if (need_to_start_children) {

            need_to_start_children = 0;

            start_children(first_feed);

        }

        /* now handle the events */

        for(c = first_http_ctx; c != NULL; c = c_next) {

            c_next = c->next;

            if (handle_connection(c) < 0) {

                /* close and free the connection */

                log_connection(c);

                close_connection(c);

            }

        }

        poll_entry = poll_table;

        if (server_fd) {

            /* new HTTP connection request ? */

            if (poll_entry->revents & POLLIN)

                new_connection(server_fd, 0);

            poll_entry++;

        }