/*

 * 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

 */

/**

 * @file

 * multiple format streaming server based on the FFmpeg libraries

 */

#include "config.h"

#if !HAVE_CLOSESOCKET

#define closesocket close

#endif

#include 

#include 

#include 

#include "libavformat/avformat.h"

// FIXME those are internal headers, ffserver _really_ shouldn't use them

#include "libavformat/ffm.h"

#include "libavformat/network.h"

#include "libavformat/os_support.h"

#include "libavformat/rtpdec.h"

#include "libavformat/rtpproto.h"

#include "libavformat/rtsp.h"

#include "libavformat/avio_internal.h"

#include "libavformat/internal.h"

#include "libavformat/url.h"

#include "libavutil/avassert.h"

#include "libavutil/avstring.h"

#include "libavutil/lfg.h"

#include "libavutil/dict.h"

#include "libavutil/intreadwrite.h"

#include "libavutil/mathematics.h"

#include "libavutil/pixdesc.h"

#include "libavutil/random_seed.h"

#include "libavutil/parseutils.h"

#include "libavutil/opt.h"

#include "libavutil/time.h"

#include 

#include 

#include 

#include 

#if HAVE_POLL_H

#include 

#endif

#include 

#include 

#include 

#include 

#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 MAX_STREAMS 20

#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 */

    AVIOContext *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) */

    AVDictionary *in_opts;   /* 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 *config_filename;

static int ffserver_debug;

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;

static void htmlstrip(char *s) {

    while (s && *s) {

        s += strspn(s, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,. ");

        if (*s)

            *s++ = '?';

    }

}

static int64_t ffm_read_write_index(int fd)

{

    uint8_t buf[8];

    if (lseek(fd, 8, SEEK_SET) < 0)

        return AVERROR(EIO);

    if (read(fd, buf, 8) != 8)

        return AVERROR(EIO);

    return AV_RB64(buf);

}

static int ffm_write_write_index(int fd, int64_t pos)

{

    uint8_t buf[8];

    int i;

    for(i=0;i<8;i++)

        buf[i] = (pos >> (56 - i * 8)) & 0xff;

    if (lseek(fd, 8, SEEK_SET) < 0)

        return AVERROR(EIO);

    if (write(fd, buf, 8) != 8)

        return AVERROR(EIO);

    return 8;

}

static void ffm_set_write_index(AVFormatContext *s, int64_t pos,

                                int64_t file_size)

{

    FFMContext *ffm = s->priv_data;

    ffm->write_index = pos;

    ffm->file_size = file_size;

}

/* 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 = { 0 };

        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, int buf_size)

{

    time_t ti;

    char *p;

    ti = time(NULL);

    p = ctime(&ti);

    av_strlcpy(buf2, p, buf_size);

    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, sizeof(buf));

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

        }

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

        vfprintf(logfile, fmt, vargs);

        fflush(logfile);

    }

}

#ifdef __GNUC__

__attribute__ ((format (printf, 1, 2)))

#endif

static void 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 command line: ");

                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) {

                    if (!freopen("/dev/null", "r", stdin))

                        http_log("failed to redirect STDIN to /dev/null\n;");

                    if (!freopen("/dev/null", "w", stdout))

                        http_log("failed to redirect STDOUT to /dev/null\n;");

                    if (!freopen("/dev/null", "w", stderr))

                        http_log("failed to redirect STDERR to /dev/null\n;");

                }

                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));

    my_addr->sin_family = AF_INET;

    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 = {0};

    int default_port, stream_index;

    default_port = 6000;

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

        if (stream->is_multicast) {

            unsigned random0 = av_lfg_get(&random_state);

            unsigned random1 = av_lfg_get(&random_state);

            /* open the RTP connection */

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

                     random0, random1);

            /* 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() != AVERROR(EAGAIN) &&

                ff_neterrno() != AVERROR(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++;

        }

        if (rtsp_server_fd) {

            /* new RTSP connection request ? */

            if (poll_entry->revents & POLLIN)

                new_connection(rtsp_server_fd, 1);

        }

    }

}

/* start waiting for a new HTTP/RTSP request */

static void start_wait_request(HTTPContext *c, int is_rtsp)

{

    c->buffer_ptr = c->buffer;

    c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */

    if (is_rtsp) {

        c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;

        c->state = RTSPSTATE_WAIT_REQUEST;

    } else {

        c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;

        c->state = HTTPSTATE_WAIT_REQUEST;

    }

}

static void http_send_too_busy_reply(int fd)

