/* * Multiple format streaming server * Copyright (c) 2000, 2001, 2002 Fabrice Bellard * * This library 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 of the License, or (at your option) any later version. * * This library 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 this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */#define HAVE_AV_CONFIG_H#include "avformat.h"#include <stdarg.h>#include <unistd.h>#include <fcntl.h>#include <sys/ioctl.h>#include <sys/poll.h>#include <errno.h>#include <sys/time.h>#undef time //needed because HAVE_AV_CONFIG_H is defined on top#include <time.h>#include <sys/types.h>#include <sys/socket.h>#include <sys/wait.h>#include <netinet/in.h>#include <arpa/inet.h>#include <netdb.h>#include <signal.h>#ifdef CONFIG_HAVE_DLFCN#include <dlfcn.h>#endif#include "ffserver.h"/* maximum number of simultaneous HTTP connections */#define HTTP_MAX_CONNECTIONS 2000enum 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,};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/* coef for exponential mean for bitrate estimation in statistics */#define AVG_COEF 0.9/* timeouts are in ms */#define HTTP_REQUEST_TIMEOUT (15 * 1000)#define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)#define SYNC_TIMEOUT (10 * 1000)typedef struct {    int64_t count1, count2;    long 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 */    long timeout;    uint8_t *buffer_ptr, *buffer_end;    int http_error;    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;    long 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 RTSPProtocol 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;static AVFrame dummy_frame;/* 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;    int nb_streams;    int prebuffer;      /* Number of millseconds early to start */    long 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;    int 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 conns_served;    int64_t bytes_served;    int64_t feed_max_size;      /* maximum storage size */    int64_t feed_write_index;   /* current write position in feed (it wraps round) */    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 averraged over last frames with exponential mean */} FeedData;struct sockaddr_in my_http_addr;struct sockaddr_in my_rtsp_addr;char logfilename[1024];HTTPContext *first_http_ctx;FFStream *first_feed;   /* contains only feeds */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_stats(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, RTSPHeader *h);static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h);static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h);static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *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 RTSPProtocol 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 int ffserver_debug;static int ffserver_daemon;static int no_launch;static int need_to_start_children;int nb_max_connections;int nb_connections;int max_bandwidth;int current_bandwidth;static long cur_time;           // Making this global saves on passing it around everywherestatic long gettime_ms(void){    struct timeval tv;    gettimeofday(&tv,NULL);    return (long long)tv.tv_sec * 1000 + (tv.tv_usec / 1000);}static FILE *logfile = NULL;static void __attribute__ ((format (printf, 1, 2))) http_log(const char *fmt, ...) {    va_list ap;    va_start(ap, fmt);        if (logfile) {        vfprintf(logfile, fmt, ap);        fflush(logfile);    }    va_end(ap);}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 log_connection(HTTPContext *c){    char buf2[32];    if (c->suppress_log)         return;    http_log("%s - - [%s] \"%s %s %s\" %d %lld\n",              inet_ntoa(c->from_addr.sin_addr),              ctime1(buf2), 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 int get_longterm_datarate(DataRateData *drd, int64_t count){    /* You get the first 3 seconds flat out */    if (cur_time - drd->time1 < 3000)        return 0;    return compute_datarate(drd, count);}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) {                fprintf(stderr, "Unable to create children\n");                exit(1);            }            if (!feed->pid) {                /* In child */                char pathname[1024];                char *slash;                int i;                for (i = 3; i < 256; i++) {                    close(i);                }                if (!ffserver_debug) {                    i = open("/dev/null", O_RDWR);                    if (i)