{

    char buffer[400];

    int len = snprintf(buffer, sizeof(buffer),

                       "HTTP/1.0 503 Server too busy\r\n"

                       "Content-type: text/html\r\n"

                       "\r\n"

                       "\r\n"

                       "
The server is too busy to serve your request at this time.
\r\n"

                       "
The number of current connections is %u, and this exceeds the limit of %u.
\r\n"

                       "\r\n",

                       nb_connections, nb_max_connections);

    av_assert0(len < sizeof(buffer));

    send(fd, buffer, len, 0);

}

static void new_connection(int server_fd, int is_rtsp)

{

    struct sockaddr_in from_addr;

    socklen_t len;

    int fd;

    HTTPContext *c = NULL;

    len = sizeof(from_addr);

    fd = accept(server_fd, (struct sockaddr *)&from_addr,

                &len);

    if (fd < 0) {

        http_log("error during accept %s\n", strerror(errno));

        return;

    }

    ff_socket_nonblock(fd, 1);

    if (nb_connections >= nb_max_connections) {

        http_send_too_busy_reply(fd);

        goto fail;

    }

    /* add a new connection */

    c = av_mallocz(sizeof(HTTPContext));

    if (!c)

        goto fail;

    c->fd = fd;

    c->poll_entry = NULL;

    c->from_addr = from_addr;

    c->buffer_size = IOBUFFER_INIT_SIZE;

    c->buffer = av_malloc(c->buffer_size);

    if (!c->buffer)

        goto fail;

    c->next = first_http_ctx;

    first_http_ctx = c;

    nb_connections++;

    start_wait_request(c, is_rtsp);

    return;

 fail:

    if (c) {

        av_free(c->buffer);

        av_free(c);

    }

    closesocket(fd);

}

static void close_connection(HTTPContext *c)

{

    HTTPContext **cp, *c1;

    int i, nb_streams;

    AVFormatContext *ctx;

    URLContext *h;

    AVStream *st;

    /* remove connection from list */

    cp = &first_http_ctx;

    while ((*cp) != NULL) {

        c1 = *cp;

        if (c1 == c)

            *cp = c->next;

        else

            cp = &c1->next;

    }

    /* remove references, if any (XXX: do it faster) */

    for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {

        if (c1->rtsp_c == c)

            c1->rtsp_c = NULL;

    }

    /* remove connection associated resources */

    if (c->fd >= 0)

        closesocket(c->fd);

    if (c->fmt_in) {

        /* close each frame parser */

        for(i=0;ifmt_in->nb_streams;i++) {

            st = c->fmt_in->streams[i];

            if (st->codec->codec)

                avcodec_close(st->codec);

        }

        avformat_close_input(&c->fmt_in);

    }

    /* free RTP output streams if any */

    nb_streams = 0;

    if (c->stream)

        nb_streams = c->stream->nb_streams;

    for(i=0;i

        ctx = c->rtp_ctx[i];

        if (ctx) {

            av_write_trailer(ctx);

            av_dict_free(&ctx->metadata);

            av_free(ctx->streams[0]);

            av_free(ctx);

        }

        h = c->rtp_handles[i];

        if (h)

            ffurl_close(h);

    }

    ctx = &c->fmt_ctx;

    if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {

        if (ctx->oformat) {

            /* prepare header */

            if (avio_open_dyn_buf(&ctx->pb) >= 0) {

                av_write_trailer(ctx);

                av_freep(&c->pb_buffer);

                avio_close_dyn_buf(ctx->pb, &c->pb_buffer);

            }

        }

    }

    for(i=0; inb_streams; i++)

        av_free(ctx->streams[i]);

    av_freep(&ctx->streams);

    av_freep(&ctx->priv_data);

    if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)

        current_bandwidth -= c->stream->bandwidth;

    /* signal that there is no feed if we are the feeder socket */

    if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {

        c->stream->feed_opened = 0;

        close(c->feed_fd);

    }

    av_freep(&c->pb_buffer);

    av_freep(&c->packet_buffer);

    av_free(c->buffer);

    av_free(c);

    nb_connections--;

}

static int handle_connection(HTTPContext *c)

{

    int len, ret;

    switch(c->state) {

    case HTTPSTATE_WAIT_REQUEST:

    case RTSPSTATE_WAIT_REQUEST:

        /* timeout ? */

        if ((c->timeout - cur_time) < 0)

            return -1;

        if (c->poll_entry->revents & (POLLERR | POLLHUP))

            return -1;

        /* no need to read if no events */

        if (!(c->poll_entry->revents & POLLIN))

            return 0;

        /* read the data */

    read_loop:

        len = recv(c->fd, c->buffer_ptr, 1, 0);

        if (len < 0) {

            if (ff_neterrno() != AVERROR(EAGAIN) &&

                ff_neterrno() != AVERROR(EINTR))

                return -1;

        } else if (len == 0) {

            return -1;

        } else {

            /* search for end of request. */

            uint8_t *ptr;

            c->buffer_ptr += len;

            ptr = c->buffer_ptr;

            if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||

                (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {

                /* request found : parse it and reply */

                if (c->state == HTTPSTATE_WAIT_REQUEST) {

                    ret = http_parse_request(c);

                } else {

                    ret = rtsp_parse_request(c);

                }

                if (ret < 0)

                    return -1;

            } else if (ptr >= c->buffer_end) {

                /* request too long: cannot do anything */

                return -1;

            } else goto read_loop;

        }

        break;

    case HTTPSTATE_SEND_HEADER:

        if (c->poll_entry->revents & (POLLERR | POLLHUP))

            return -1;

        /* no need to write if no events */

        if (!(c->poll_entry->revents & POLLOUT))

            return 0;

        len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);

        if (len < 0) {

            if (ff_neterrno() != AVERROR(EAGAIN) &&

                ff_neterrno() != AVERROR(EINTR)) {

                /* error : close connection */

                av_freep(&c->pb_buffer);

                return -1;

            }

        } else {

            c->buffer_ptr += len;

            if (c->stream)

                c->stream->bytes_served += len;

            c->data_count += len;

            if (c->buffer_ptr >= c->buffer_end) {

                av_freep(&c->pb_buffer);

                /* if error, exit */

                if (c->http_error)

                    return -1;

                /* all the buffer was sent : synchronize to the incoming stream */

                c->state = HTTPSTATE_SEND_DATA_HEADER;

                c->buffer_ptr = c->buffer_end = c->buffer;

            }

        }

        break;

    case HTTPSTATE_SEND_DATA:

    case HTTPSTATE_SEND_DATA_HEADER:

    case HTTPSTATE_SEND_DATA_TRAILER:

        /* for packetized output, we consider we can always write (the

           input streams sets the speed). It may be better to verify

           that we do not rely too much on the kernel queues */

        if (!c->is_packetized) {

            if (c->poll_entry->revents & (POLLERR | POLLHUP))

                return -1;

            /* no need to read if no events */

            if (!(c->poll_entry->revents & POLLOUT))

                return 0;

        }

        if (http_send_data(c) < 0)

            return -1;

        /* close connection if trailer sent */

        if (c->state == HTTPSTATE_SEND_DATA_TRAILER)

            return -1;

        break;

    case HTTPSTATE_RECEIVE_DATA:

        /* no need to read if no events */

        if (c->poll_entry->revents & (POLLERR | POLLHUP))

            return -1;

        if (!(c->poll_entry->revents & POLLIN))

            return 0;

        if (http_receive_data(c) < 0)

            return -1;

        break;

    case HTTPSTATE_WAIT_FEED:

        /* no need to read if no events */

        if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))

            return -1;

        /* nothing to do, we'll be waken up by incoming feed packets */

        break;

    case RTSPSTATE_SEND_REPLY:

        if (c->poll_entry->revents & (POLLERR | POLLHUP)) {

            av_freep(&c->pb_buffer);

            return -1;

        }

        /* no need to write if no events */

        if (!(c->poll_entry->revents & POLLOUT))

            return 0;

        len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);

        if (len < 0) {

            if (ff_neterrno() != AVERROR(EAGAIN) &&

                ff_neterrno() != AVERROR(EINTR)) {

                /* error : close connection */

                av_freep(&c->pb_buffer);

                return -1;

            }

        } else {

            c->buffer_ptr += len;

            c->data_count += len;

            if (c->buffer_ptr >= c->buffer_end) {

                /* all the buffer was sent : wait for a new request */

                av_freep(&c->pb_buffer);

                start_wait_request(c, 1);

            }

        }

        break;

    case RTSPSTATE_SEND_PACKET:

        if (c->poll_entry->revents & (POLLERR | POLLHUP)) {

            av_freep(&c->packet_buffer);

            return -1;

        }

        /* no need to write if no events */

        if (!(c->poll_entry->revents & POLLOUT))

            return 0;

        len = send(c->fd, c->packet_buffer_ptr,

                    c->packet_buffer_end - c->packet_buffer_ptr, 0);

        if (len < 0) {

            if (ff_neterrno() != AVERROR(EAGAIN) &&

                ff_neterrno() != AVERROR(EINTR)) {

                /* error : close connection */

                av_freep(&c->packet_buffer);

                return -1;

            }

        } else {

            c->packet_buffer_ptr += len;

            if (c->packet_buffer_ptr >= c->packet_buffer_end) {

                /* all the buffer was sent : wait for a new request */

                av_freep(&c->packet_buffer);

                c->state = RTSPSTATE_WAIT_REQUEST;

            }

        }

        break;

    case HTTPSTATE_READY:

        /* nothing to do */

        break;

    default:

        return -1;

    }

    return 0;

}