git.sesse.net Git - ffmpeg/blob - ffserver.c

   1 /*
   2  * Multiple format streaming server
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #define _XOPEN_SOURCE 600
  23
  24 #include "config.h"
  25 #if !HAVE_CLOSESOCKET
  26 #define closesocket close
  27 #endif
  28 #include <string.h>
  29 #include <strings.h>
  30 #include <stdlib.h>
  31 #include "libavformat/avformat.h"
  32 #include "libavformat/ffm.h"
  33 #include "libavformat/network.h"
  34 #include "libavformat/os_support.h"
  35 #include "libavformat/rtpdec.h"
  36 #include "libavformat/rtsp.h"
  37 // XXX for ffio_open_dyn_packet_buffer, to be removed
  38 #include "libavformat/avio_internal.h"
  39 #include "libavutil/avstring.h"
  40 #include "libavutil/lfg.h"
  41 #include "libavutil/random_seed.h"
  42 #include "libavutil/parseutils.h"
  43 #include "libavutil/opt.h"
  44 #include <stdarg.h>
  45 #include <unistd.h>
  46 #include <fcntl.h>
  47 #include <sys/ioctl.h>
  48 #if HAVE_POLL_H
  49 #include <poll.h>
  50 #endif
  51 #include <errno.h>
  52 #include <sys/time.h>
  53 #include <time.h>
  54 #include <sys/wait.h>
  55 #include <signal.h>
  56 #if HAVE_DLFCN_H
  57 #include <dlfcn.h>
  58 #endif
  59
  60 #include "cmdutils.h"
  61
  62 const char program_name[] = "ffserver";
  63 const int program_birth_year = 2000;
  64
  65 static const OptionDef options[];
  66
  67 enum HTTPState {
  68     HTTPSTATE_WAIT_REQUEST,
  69     HTTPSTATE_SEND_HEADER,
  70     HTTPSTATE_SEND_DATA_HEADER,
  71     HTTPSTATE_SEND_DATA,          /* sending TCP or UDP data */
  72     HTTPSTATE_SEND_DATA_TRAILER,
  73     HTTPSTATE_RECEIVE_DATA,
  74     HTTPSTATE_WAIT_FEED,          /* wait for data from the feed */
  75     HTTPSTATE_READY,
  76
  77     RTSPSTATE_WAIT_REQUEST,
  78     RTSPSTATE_SEND_REPLY,
  79     RTSPSTATE_SEND_PACKET,
  80 };
  81
  82 static const char *http_state[] = {
  83     "HTTP_WAIT_REQUEST",
  84     "HTTP_SEND_HEADER",
  85
  86     "SEND_DATA_HEADER",
  87     "SEND_DATA",
  88     "SEND_DATA_TRAILER",
  89     "RECEIVE_DATA",
  90     "WAIT_FEED",
  91     "READY",
  92
  93     "RTSP_WAIT_REQUEST",
  94     "RTSP_SEND_REPLY",
  95     "RTSP_SEND_PACKET",
  96 };
  97
  98 #define MAX_STREAMS 20
  99
 100 #define IOBUFFER_INIT_SIZE 8192
 101
 102 /* timeouts are in ms */
 103 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
 104 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
 105
 106 #define SYNC_TIMEOUT (10 * 1000)
 107
 108 typedef struct RTSPActionServerSetup {
 109     uint32_t ipaddr;
 110     char transport_option[512];
 111 } RTSPActionServerSetup;
 112
 113 typedef struct {
 114     int64_t count1, count2;
 115     int64_t time1, time2;
 116 } DataRateData;
 117
 118 /* context associated with one connection */
 119 typedef struct HTTPContext {
 120     enum HTTPState state;
 121     int fd; /* socket file descriptor */
 122     struct sockaddr_in from_addr; /* origin */
 123     struct pollfd *poll_entry; /* used when polling */
 124     int64_t timeout;
 125     uint8_t *buffer_ptr, *buffer_end;
 126     int http_error;
 127     int post;
 128     int chunked_encoding;
 129     int chunk_size;               /* 0 if it needs to be read */
 130     struct HTTPContext *next;
 131     int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
 132     int64_t data_count;
 133     /* feed input */
 134     int feed_fd;
 135     /* input format handling */
 136     AVFormatContext *fmt_in;
 137     int64_t start_time;            /* In milliseconds - this wraps fairly often */
 138     int64_t first_pts;            /* initial pts value */
 139     int64_t cur_pts;             /* current pts value from the stream in us */
 140     int64_t cur_frame_duration;  /* duration of the current frame in us */
 141     int cur_frame_bytes;       /* output frame size, needed to compute
 142                                   the time at which we send each
 143                                   packet */
 144     int pts_stream_index;        /* stream we choose as clock reference */
 145     int64_t cur_clock;           /* current clock reference value in us */
 146     /* output format handling */
 147     struct FFStream *stream;
 148     /* -1 is invalid stream */
 149     int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
 150     int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
 151     int switch_pending;
 152     AVFormatContext fmt_ctx; /* instance of FFStream for one user */
 153     int last_packet_sent; /* true if last data packet was sent */
 154     int suppress_log;
 155     DataRateData datarate;
 156     int wmp_client_id;
 157     char protocol[16];
 158     char method[16];
 159     char url[128];
 160     int buffer_size;
 161     uint8_t *buffer;
 162     int is_packetized; /* if true, the stream is packetized */
 163     int packet_stream_index; /* current stream for output in state machine */
 164
 165     /* RTSP state specific */
 166     uint8_t *pb_buffer; /* XXX: use that in all the code */
 167     AVIOContext *pb;
 168     int seq; /* RTSP sequence number */
 169
 170     /* RTP state specific */
 171     enum RTSPLowerTransport rtp_protocol;
 172     char session_id[32]; /* session id */
 173     AVFormatContext *rtp_ctx[MAX_STREAMS];
 174
 175     /* RTP/UDP specific */
 176     URLContext *rtp_handles[MAX_STREAMS];
 177
 178     /* RTP/TCP specific */
 179     struct HTTPContext *rtsp_c;
 180     uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
 181 } HTTPContext;
 182
 183 /* each generated stream is described here */
 184 enum StreamType {
 185     STREAM_TYPE_LIVE,
 186     STREAM_TYPE_STATUS,
 187     STREAM_TYPE_REDIRECT,
 188 };
 189
 190 enum IPAddressAction {
 191     IP_ALLOW = 1,
 192     IP_DENY,
 193 };
 194
 195 typedef struct IPAddressACL {
 196     struct IPAddressACL *next;
 197     enum IPAddressAction action;
 198     /* These are in host order */
 199     struct in_addr first;
 200     struct in_addr last;
 201 } IPAddressACL;
 202
 203 /* description of each stream of the ffserver.conf file */
 204 typedef struct FFStream {
 205     enum StreamType stream_type;
 206     char filename[1024];     /* stream filename */
 207     struct FFStream *feed;   /* feed we are using (can be null if
 208                                 coming from file) */
 209     AVFormatParameters *ap_in; /* input parameters */
 210     AVInputFormat *ifmt;       /* if non NULL, force input format */
 211     AVOutputFormat *fmt;
 212     IPAddressACL *acl;
 213     char dynamic_acl[1024];
 214     int nb_streams;
 215     int prebuffer;      /* Number of millseconds early to start */
 216     int64_t max_time;      /* Number of milliseconds to run */
 217     int send_on_key;
 218     AVStream *streams[MAX_STREAMS];
 219     int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
 220     char feed_filename[1024]; /* file name of the feed storage, or
 221                                  input file name for a stream */
 222     char author[512];
 223     char title[512];
 224     char copyright[512];
 225     char comment[512];
 226     pid_t pid;  /* Of ffmpeg process */
 227     time_t pid_start;  /* Of ffmpeg process */
 228     char **child_argv;
 229     struct FFStream *next;
 230     unsigned bandwidth; /* bandwidth, in kbits/s */
 231     /* RTSP options */
 232     char *rtsp_option;
 233     /* multicast specific */
 234     int is_multicast;
 235     struct in_addr multicast_ip;
 236     int multicast_port; /* first port used for multicast */
 237     int multicast_ttl;
 238     int loop; /* if true, send the stream in loops (only meaningful if file) */
 239
 240     /* feed specific */
 241     int feed_opened;     /* true if someone is writing to the feed */
 242     int is_feed;         /* true if it is a feed */
 243     int readonly;        /* True if writing is prohibited to the file */
 244     int truncate;        /* True if feeder connection truncate the feed file */
 245     int conns_served;
 246     int64_t bytes_served;
 247     int64_t feed_max_size;      /* maximum storage size, zero means unlimited */
 248     int64_t feed_write_index;   /* current write position in feed (it wraps around) */
 249     int64_t feed_size;          /* current size of feed */
 250     struct FFStream *next_feed;
 251 } FFStream;
 252
 253 typedef struct FeedData {
 254     long long data_count;
 255     float avg_frame_size;   /* frame size averaged over last frames with exponential mean */
 256 } FeedData;
 257
 258 static struct sockaddr_in my_http_addr;
 259 static struct sockaddr_in my_rtsp_addr;
 260
 261 static char logfilename[1024];
 262 static HTTPContext *first_http_ctx;
 263 static FFStream *first_feed;   /* contains only feeds */
 264 static FFStream *first_stream; /* contains all streams, including feeds */
 265
 266 static void new_connection(int server_fd, int is_rtsp);
 267 static void close_connection(HTTPContext *c);
 268
 269 /* HTTP handling */
 270 static int handle_connection(HTTPContext *c);
 271 static int http_parse_request(HTTPContext *c);
 272 static int http_send_data(HTTPContext *c);
 273 static void compute_status(HTTPContext *c);
 274 static int open_input_stream(HTTPContext *c, const char *info);
 275 static int http_start_receive_data(HTTPContext *c);
 276 static int http_receive_data(HTTPContext *c);
 277
 278 /* RTSP handling */
 279 static int rtsp_parse_request(HTTPContext *c);
 280 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
 281 static void rtsp_cmd_options(HTTPContext *c, const char *url);
 282 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
 283 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
 284 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
 285 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
 286
 287 /* SDP handling */
 288 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
 289                                    struct in_addr my_ip);
 290
 291 /* RTP handling */
 292 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
 293                                        FFStream *stream, const char *session_id,
 294                                        enum RTSPLowerTransport rtp_protocol);
 295 static int rtp_new_av_stream(HTTPContext *c,
 296                              int stream_index, struct sockaddr_in *dest_addr,
 297                              HTTPContext *rtsp_c);
 298
 299 static const char *my_program_name;
 300 static const char *my_program_dir;
 301
 302 static const char *config_filename = "/etc/ffserver.conf";
 303
 304 static int ffserver_debug;
 305 static int ffserver_daemon;
 306 static int no_launch;
 307 static int need_to_start_children;
 308
 309 /* maximum number of simultaneous HTTP connections */
 310 static unsigned int nb_max_http_connections = 2000;
 311 static unsigned int nb_max_connections = 5;
 312 static unsigned int nb_connections;
 313
 314 static uint64_t max_bandwidth = 1000;
 315 static uint64_t current_bandwidth;
 316
 317 static int64_t cur_time;           // Making this global saves on passing it around everywhere
 318
 319 static AVLFG random_state;
 320
 321 static FILE *logfile = NULL;
 322
 323 /* FIXME: make ffserver work with IPv6 */
 324 /* resolve host with also IP address parsing */
 325 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
 326 {
 327
 328     if (!ff_inet_aton(hostname, sin_addr)) {
 329 #if HAVE_GETADDRINFO
 330         struct addrinfo *ai, *cur;
 331         struct addrinfo hints;
 332         memset(&hints, 0, sizeof(hints));
 333         hints.ai_family = AF_INET;
 334         if (getaddrinfo(hostname, NULL, &hints, &ai))
 335             return -1;
 336         /* getaddrinfo returns a linked list of addrinfo structs.
 337          * Even if we set ai_family = AF_INET above, make sure
 338          * that the returned one actually is of the correct type. */
 339         for (cur = ai; cur; cur = cur->ai_next) {
 340             if (cur->ai_family == AF_INET) {
 341                 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
 342                 freeaddrinfo(ai);
 343                 return 0;
 344             }
 345         }
 346         freeaddrinfo(ai);
 347         return -1;
 348 #else
 349         struct hostent *hp;
 350         hp = gethostbyname(hostname);
 351         if (!hp)
 352             return -1;
 353         memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
 354 #endif
 355     }
 356     return 0;
 357 }
 358
 359 static char *ctime1(char *buf2)
 360 {
 361     time_t ti;
 362     char *p;
 363
 364     ti = time(NULL);
 365     p = ctime(&ti);
 366     strcpy(buf2, p);
 367     p = buf2 + strlen(p) - 1;
 368     if (*p == '\n')
 369         *p = '\0';
 370     return buf2;
 371 }
 372
 373 static void http_vlog(const char *fmt, va_list vargs)
 374 {
 375     static int print_prefix = 1;
 376     if (logfile) {
 377         if (print_prefix) {
 378             char buf[32];
 379             ctime1(buf);
 380             fprintf(logfile, "%s ", buf);
 381         }
 382         print_prefix = strstr(fmt, "\n") != NULL;
 383         vfprintf(logfile, fmt, vargs);
 384         fflush(logfile);
 385     }
 386 }
 387
 388 #ifdef __GNUC__
 389 __attribute__ ((format (printf, 1, 2)))
 390 #endif
 391 static void http_log(const char *fmt, ...)
 392 {
 393     va_list vargs;
 394     va_start(vargs, fmt);
 395     http_vlog(fmt, vargs);
 396     va_end(vargs);
 397 }
 398
 399 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
 400 {
 401     static int print_prefix = 1;
 402     AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
 403     if (level > av_log_get_level())
 404         return;
 405     if (print_prefix && avc)
 406         http_log("[%s @ %p]", avc->item_name(ptr), ptr);
 407     print_prefix = strstr(fmt, "\n") != NULL;
 408     http_vlog(fmt, vargs);
 409 }
 410
 411 static void log_connection(HTTPContext *c)
 412 {
 413     if (c->suppress_log)
 414         return;
 415
 416     http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
 417              inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
 418              c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
 419 }
 420
 421 static void update_datarate(DataRateData *drd, int64_t count)
 422 {
 423     if (!drd->time1 && !drd->count1) {
 424         drd->time1 = drd->time2 = cur_time;
 425         drd->count1 = drd->count2 = count;
 426     } else if (cur_time - drd->time2 > 5000) {
 427         drd->time1 = drd->time2;
 428         drd->count1 = drd->count2;
 429         drd->time2 = cur_time;
 430         drd->count2 = count;
 431     }
 432 }
 433
 434 /* In bytes per second */
 435 static int compute_datarate(DataRateData *drd, int64_t count)
 436 {
 437     if (cur_time == drd->time1)
 438         return 0;
 439
 440     return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
 441 }
 442
 443
 444 static void start_children(FFStream *feed)
 445 {
 446     if (no_launch)
 447         return;
 448
 449     for (; feed; feed = feed->next) {
 450         if (feed->child_argv && !feed->pid) {
 451             feed->pid_start = time(0);
 452
 453             feed->pid = fork();
 454
 455             if (feed->pid < 0) {
 456                 http_log("Unable to create children\n");
 457                 exit(1);
 458             }
 459             if (!feed->pid) {
 460                 /* In child */
 461                 char pathname[1024];
 462                 char *slash;
 463                 int i;
 464
 465                 av_strlcpy(pathname, my_program_name, sizeof(pathname));
 466
 467                 slash = strrchr(pathname, '/');
 468                 if (!slash)
 469                     slash = pathname;
 470                 else
 471                     slash++;
 472                 strcpy(slash, "ffmpeg");
 473
 474                 http_log("Launch commandline: ");
 475                 http_log("%s ", pathname);
 476                 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
 477                     http_log("%s ", feed->child_argv[i]);
 478                 http_log("\n");
 479
 480                 for (i = 3; i < 256; i++)
 481                     close(i);
 482
 483                 if (!ffserver_debug) {
 484                     i = open("/dev/null", O_RDWR);
 485                     if (i != -1) {
 486                         dup2(i, 0);
 487                         dup2(i, 1);
 488                         dup2(i, 2);
 489                         close(i);
 490                     }
 491                 }
 492
 493                 /* This is needed to make relative pathnames work */
 494                 chdir(my_program_dir);
 495
 496                 signal(SIGPIPE, SIG_DFL);
 497
 498                 execvp(pathname, feed->child_argv);
 499
 500                 _exit(1);
 501             }
 502         }
 503     }
 504 }
 505
 506 /* open a listening socket */
 507 static int socket_open_listen(struct sockaddr_in *my_addr)
 508 {
 509     int server_fd, tmp;
 510
 511     server_fd = socket(AF_INET,SOCK_STREAM,0);
 512     if (server_fd < 0) {
 513         perror ("socket");
 514         return -1;
 515     }
 516
 517     tmp = 1;
 518     setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
 519
 520     if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
 521         char bindmsg[32];
 522         snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
 523         perror (bindmsg);
 524         closesocket(server_fd);
 525         return -1;
 526     }
 527
 528     if (listen (server_fd, 5) < 0) {
 529         perror ("listen");
 530         closesocket(server_fd);
 531         return -1;
 532     }
 533     ff_socket_nonblock(server_fd, 1);
 534
 535     return server_fd;
 536 }
 537
 538 /* start all multicast streams */
 539 static void start_multicast(void)
 540 {
 541     FFStream *stream;
 542     char session_id[32];
 543     HTTPContext *rtp_c;
 544     struct sockaddr_in dest_addr;
 545     int default_port, stream_index;
 546
 547     default_port = 6000;
 548     for(stream = first_stream; stream != NULL; stream = stream->next) {
 549         if (stream->is_multicast) {
 550             /* open the RTP connection */
 551             snprintf(session_id, sizeof(session_id), "%08x%08x",
 552                      av_lfg_get(&random_state), av_lfg_get(&random_state));
 553
 554             /* choose a port if none given */
 555             if (stream->multicast_port == 0) {
 556                 stream->multicast_port = default_port;
 557                 default_port += 100;
 558             }
 559
 560             dest_addr.sin_family = AF_INET;
 561             dest_addr.sin_addr = stream->multicast_ip;
 562             dest_addr.sin_port = htons(stream->multicast_port);
 563
 564             rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
 565                                        RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
 566             if (!rtp_c)
 567                 continue;
 568
 569             if (open_input_stream(rtp_c, "") < 0) {
 570                 http_log("Could not open input stream for stream '%s'\n",
 571                          stream->filename);
 572                 continue;
 573             }
 574
 575             /* open each RTP stream */
 576             for(stream_index = 0; stream_index < stream->nb_streams;
 577                 stream_index++) {
 578                 dest_addr.sin_port = htons(stream->multicast_port +
 579                                            2 * stream_index);
 580                 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
 581                     http_log("Could not open output stream '%s/streamid=%d'\n",
 582                              stream->filename, stream_index);
 583                     exit(1);
 584                 }
 585             }
 586
 587             /* change state to send data */
 588             rtp_c->state = HTTPSTATE_SEND_DATA;
 589         }
 590     }
 591 }
 592
 593 /* main loop of the http server */
 594 static int http_server(void)
 595 {
 596     int server_fd = 0, rtsp_server_fd = 0;
 597     int ret, delay, delay1;
 598     struct pollfd *poll_table, *poll_entry;
 599     HTTPContext *c, *c_next;
 600
 601     if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
 602         http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
 603         return -1;
 604     }
 605
 606     if (my_http_addr.sin_port) {
 607         server_fd = socket_open_listen(&my_http_addr);
 608         if (server_fd < 0)
 609             return -1;
 610     }
 611
 612     if (my_rtsp_addr.sin_port) {
 613         rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
 614         if (rtsp_server_fd < 0)
 615             return -1;
 616     }
 617
 618     if (!rtsp_server_fd && !server_fd) {
 619         http_log("HTTP and RTSP disabled.\n");
 620         return -1;
 621     }
 622
 623     http_log("FFserver started.\n");
 624
 625     start_children(first_feed);
 626
 627     start_multicast();
 628
 629     for(;;) {
 630         poll_entry = poll_table;
 631         if (server_fd) {
 632             poll_entry->fd = server_fd;
 633             poll_entry->events = POLLIN;
 634             poll_entry++;
 635         }
 636         if (rtsp_server_fd) {
 637             poll_entry->fd = rtsp_server_fd;
 638             poll_entry->events = POLLIN;
 639             poll_entry++;
 640         }
 641
 642         /* wait for events on each HTTP handle */
 643         c = first_http_ctx;
 644         delay = 1000;
 645         while (c != NULL) {
 646             int fd;
 647             fd = c->fd;
 648             switch(c->state) {
 649             case HTTPSTATE_SEND_HEADER:
 650             case RTSPSTATE_SEND_REPLY:
 651             case RTSPSTATE_SEND_PACKET:
 652                 c->poll_entry = poll_entry;
 653                 poll_entry->fd = fd;
 654                 poll_entry->events = POLLOUT;
 655                 poll_entry++;
 656                 break;
 657             case HTTPSTATE_SEND_DATA_HEADER:
 658             case HTTPSTATE_SEND_DATA:
 659             case HTTPSTATE_SEND_DATA_TRAILER:
 660                 if (!c->is_packetized) {
 661                     /* for TCP, we output as much as we can (may need to put a limit) */
 662                     c->poll_entry = poll_entry;
 663                     poll_entry->fd = fd;
 664                     poll_entry->events = POLLOUT;
 665                     poll_entry++;
 666                 } else {
 667                     /* when ffserver is doing the timing, we work by
 668                        looking at which packet need to be sent every
 669                        10 ms */
 670                     delay1 = 10; /* one tick wait XXX: 10 ms assumed */
 671                     if (delay1 < delay)
 672                         delay = delay1;
 673                 }
 674                 break;
 675             case HTTPSTATE_WAIT_REQUEST:
 676             case HTTPSTATE_RECEIVE_DATA:
 677             case HTTPSTATE_WAIT_FEED:
 678             case RTSPSTATE_WAIT_REQUEST:
 679                 /* need to catch errors */
 680                 c->poll_entry = poll_entry;
 681                 poll_entry->fd = fd;
 682                 poll_entry->events = POLLIN;/* Maybe this will work */
 683                 poll_entry++;
 684                 break;
 685             default:
 686                 c->poll_entry = NULL;
 687                 break;
 688             }
 689             c = c->next;
 690         }
 691
 692         /* wait for an event on one connection. We poll at least every
 693            second to handle timeouts */
 694         do {
 695             ret = poll(poll_table, poll_entry - poll_table, delay);
 696             if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
 697                 ff_neterrno() != AVERROR(EINTR))
 698                 return -1;
 699         } while (ret < 0);
 700
 701         cur_time = av_gettime() / 1000;
 702
 703         if (need_to_start_children) {
 704             need_to_start_children = 0;
 705             start_children(first_feed);
 706         }
 707
 708         /* now handle the events */
 709         for(c = first_http_ctx; c != NULL; c = c_next) {
 710             c_next = c->next;
 711             if (handle_connection(c) < 0) {
 712                 /* close and free the connection */
 713                 log_connection(c);
 714                 close_connection(c);
 715             }
 716         }
 717
 718         poll_entry = poll_table;
 719         if (server_fd) {
 720             /* new HTTP connection request ? */
 721             if (poll_entry->revents & POLLIN)
 722                 new_connection(server_fd, 0);
 723             poll_entry++;
 724         }
 725         if (rtsp_server_fd) {
 726             /* new RTSP connection request ? */
 727             if (poll_entry->revents & POLLIN)
 728                 new_connection(rtsp_server_fd, 1);
 729         }
 730     }
 731 }
 732
 733 /* start waiting for a new HTTP/RTSP request */
 734 static void start_wait_request(HTTPContext *c, int is_rtsp)
 735 {
 736     c->buffer_ptr = c->buffer;
 737     c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
 738
 739     if (is_rtsp) {
 740         c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
 741         c->state = RTSPSTATE_WAIT_REQUEST;
 742     } else {
 743         c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
 744         c->state = HTTPSTATE_WAIT_REQUEST;
 745     }
 746 }
 747
 748 static void http_send_too_busy_reply(int fd)
 749 {
 750     char buffer[300];
 751     int len = snprintf(buffer, sizeof(buffer),
 752                        "HTTP/1.0 503 Server too busy\r\n"
 753                        "Content-type: text/html\r\n"
 754                        "\r\n"
 755                        "<html><head><title>Too busy</title></head><body>\r\n"
 756                        "<p>The server is too busy to serve your request at this time.</p>\r\n"
 757                        "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
 758                        "</body></html>\r\n",
 759                        nb_connections, nb_max_connections);
 760     send(fd, buffer, len, 0);
 761 }
 762
 763
 764 static void new_connection(int server_fd, int is_rtsp)
 765 {
 766     struct sockaddr_in from_addr;
 767     int fd, len;
 768     HTTPContext *c = NULL;
 769
 770     len = sizeof(from_addr);
 771     fd = accept(server_fd, (struct sockaddr *)&from_addr,
 772                 &len);
 773     if (fd < 0) {
 774         http_log("error during accept %s\n", strerror(errno));
 775         return;
 776     }
 777     ff_socket_nonblock(fd, 1);
 778
 779     if (nb_connections >= nb_max_connections) {
 780         http_send_too_busy_reply(fd);
 781         goto fail;
 782     }
 783
 784     /* add a new connection */
 785     c = av_mallocz(sizeof(HTTPContext));
 786     if (!c)
 787         goto fail;
 788
 789     c->fd = fd;
 790     c->poll_entry = NULL;
 791     c->from_addr = from_addr;
 792     c->buffer_size = IOBUFFER_INIT_SIZE;
 793     c->buffer = av_malloc(c->buffer_size);
 794     if (!c->buffer)
 795         goto fail;
 796
 797     c->next = first_http_ctx;
 798     first_http_ctx = c;
 799     nb_connections++;
 800
 801     start_wait_request(c, is_rtsp);
 802
 803     return;
 804
 805  fail:
 806     if (c) {
 807         av_free(c->buffer);
 808         av_free(c);
 809     }
 810     closesocket(fd);
 811 }
 812
 813 static void close_connection(HTTPContext *c)
 814 {
 815     HTTPContext **cp, *c1;
 816     int i, nb_streams;
 817     AVFormatContext *ctx;
 818     URLContext *h;
 819     AVStream *st;
 820
 821     /* remove connection from list */
 822     cp = &first_http_ctx;
 823     while ((*cp) != NULL) {
 824         c1 = *cp;
 825         if (c1 == c)
 826             *cp = c->next;
 827         else
 828             cp = &c1->next;
 829     }
 830
 831     /* remove references, if any (XXX: do it faster) */
 832     for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
 833         if (c1->rtsp_c == c)
 834             c1->rtsp_c = NULL;
 835     }
 836
 837     /* remove connection associated resources */
 838     if (c->fd >= 0)
 839         closesocket(c->fd);
 840     if (c->fmt_in) {
 841         /* close each frame parser */
 842         for(i=0;i<c->fmt_in->nb_streams;i++) {
 843             st = c->fmt_in->streams[i];
 844             if (st->codec->codec)
 845                 avcodec_close(st->codec);
 846         }
 847         av_close_input_file(c->fmt_in);
 848     }
 849
 850     /* free RTP output streams if any */
 851     nb_streams = 0;
 852     if (c->stream)
 853         nb_streams = c->stream->nb_streams;
 854
 855     for(i=0;i<nb_streams;i++) {
 856         ctx = c->rtp_ctx[i];
 857         if (ctx) {
 858             av_write_trailer(ctx);
 859             av_metadata_free(&ctx->metadata);
 860             av_free(ctx->streams[0]);
 861             av_free(ctx);
 862         }
 863         h = c->rtp_handles[i];
 864         if (h)
 865             url_close(h);
 866     }
 867
 868     ctx = &c->fmt_ctx;
 869
 870     if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
 871         if (ctx->oformat) {
 872             /* prepare header */
 873             if (avio_open_dyn_buf(&ctx->pb) >= 0) {
 874                 av_write_trailer(ctx);
 875                 av_freep(&c->pb_buffer);
 876                 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
 877             }
 878         }
 879     }
 880
 881     for(i=0; i<ctx->nb_streams; i++)
 882         av_free(ctx->streams[i]);
 883
 884     if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
 885         current_bandwidth -= c->stream->bandwidth;
 886
 887     /* signal that there is no feed if we are the feeder socket */
 888     if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
 889         c->stream->feed_opened = 0;
 890         close(c->feed_fd);
 891     }
 892
 893     av_freep(&c->pb_buffer);
 894     av_freep(&c->packet_buffer);
 895     av_free(c->buffer);
 896     av_free(c);
 897     nb_connections--;
 898 }
 899
 900 static int handle_connection(HTTPContext *c)
 901 {
 902     int len, ret;
 903
 904     switch(c->state) {
 905     case HTTPSTATE_WAIT_REQUEST:
 906     case RTSPSTATE_WAIT_REQUEST:
 907         /* timeout ? */
 908         if ((c->timeout - cur_time) < 0)
 909             return -1;
 910         if (c->poll_entry->revents & (POLLERR | POLLHUP))
 911             return -1;
 912
 913         /* no need to read if no events */
 914         if (!(c->poll_entry->revents & POLLIN))
 915             return 0;
 916         /* read the data */
 917     read_loop:
 918         len = recv(c->fd, c->buffer_ptr, 1, 0);
 919         if (len < 0) {
 920             if (ff_neterrno() != AVERROR(EAGAIN) &&
 921                 ff_neterrno() != AVERROR(EINTR))
 922                 return -1;
 923         } else if (len == 0) {
 924             return -1;
 925         } else {
 926             /* search for end of request. */
 927             uint8_t *ptr;
 928             c->buffer_ptr += len;
 929             ptr = c->buffer_ptr;
 930             if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
 931                 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
 932                 /* request found : parse it and reply */
 933                 if (c->state == HTTPSTATE_WAIT_REQUEST) {
 934                     ret = http_parse_request(c);
 935                 } else {
 936                     ret = rtsp_parse_request(c);
 937                 }
 938                 if (ret < 0)
 939                     return -1;
 940             } else if (ptr >= c->buffer_end) {
 941                 /* request too long: cannot do anything */
 942                 return -1;
 943             } else goto read_loop;
 944         }
 945         break;
 946
 947     case HTTPSTATE_SEND_HEADER:
 948         if (c->poll_entry->revents & (POLLERR | POLLHUP))
 949             return -1;
 950
 951         /* no need to write if no events */
 952         if (!(c->poll_entry->revents & POLLOUT))
 953             return 0;
 954         len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
 955         if (len < 0) {
 956             if (ff_neterrno() != AVERROR(EAGAIN) &&
 957                 ff_neterrno() != AVERROR(EINTR)) {
 958                 /* error : close connection */
 959                 av_freep(&c->pb_buffer);
 960                 return -1;
 961             }
 962         } else {
 963             c->buffer_ptr += len;
 964             if (c->stream)
 965                 c->stream->bytes_served += len;
 966             c->data_count += len;
 967             if (c->buffer_ptr >= c->buffer_end) {
 968                 av_freep(&c->pb_buffer);
 969                 /* if error, exit */
 970                 if (c->http_error)
 971                     return -1;
 972                 /* all the buffer was sent : synchronize to the incoming stream */
 973                 c->state = HTTPSTATE_SEND_DATA_HEADER;
 974                 c->buffer_ptr = c->buffer_end = c->buffer;
 975             }
 976         }
 977         break;
 978
 979     case HTTPSTATE_SEND_DATA:
 980     case HTTPSTATE_SEND_DATA_HEADER:
 981     case HTTPSTATE_SEND_DATA_TRAILER:
 982         /* for packetized output, we consider we can always write (the
 983            input streams sets the speed). It may be better to verify
 984            that we do not rely too much on the kernel queues */
 985         if (!c->is_packetized) {
 986             if (c->poll_entry->revents & (POLLERR | POLLHUP))
 987                 return -1;
 988
 989             /* no need to read if no events */
 990             if (!(c->poll_entry->revents & POLLOUT))
 991                 return 0;
 992         }
 993         if (http_send_data(c) < 0)
 994             return -1;
 995         /* close connection if trailer sent */
 996         if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
 997             return -1;
 998         break;
 999     case HTTPSTATE_RECEIVE_DATA:
1000         /* no need to read if no events */
1001         if (c->poll_entry->revents & (POLLERR | POLLHUP))
1002             return -1;
1003         if (!(c->poll_entry->revents & POLLIN))
1004             return 0;
1005         if (http_receive_data(c) < 0)
1006             return -1;
1007         break;
1008     case HTTPSTATE_WAIT_FEED:
1009         /* no need to read if no events */
1010         if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1011             return -1;
1012
1013         /* nothing to do, we'll be waken up by incoming feed packets */
1014         break;
1015
1016     case RTSPSTATE_SEND_REPLY:
1017         if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1018             av_freep(&c->pb_buffer);
1019             return -1;
1020         }
1021         /* no need to write if no events */
1022         if (!(c->poll_entry->revents & POLLOUT))
1023             return 0;
1024         len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1025         if (len < 0) {
1026             if (ff_neterrno() != AVERROR(EAGAIN) &&
1027                 ff_neterrno() != AVERROR(EINTR)) {
1028                 /* error : close connection */
1029                 av_freep(&c->pb_buffer);
1030                 return -1;
1031             }
1032         } else {
1033             c->buffer_ptr += len;
1034             c->data_count += len;
1035             if (c->buffer_ptr >= c->buffer_end) {
1036                 /* all the buffer was sent : wait for a new request */
1037                 av_freep(&c->pb_buffer);
1038                 start_wait_request(c, 1);
1039             }
1040         }
1041         break;
1042     case RTSPSTATE_SEND_PACKET:
1043         if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1044             av_freep(&c->packet_buffer);
1045             return -1;
1046         }
1047         /* no need to write if no events */
1048         if (!(c->poll_entry->revents & POLLOUT))
1049             return 0;
1050         len = send(c->fd, c->packet_buffer_ptr,
1051                     c->packet_buffer_end - c->packet_buffer_ptr, 0);
1052         if (len < 0) {
1053             if (ff_neterrno() != AVERROR(EAGAIN) &&
1054                 ff_neterrno() != AVERROR(EINTR)) {
1055                 /* error : close connection */
1056                 av_freep(&c->packet_buffer);
1057                 return -1;
1058             }
1059         } else {
1060             c->packet_buffer_ptr += len;
1061             if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1062                 /* all the buffer was sent : wait for a new request */
1063                 av_freep(&c->packet_buffer);
1064                 c->state = RTSPSTATE_WAIT_REQUEST;
1065             }
1066         }
1067         break;
1068     case HTTPSTATE_READY:
1069         /* nothing to do */
1070         break;
1071     default:
1072         return -1;
1073     }
1074     return 0;
1075 }
1076
1077 static int extract_rates(char *rates, int ratelen, const char *request)
1078 {
1079     const char *p;
1080
1081     for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1082         if (strncasecmp(p, "Pragma:", 7) == 0) {
1083             const char *q = p + 7;
1084
1085             while (*q && *q != '\n' && isspace(*q))
1086                 q++;
1087
1088             if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1089                 int stream_no;
1090                 int rate_no;
1091
1092                 q += 20;
1093
1094                 memset(rates, 0xff, ratelen);
1095
1096                 while (1) {
1097                     while (*q && *q != '\n' && *q != ':')
1098                         q++;
1099
1100                     if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1101                         break;
1102
1103                     stream_no--;
1104                     if (stream_no < ratelen && stream_no >= 0)
1105                         rates[stream_no] = rate_no;
1106
1107                     while (*q && *q != '\n' && !isspace(*q))
1108                         q++;
1109                 }
1110
1111                 return 1;
1112             }
1113         }
1114         p = strchr(p, '\n');
1115         if (!p)
1116             break;
1117
1118         p++;
1119     }
1120
1121     return 0;
1122 }
1123
1124 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1125 {
1126     int i;
1127     int best_bitrate = 100000000;
1128     int best = -1;
1129
1130     for (i = 0; i < feed->nb_streams; i++) {
1131         AVCodecContext *feed_codec = feed->streams[i]->codec;
1132
1133         if (feed_codec->codec_id != codec->codec_id ||
1134             feed_codec->sample_rate != codec->sample_rate ||
1135             feed_codec->width != codec->width ||
1136             feed_codec->height != codec->height)
1137             continue;
1138
1139         /* Potential stream */
1140
1141         /* We want the fastest stream less than bit_rate, or the slowest
1142          * faster than bit_rate
1143          */
1144
1145         if (feed_codec->bit_rate <= bit_rate) {
1146             if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1147                 best_bitrate = feed_codec->bit_rate;
1148                 best = i;
1149             }
1150         } else {
1151             if (feed_codec->bit_rate < best_bitrate) {
1152                 best_bitrate = feed_codec->bit_rate;
1153                 best = i;
1154             }
1155         }
1156     }
1157
1158     return best;
1159 }
1160
1161 static int modify_current_stream(HTTPContext *c, char *rates)
1162 {
1163     int i;
1164     FFStream *req = c->stream;
1165     int action_required = 0;
1166
1167     /* Not much we can do for a feed */
1168     if (!req->feed)
1169         return 0;
1170
1171     for (i = 0; i < req->nb_streams; i++) {
1172         AVCodecContext *codec = req->streams[i]->codec;
1173
1174         switch(rates[i]) {
1175             case 0:
1176                 c->switch_feed_streams[i] = req->feed_streams[i];
1177                 break;
1178             case 1:
1179                 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1180                 break;
1181             case 2:
1182                 /* Wants off or slow */
1183                 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1184 #ifdef WANTS_OFF
1185                 /* This doesn't work well when it turns off the only stream! */
1186                 c->switch_feed_streams[i] = -2;
1187                 c->feed_streams[i] = -2;
1188 #endif
1189                 break;
1190         }
1191
1192         if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1193             action_required = 1;
1194     }
1195
1196     return action_required;
1197 }
1198
1199 /* XXX: factorize in utils.c ? */
1200 /* XXX: take care with different space meaning */
1201 static void skip_spaces(const char **pp)
1202 {
1203     const char *p;
1204     p = *pp;
1205     while (*p == ' ' || *p == '\t')
1206         p++;
1207     *pp = p;
1208 }
1209
1210 static void get_word(char *buf, int buf_size, const char **pp)
1211 {
1212     const char *p;
1213     char *q;
1214
1215     p = *pp;
1216     skip_spaces(&p);
1217     q = buf;
1218     while (!isspace(*p) && *p != '\0') {
1219         if ((q - buf) < buf_size - 1)
1220             *q++ = *p;
1221         p++;
1222     }
1223     if (buf_size > 0)
1224         *q = '\0';
1225     *pp = p;
1226 }
1227
1228 static void get_arg(char *buf, int buf_size, const char **pp)
1229 {
1230     const char *p;
1231     char *q;
1232     int quote;
1233
1234     p = *pp;
1235     while (isspace(*p)) p++;
1236     q = buf;
1237     quote = 0;
1238     if (*p == '\"' || *p == '\'')
1239         quote = *p++;
1240     for(;;) {
1241         if (quote) {
1242             if (*p == quote)
1243                 break;
1244         } else {
1245             if (isspace(*p))
1246                 break;
1247         }
1248         if (*p == '\0')
1249             break;
1250         if ((q - buf) < buf_size - 1)
1251             *q++ = *p;
1252         p++;
1253     }
1254     *q = '\0';
1255     if (quote && *p == quote)
1256         p++;
1257     *pp = p;
1258 }
1259
1260 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1261                          const char *p, const char *filename, int line_num)
1262 {
1263     char arg[1024];
1264     IPAddressACL acl;
1265     int errors = 0;
1266
1267     get_arg(arg, sizeof(arg), &p);
1268     if (strcasecmp(arg, "allow") == 0)
1269         acl.action = IP_ALLOW;
1270     else if (strcasecmp(arg, "deny") == 0)
1271         acl.action = IP_DENY;
1272     else {
1273         fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1274                 filename, line_num, arg);
1275         errors++;
1276     }
1277
1278     get_arg(arg, sizeof(arg), &p);
1279
1280     if (resolve_host(&acl.first, arg) != 0) {
1281         fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1282                 filename, line_num, arg);
1283         errors++;
1284     } else
1285         acl.last = acl.first;
1286
1287     get_arg(arg, sizeof(arg), &p);
1288
1289     if (arg[0]) {
1290         if (resolve_host(&acl.last, arg) != 0) {
1291             fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1292                     filename, line_num, arg);
1293             errors++;
1294         }
1295     }
1296
1297     if (!errors) {
1298         IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1299         IPAddressACL **naclp = 0;
1300
1301         acl.next = 0;
1302         *nacl = acl;
1303
1304         if (stream)
1305             naclp = &stream->acl;
1306         else if (feed)
1307             naclp = &feed->acl;
1308         else if (ext_acl)
1309             naclp = &ext_acl;
1310         else {
1311             fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1312                     filename, line_num);
1313             errors++;
1314         }
1315
1316         if (naclp) {
1317             while (*naclp)
1318                 naclp = &(*naclp)->next;
1319
1320             *naclp = nacl;
1321         }
1322     }
1323 }
1324
1325
1326 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1327 {
1328     FILE* f;
1329     char line[1024];
1330     char  cmd[1024];
1331     IPAddressACL *acl = NULL;
1332     int line_num = 0;
1333     const char *p;
1334
1335     f = fopen(stream->dynamic_acl, "r");
1336     if (!f) {
1337         perror(stream->dynamic_acl);
1338         return NULL;
1339     }
1340
1341     acl = av_mallocz(sizeof(IPAddressACL));
1342
1343     /* Build ACL */
1344     for(;;) {
1345         if (fgets(line, sizeof(line), f) == NULL)
1346             break;
1347         line_num++;
1348         p = line;
1349         while (isspace(*p))
1350             p++;
1351         if (*p == '\0' || *p == '#')
1352             continue;
1353         get_arg(cmd, sizeof(cmd), &p);
1354
1355         if (!strcasecmp(cmd, "ACL"))
1356             parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1357     }
1358     fclose(f);
1359     return acl;
1360 }
1361
1362
1363 static void free_acl_list(IPAddressACL *in_acl)
1364 {
1365     IPAddressACL *pacl,*pacl2;
1366
1367     pacl = in_acl;
1368     while(pacl) {
1369         pacl2 = pacl;
1370         pacl = pacl->next;
1371         av_freep(pacl2);
1372     }
1373 }
1374
1375 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1376 {
1377     enum IPAddressAction last_action = IP_DENY;
1378     IPAddressACL *acl;
1379     struct in_addr *src = &c->from_addr.sin_addr;
1380     unsigned long src_addr = src->s_addr;
1381
1382     for (acl = in_acl; acl; acl = acl->next) {
1383         if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1384             return (acl->action == IP_ALLOW) ? 1 : 0;
1385         last_action = acl->action;
1386     }
1387
1388     /* Nothing matched, so return not the last action */
1389     return (last_action == IP_DENY) ? 1 : 0;
1390 }
1391
1392 static int validate_acl(FFStream *stream, HTTPContext *c)
1393 {
1394     int ret = 0;
1395     IPAddressACL *acl;
1396
1397
1398     /* if stream->acl is null validate_acl_list will return 1 */
1399     ret = validate_acl_list(stream->acl, c);
1400
1401     if (stream->dynamic_acl[0]) {
1402         acl = parse_dynamic_acl(stream, c);
1403
1404         ret = validate_acl_list(acl, c);
1405
1406         free_acl_list(acl);
1407     }
1408
1409     return ret;
1410 }
1411
1412 /* compute the real filename of a file by matching it without its
1413    extensions to all the stream filenames */
1414 static void compute_real_filename(char *filename, int max_size)
1415 {
1416     char file1[1024];
1417     char file2[1024];
1418     char *p;
1419     FFStream *stream;
1420
1421     /* compute filename by matching without the file extensions */
1422     av_strlcpy(file1, filename, sizeof(file1));
1423     p = strrchr(file1, '.');
1424     if (p)
1425         *p = '\0';
1426     for(stream = first_stream; stream != NULL; stream = stream->next) {
1427         av_strlcpy(file2, stream->filename, sizeof(file2));
1428         p = strrchr(file2, '.');
1429         if (p)
1430             *p = '\0';
1431         if (!strcmp(file1, file2)) {
1432             av_strlcpy(filename, stream->filename, max_size);
1433             break;
1434         }
1435     }
1436 }
1437
1438 enum RedirType {
1439     REDIR_NONE,
1440     REDIR_ASX,
1441     REDIR_RAM,
1442     REDIR_ASF,
1443     REDIR_RTSP,
1444     REDIR_SDP,
1445 };
1446
1447 /* parse http request and prepare header */
1448 static int http_parse_request(HTTPContext *c)
1449 {
1450     char *p;
1451     enum RedirType redir_type;
1452     char cmd[32];
1453     char info[1024], filename[1024];
1454     char url[1024], *q;
1455     char protocol[32];
1456     char msg[1024];
1457     const char *mime_type;
1458     FFStream *stream;
1459     int i;
1460     char ratebuf[32];
1461     char *useragent = 0;
1462
1463     p = c->buffer;
1464     get_word(cmd, sizeof(cmd), (const char **)&p);
1465     av_strlcpy(c->method, cmd, sizeof(c->method));
1466
1467     if (!strcmp(cmd, "GET"))
1468         c->post = 0;
1469     else if (!strcmp(cmd, "POST"))
1470         c->post = 1;
1471     else
1472         return -1;
1473
1474     get_word(url, sizeof(url), (const char **)&p);
1475     av_strlcpy(c->url, url, sizeof(c->url));
1476
1477     get_word(protocol, sizeof(protocol), (const char **)&p);
1478     if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1479         return -1;
1480
1481     av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1482
1483     if (ffserver_debug)
1484         http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1485
1486     /* find the filename and the optional info string in the request */
1487     p = strchr(url, '?');
1488     if (p) {
1489         av_strlcpy(info, p, sizeof(info));
1490         *p = '\0';
1491     } else
1492         info[0] = '\0';
1493
1494     av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1495
1496     for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1497         if (strncasecmp(p, "User-Agent:", 11) == 0) {
1498             useragent = p + 11;
1499             if (*useragent && *useragent != '\n' && isspace(*useragent))
1500                 useragent++;
1501             break;
1502         }
1503         p = strchr(p, '\n');
1504         if (!p)
1505             break;
1506
1507         p++;
1508     }
1509
1510     redir_type = REDIR_NONE;
1511     if (av_match_ext(filename, "asx")) {
1512         redir_type = REDIR_ASX;
1513         filename[strlen(filename)-1] = 'f';
1514     } else if (av_match_ext(filename, "asf") &&
1515         (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1516         /* if this isn't WMP or lookalike, return the redirector file */
1517         redir_type = REDIR_ASF;
1518     } else if (av_match_ext(filename, "rpm,ram")) {
1519         redir_type = REDIR_RAM;
1520         strcpy(filename + strlen(filename)-2, "m");
1521     } else if (av_match_ext(filename, "rtsp")) {
1522         redir_type = REDIR_RTSP;
1523         compute_real_filename(filename, sizeof(filename) - 1);
1524     } else if (av_match_ext(filename, "sdp")) {
1525         redir_type = REDIR_SDP;
1526         compute_real_filename(filename, sizeof(filename) - 1);
1527     }
1528
1529     // "redirect" / request to index.html
1530     if (!strlen(filename))
1531         av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1532
1533     stream = first_stream;
1534     while (stream != NULL) {
1535         if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1536             break;
1537         stream = stream->next;
1538     }
1539     if (stream == NULL) {
1540         snprintf(msg, sizeof(msg), "File '%s' not found", url);
1541         http_log("File '%s' not found\n", url);
1542         goto send_error;
1543     }
1544
1545     c->stream = stream;
1546     memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1547     memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1548
1549     if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1550         c->http_error = 301;
1551         q = c->buffer;
1552         q += snprintf(q, c->buffer_size,
1553                       "HTTP/1.0 301 Moved\r\n"
1554                       "Location: %s\r\n"
1555                       "Content-type: text/html\r\n"
1556                       "\r\n"
1557                       "<html><head><title>Moved</title></head><body>\r\n"
1558                       "You should be <a href=\"%s\">redirected</a>.\r\n"
1559                       "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1560         /* prepare output buffer */
1561         c->buffer_ptr = c->buffer;
1562         c->buffer_end = q;
1563         c->state = HTTPSTATE_SEND_HEADER;
1564         return 0;
1565     }
1566
1567     /* If this is WMP, get the rate information */
1568     if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1569         if (modify_current_stream(c, ratebuf)) {
1570             for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1571                 if (c->switch_feed_streams[i] >= 0)
1572                     c->switch_feed_streams[i] = -1;
1573             }
1574         }
1575     }
1576
1577     if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1578         current_bandwidth += stream->bandwidth;
1579
1580     /* If already streaming this feed, do not let start another feeder. */
1581     if (stream->feed_opened) {
1582         snprintf(msg, sizeof(msg), "This feed is already being received.");
1583         http_log("Feed '%s' already being received\n", stream->feed_filename);
1584         goto send_error;
1585     }
1586
1587     if (c->post == 0 && max_bandwidth < current_bandwidth) {
1588         c->http_error = 503;
1589         q = c->buffer;
1590         q += snprintf(q, c->buffer_size,
1591                       "HTTP/1.0 503 Server too busy\r\n"
1592                       "Content-type: text/html\r\n"
1593                       "\r\n"
1594                       "<html><head><title>Too busy</title></head><body>\r\n"
1595                       "<p>The server is too busy to serve your request at this time.</p>\r\n"
1596                       "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1597                       "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1598                       "</body></html>\r\n", current_bandwidth, max_bandwidth);
1599         /* prepare output buffer */
1600         c->buffer_ptr = c->buffer;
1601         c->buffer_end = q;
1602         c->state = HTTPSTATE_SEND_HEADER;
1603         return 0;
1604     }
1605
1606     if (redir_type != REDIR_NONE) {
1607         char *hostinfo = 0;
1608
1609         for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1610             if (strncasecmp(p, "Host:", 5) == 0) {
1611                 hostinfo = p + 5;
1612                 break;
1613             }
1614             p = strchr(p, '\n');
1615             if (!p)
1616                 break;
1617
1618             p++;
1619         }
1620
1621         if (hostinfo) {
1622             char *eoh;
1623             char hostbuf[260];
1624
1625             while (isspace(*hostinfo))
1626                 hostinfo++;
1627
1628             eoh = strchr(hostinfo, '\n');
1629             if (eoh) {
1630                 if (eoh[-1] == '\r')
1631                     eoh--;
1632
1633                 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1634                     memcpy(hostbuf, hostinfo, eoh - hostinfo);
1635                     hostbuf[eoh - hostinfo] = 0;
1636
1637                     c->http_error = 200;
1638                     q = c->buffer;
1639                     switch(redir_type) {
1640                     case REDIR_ASX:
1641                         q += snprintf(q, c->buffer_size,
1642                                       "HTTP/1.0 200 ASX Follows\r\n"
1643                                       "Content-type: video/x-ms-asf\r\n"
1644                                       "\r\n"
1645                                       "<ASX Version=\"3\">\r\n"
1646                                       //"<!-- Autogenerated by ffserver -->\r\n"
1647                                       "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1648                                       "</ASX>\r\n", hostbuf, filename, info);
1649                         break;
1650                     case REDIR_RAM:
1651                         q += snprintf(q, c->buffer_size,
1652                                       "HTTP/1.0 200 RAM Follows\r\n"
1653                                       "Content-type: audio/x-pn-realaudio\r\n"
1654                                       "\r\n"
1655                                       "# Autogenerated by ffserver\r\n"
1656                                       "http://%s/%s%s\r\n", hostbuf, filename, info);
1657                         break;
1658                     case REDIR_ASF:
1659                         q += snprintf(q, c->buffer_size,
1660                                       "HTTP/1.0 200 ASF Redirect follows\r\n"
1661                                       "Content-type: video/x-ms-asf\r\n"
1662                                       "\r\n"
1663                                       "[Reference]\r\n"
1664                                       "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1665                         break;
1666                     case REDIR_RTSP:
1667                         {
1668                             char hostname[256], *p;
1669                             /* extract only hostname */
1670                             av_strlcpy(hostname, hostbuf, sizeof(hostname));
1671                             p = strrchr(hostname, ':');
1672                             if (p)
1673                                 *p = '\0';
1674                             q += snprintf(q, c->buffer_size,
1675                                           "HTTP/1.0 200 RTSP Redirect follows\r\n"
1676                                           /* XXX: incorrect mime type ? */
1677                                           "Content-type: application/x-rtsp\r\n"
1678                                           "\r\n"
1679                                           "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1680                         }
1681                         break;
1682                     case REDIR_SDP:
1683                         {
1684                             uint8_t *sdp_data;
1685                             int sdp_data_size, len;
1686                             struct sockaddr_in my_addr;
1687
1688                             q += snprintf(q, c->buffer_size,
1689                                           "HTTP/1.0 200 OK\r\n"
1690                                           "Content-type: application/sdp\r\n"
1691                                           "\r\n");
1692
1693                             len = sizeof(my_addr);
1694                             getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1695
1696                             /* XXX: should use a dynamic buffer */
1697                             sdp_data_size = prepare_sdp_description(stream,
1698                                                                     &sdp_data,
1699                                                                     my_addr.sin_addr);
1700                             if (sdp_data_size > 0) {
1701                                 memcpy(q, sdp_data, sdp_data_size);
1702                                 q += sdp_data_size;
1703                                 *q = '\0';
1704                                 av_free(sdp_data);
1705                             }
1706                         }
1707                         break;
1708                     default:
1709                         abort();
1710                         break;
1711                     }
1712
1713                     /* prepare output buffer */
1714                     c->buffer_ptr = c->buffer;
1715                     c->buffer_end = q;
1716                     c->state = HTTPSTATE_SEND_HEADER;
1717                     return 0;
1718                 }
1719             }
1720         }
1721
1722         snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1723         goto send_error;
1724     }
1725
1726     stream->conns_served++;
1727
1728     /* XXX: add there authenticate and IP match */
1729
1730     if (c->post) {
1731         /* if post, it means a feed is being sent */
1732         if (!stream->is_feed) {
1733             /* However it might be a status report from WMP! Let us log the
1734              * data as it might come in handy one day. */
1735             char *logline = 0;
1736             int client_id = 0;
1737
1738             for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1739                 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1740                     logline = p;
1741                     break;
1742                 }
1743                 if (strncasecmp(p, "Pragma: client-id=", 18) == 0)
1744                     client_id = strtol(p + 18, 0, 10);
1745                 p = strchr(p, '\n');
1746                 if (!p)
1747                     break;
1748
1749                 p++;
1750             }
1751
1752             if (logline) {
1753                 char *eol = strchr(logline, '\n');
1754
1755                 logline += 17;
1756
1757                 if (eol) {
1758                     if (eol[-1] == '\r')
1759                         eol--;
1760                     http_log("%.*s\n", (int) (eol - logline), logline);
1761                     c->suppress_log = 1;
1762                 }
1763             }
1764
1765 #ifdef DEBUG_WMP
1766             http_log("\nGot request:\n%s\n", c->buffer);
1767 #endif
1768
1769             if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1770                 HTTPContext *wmpc;
1771
1772                 /* Now we have to find the client_id */
1773                 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1774                     if (wmpc->wmp_client_id == client_id)
1775                         break;
1776                 }
1777
1778                 if (wmpc && modify_current_stream(wmpc, ratebuf))
1779                     wmpc->switch_pending = 1;
1780             }
1781
1782             snprintf(msg, sizeof(msg), "POST command not handled");
1783             c->stream = 0;
1784             goto send_error;
1785         }
1786         if (http_start_receive_data(c) < 0) {
1787             snprintf(msg, sizeof(msg), "could not open feed");
1788             goto send_error;
1789         }
1790         c->http_error = 0;
1791         c->state = HTTPSTATE_RECEIVE_DATA;
1792         return 0;
1793     }
1794
1795 #ifdef DEBUG_WMP
1796     if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1797         http_log("\nGot request:\n%s\n", c->buffer);
1798 #endif
1799
1800     if (c->stream->stream_type == STREAM_TYPE_STATUS)
1801         goto send_status;
1802
1803     /* open input stream */
1804     if (open_input_stream(c, info) < 0) {
1805         snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1806         goto send_error;
1807     }
1808
1809     /* prepare http header */
1810     q = c->buffer;
1811     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1812     mime_type = c->stream->fmt->mime_type;
1813     if (!mime_type)
1814         mime_type = "application/x-octet-stream";
1815     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1816
1817     /* for asf, we need extra headers */
1818     if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1819         /* Need to allocate a client id */
1820
1821         c->wmp_client_id = av_lfg_get(&random_state);
1822
1823         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Server: Cougar 4.1.0.3923\r\nCache-Control: no-cache\r\nPragma: client-id=%d\r\nPragma: features=\"broadcast\"\r\n", c->wmp_client_id);
1824     }
1825     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1826     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1827
1828     /* prepare output buffer */
1829     c->http_error = 0;
1830     c->buffer_ptr = c->buffer;
1831     c->buffer_end = q;
1832     c->state = HTTPSTATE_SEND_HEADER;
1833     return 0;
1834  send_error:
1835     c->http_error = 404;
1836     q = c->buffer;
1837     q += snprintf(q, c->buffer_size,
1838                   "HTTP/1.0 404 Not Found\r\n"
1839                   "Content-type: text/html\r\n"
1840                   "\r\n"
1841                   "<html>\n"
1842                   "<head><title>404 Not Found</title></head>\n"
1843                   "<body>%s</body>\n"
1844                   "</html>\n", msg);
1845     /* prepare output buffer */
1846     c->buffer_ptr = c->buffer;
1847     c->buffer_end = q;
1848     c->state = HTTPSTATE_SEND_HEADER;
1849     return 0;
1850  send_status:
1851     compute_status(c);
1852     c->http_error = 200; /* horrible : we use this value to avoid
1853                             going to the send data state */
1854     c->state = HTTPSTATE_SEND_HEADER;
1855     return 0;
1856 }
1857
1858 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1859 {
1860     static const char *suffix = " kMGTP";
1861     const char *s;
1862
1863     for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1864
1865     avio_printf(pb, "%"PRId64"%c", count, *s);
1866 }
1867
1868 static void compute_status(HTTPContext *c)
1869 {
1870     HTTPContext *c1;
1871     FFStream *stream;
1872     char *p;
1873     time_t ti;
1874     int i, len;
1875     AVIOContext *pb;
1876
1877     if (avio_open_dyn_buf(&pb) < 0) {
1878         /* XXX: return an error ? */
1879         c->buffer_ptr = c->buffer;
1880         c->buffer_end = c->buffer;
1881         return;
1882     }
1883
1884     avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1885     avio_printf(pb, "Content-type: %s\r\n", "text/html");
1886     avio_printf(pb, "Pragma: no-cache\r\n");
1887     avio_printf(pb, "\r\n");
1888
1889     avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1890     if (c->stream->feed_filename[0])
1891         avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1892     avio_printf(pb, "</head>\n<body>");
1893     avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1894     /* format status */
1895     avio_printf(pb, "<h2>Available Streams</h2>\n");
1896     avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1897     avio_printf(pb, "<tr><th valign=top>Path<th align=left>Served<br>Conns<th><br>bytes<th valign=top>Format<th>Bit rate<br>kbits/s<th align=left>Video<br>kbits/s<th><br>Codec<th align=left>Audio<br>kbits/s<th><br>Codec<th align=left valign=top>Feed\n");
1898     stream = first_stream;
1899     while (stream != NULL) {
1900         char sfilename[1024];
1901         char *eosf;
1902
1903         if (stream->feed != stream) {
1904             av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1905             eosf = sfilename + strlen(sfilename);
1906             if (eosf - sfilename >= 4) {
1907                 if (strcmp(eosf - 4, ".asf") == 0)
1908                     strcpy(eosf - 4, ".asx");
1909                 else if (strcmp(eosf - 3, ".rm") == 0)
1910                     strcpy(eosf - 3, ".ram");
1911                 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1912                     /* generate a sample RTSP director if
1913                        unicast. Generate an SDP redirector if
1914                        multicast */
1915                     eosf = strrchr(sfilename, '.');
1916                     if (!eosf)
1917                         eosf = sfilename + strlen(sfilename);
1918                     if (stream->is_multicast)
1919                         strcpy(eosf, ".sdp");
1920                     else
1921                         strcpy(eosf, ".rtsp");
1922                 }
1923             }
1924
1925             avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1926                          sfilename, stream->filename);
1927             avio_printf(pb, "<td align=right> %d <td align=right> ",
1928                         stream->conns_served);
1929             fmt_bytecount(pb, stream->bytes_served);
1930             switch(stream->stream_type) {
1931             case STREAM_TYPE_LIVE: {
1932                     int audio_bit_rate = 0;
1933                     int video_bit_rate = 0;
1934                     const char *audio_codec_name = "";
1935                     const char *video_codec_name = "";
1936                     const char *audio_codec_name_extra = "";
1937                     const char *video_codec_name_extra = "";
1938
1939                     for(i=0;i<stream->nb_streams;i++) {
1940                         AVStream *st = stream->streams[i];
1941                         AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1942                         switch(st->codec->codec_type) {
1943                         case AVMEDIA_TYPE_AUDIO:
1944                             audio_bit_rate += st->codec->bit_rate;
1945                             if (codec) {
1946                                 if (*audio_codec_name)
1947                                     audio_codec_name_extra = "...";
1948                                 audio_codec_name = codec->name;
1949                             }
1950                             break;
1951                         case AVMEDIA_TYPE_VIDEO:
1952                             video_bit_rate += st->codec->bit_rate;
1953                             if (codec) {
1954                                 if (*video_codec_name)
1955                                     video_codec_name_extra = "...";
1956                                 video_codec_name = codec->name;
1957                             }
1958                             break;
1959                         case AVMEDIA_TYPE_DATA:
1960                             video_bit_rate += st->codec->bit_rate;
1961                             break;
1962                         default:
1963                             abort();
1964                         }
1965                     }
1966                     avio_printf(pb, "<td align=center> %s <td align=right> %d <td align=right> %d <td> %s %s <td align=right> %d <td> %s %s",
1967                                  stream->fmt->name,
1968                                  stream->bandwidth,
1969                                  video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1970                                  audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1971                     if (stream->feed)
1972                         avio_printf(pb, "<td>%s", stream->feed->filename);
1973                     else
1974                         avio_printf(pb, "<td>%s", stream->feed_filename);
1975                     avio_printf(pb, "\n");
1976                 }
1977                 break;
1978             default:
1979                 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1980                 break;
1981             }
1982         }
1983         stream = stream->next;
1984     }
1985     avio_printf(pb, "</table>\n");
1986
1987     stream = first_stream;
1988     while (stream != NULL) {
1989         if (stream->feed == stream) {
1990             avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
1991             if (stream->pid) {
1992                 avio_printf(pb, "Running as pid %d.\n", stream->pid);
1993
1994 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1995                 {
1996                     FILE *pid_stat;
1997                     char ps_cmd[64];
1998
1999                     /* This is somewhat linux specific I guess */
2000                     snprintf(ps_cmd, sizeof(ps_cmd),
2001                              "ps -o \"%%cpu,cputime\" --no-headers %d",
2002                              stream->pid);
2003
2004                     pid_stat = popen(ps_cmd, "r");
2005                     if (pid_stat) {
2006                         char cpuperc[10];
2007                         char cpuused[64];
2008
2009                         if (fscanf(pid_stat, "%10s %64s", cpuperc,
2010                                    cpuused) == 2) {
2011                             avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2012                                          cpuperc, cpuused);
2013                         }
2014                         fclose(pid_stat);
2015                     }
2016                 }
2017 #endif
2018
2019                 avio_printf(pb, "<p>");
2020             }
2021             avio_printf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
2022
2023             for (i = 0; i < stream->nb_streams; i++) {
2024                 AVStream *st = stream->streams[i];
2025                 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2026                 const char *type = "unknown";
2027                 char parameters[64];
2028
2029                 parameters[0] = 0;
2030
2031                 switch(st->codec->codec_type) {
2032                 case AVMEDIA_TYPE_AUDIO:
2033                     type = "audio";
2034                     snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2035                     break;
2036                 case AVMEDIA_TYPE_VIDEO:
2037                     type = "video";
2038                     snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2039                                 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2040                     break;
2041                 default:
2042                     abort();
2043                 }
2044                 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2045                         i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2046             }
2047             avio_printf(pb, "</table>\n");
2048
2049         }
2050         stream = stream->next;
2051     }
2052
2053     /* connection status */
2054     avio_printf(pb, "<h2>Connection Status</h2>\n");
2055
2056     avio_printf(pb, "Number of connections: %d / %d<br>\n",
2057                  nb_connections, nb_max_connections);
2058
2059     avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2060                  current_bandwidth, max_bandwidth);
2061
2062     avio_printf(pb, "<table>\n");
2063     avio_printf(pb, "<tr><th>#<th>File<th>IP<th>Proto<th>State<th>Target bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
2064     c1 = first_http_ctx;
2065     i = 0;
2066     while (c1 != NULL) {
2067         int bitrate;
2068         int j;
2069
2070         bitrate = 0;
2071         if (c1->stream) {
2072             for (j = 0; j < c1->stream->nb_streams; j++) {
2073                 if (!c1->stream->feed)
2074                     bitrate += c1->stream->streams[j]->codec->bit_rate;
2075                 else if (c1->feed_streams[j] >= 0)
2076                     bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2077             }
2078         }
2079
2080         i++;
2081         p = inet_ntoa(c1->from_addr.sin_addr);
2082         avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2083                     i,
2084                     c1->stream ? c1->stream->filename : "",
2085                     c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2086                     p,
2087                     c1->protocol,
2088                     http_state[c1->state]);
2089         fmt_bytecount(pb, bitrate);
2090         avio_printf(pb, "<td align=right>");
2091         fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2092         avio_printf(pb, "<td align=right>");
2093         fmt_bytecount(pb, c1->data_count);
2094         avio_printf(pb, "\n");
2095         c1 = c1->next;
2096     }
2097     avio_printf(pb, "</table>\n");
2098
2099     /* date */
2100     ti = time(NULL);
2101     p = ctime(&ti);
2102     avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2103     avio_printf(pb, "</body>\n</html>\n");
2104
2105     len = avio_close_dyn_buf(pb, &c->pb_buffer);
2106     c->buffer_ptr = c->pb_buffer;
2107     c->buffer_end = c->pb_buffer + len;
2108 }
2109
2110 /* check if the parser needs to be opened for stream i */
2111 static void open_parser(AVFormatContext *s, int i)
2112 {
2113     AVStream *st = s->streams[i];
2114     AVCodec *codec;
2115
2116     if (!st->codec->codec) {
2117         codec = avcodec_find_decoder(st->codec->codec_id);
2118         if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
2119             st->codec->parse_only = 1;
2120             if (avcodec_open(st->codec, codec) < 0)
2121                 st->codec->parse_only = 0;
2122         }
2123     }
2124 }
2125
2126 static int open_input_stream(HTTPContext *c, const char *info)
2127 {
2128     char buf[128];
2129     char input_filename[1024];
2130     AVFormatContext *s;
2131     int buf_size, i, ret;
2132     int64_t stream_pos;
2133
2134     /* find file name */
2135     if (c->stream->feed) {
2136         strcpy(input_filename, c->stream->feed->feed_filename);
2137         buf_size = FFM_PACKET_SIZE;
2138         /* compute position (absolute time) */
2139         if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2140             if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2141                 return ret;
2142         } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2143             int prebuffer = strtol(buf, 0, 10);
2144             stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2145         } else
2146             stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2147     } else {
2148         strcpy(input_filename, c->stream->feed_filename);
2149         buf_size = 0;
2150         /* compute position (relative time) */
2151         if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2152             if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2153                 return ret;
2154         } else
2155             stream_pos = 0;
2156     }
2157     if (input_filename[0] == '\0')
2158         return -1;
2159
2160     /* open stream */
2161     if ((ret = av_open_input_file(&s, input_filename, c->stream->ifmt,
2162                                   buf_size, c->stream->ap_in)) < 0) {
2163         http_log("could not open %s: %d\n", input_filename, ret);
2164         return -1;
2165     }
2166     s->flags |= AVFMT_FLAG_GENPTS;
2167     c->fmt_in = s;
2168     if (strcmp(s->iformat->name, "ffm") && av_find_stream_info(c->fmt_in) < 0) {
2169         http_log("Could not find stream info '%s'\n", input_filename);
2170         av_close_input_file(s);
2171         return -1;
2172     }
2173
2174     /* open each parser */
2175     for(i=0;i<s->nb_streams;i++)
2176         open_parser(s, i);
2177
2178     /* choose stream as clock source (we favorize video stream if
2179        present) for packet sending */
2180     c->pts_stream_index = 0;
2181     for(i=0;i<c->stream->nb_streams;i++) {
2182         if (c->pts_stream_index == 0 &&
2183             c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2184             c->pts_stream_index = i;
2185         }
2186     }
2187
2188     if (c->fmt_in->iformat->read_seek)
2189         av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2190     /* set the start time (needed for maxtime and RTP packet timing) */
2191     c->start_time = cur_time;
2192     c->first_pts = AV_NOPTS_VALUE;
2193     return 0;
2194 }
2195
2196 /* return the server clock (in us) */
2197 static int64_t get_server_clock(HTTPContext *c)
2198 {
2199     /* compute current pts value from system time */
2200     return (cur_time - c->start_time) * 1000;
2201 }
2202
2203 /* return the estimated time at which the current packet must be sent
2204    (in us) */
2205 static int64_t get_packet_send_clock(HTTPContext *c)
2206 {
2207     int bytes_left, bytes_sent, frame_bytes;
2208
2209     frame_bytes = c->cur_frame_bytes;
2210     if (frame_bytes <= 0)
2211         return c->cur_pts;
2212     else {
2213         bytes_left = c->buffer_end - c->buffer_ptr;
2214         bytes_sent = frame_bytes - bytes_left;
2215         return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2216     }
2217 }
2218
2219
2220 static int http_prepare_data(HTTPContext *c)
2221 {
2222     int i, len, ret;
2223     AVFormatContext *ctx;
2224
2225     av_freep(&c->pb_buffer);
2226     switch(c->state) {
2227     case HTTPSTATE_SEND_DATA_HEADER:
2228         memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2229         av_metadata_set2(&c->fmt_ctx.metadata, "author"   , c->stream->author   , 0);
2230         av_metadata_set2(&c->fmt_ctx.metadata, "comment"  , c->stream->comment  , 0);
2231         av_metadata_set2(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2232         av_metadata_set2(&c->fmt_ctx.metadata, "title"    , c->stream->title    , 0);
2233
2234         for(i=0;i<c->stream->nb_streams;i++) {
2235             AVStream *st;
2236             AVStream *src;
2237             st = av_mallocz(sizeof(AVStream));
2238             c->fmt_ctx.streams[i] = st;
2239             /* if file or feed, then just take streams from FFStream struct */
2240             if (!c->stream->feed ||
2241                 c->stream->feed == c->stream)
2242                 src = c->stream->streams[i];
2243             else
2244                 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2245
2246             *st = *src;
2247             st->priv_data = 0;
2248             st->codec->frame_number = 0; /* XXX: should be done in
2249                                            AVStream, not in codec */
2250         }
2251         /* set output format parameters */
2252         c->fmt_ctx.oformat = c->stream->fmt;
2253         c->fmt_ctx.nb_streams = c->stream->nb_streams;
2254
2255         c->got_key_frame = 0;
2256
2257         /* prepare header and save header data in a stream */
2258         if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2259             /* XXX: potential leak */
2260             return -1;
2261         }
2262         c->fmt_ctx.pb->seekable = 0;
2263
2264         /*
2265          * HACK to avoid mpeg ps muxer to spit many underflow errors
2266          * Default value from Libav
2267          * Try to set it use configuration option
2268          */
2269         c->fmt_ctx.preload   = (int)(0.5*AV_TIME_BASE);
2270         c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2271
2272         av_set_parameters(&c->fmt_ctx, NULL);
2273         if (av_write_header(&c->fmt_ctx) < 0) {
2274             http_log("Error writing output header\n");
2275             return -1;
2276         }
2277         av_metadata_free(&c->fmt_ctx.metadata);
2278
2279         len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2280         c->buffer_ptr = c->pb_buffer;
2281         c->buffer_end = c->pb_buffer + len;
2282
2283         c->state = HTTPSTATE_SEND_DATA;
2284         c->last_packet_sent = 0;
2285         break;
2286     case HTTPSTATE_SEND_DATA:
2287         /* find a new packet */
2288         /* read a packet from the input stream */
2289         if (c->stream->feed)
2290             ffm_set_write_index(c->fmt_in,
2291                                 c->stream->feed->feed_write_index,
2292                                 c->stream->feed->feed_size);
2293
2294         if (c->stream->max_time &&
2295             c->stream->max_time + c->start_time - cur_time < 0)
2296             /* We have timed out */
2297             c->state = HTTPSTATE_SEND_DATA_TRAILER;
2298         else {
2299             AVPacket pkt;
2300         redo:
2301             ret = av_read_frame(c->fmt_in, &pkt);
2302             if (ret < 0) {
2303                 if (c->stream->feed) {
2304                     /* if coming from feed, it means we reached the end of the
2305                        ffm file, so must wait for more data */
2306                     c->state = HTTPSTATE_WAIT_FEED;
2307                     return 1; /* state changed */
2308                 } else if (ret == AVERROR(EAGAIN)) {
2309                     /* input not ready, come back later */
2310                     return 0;
2311                 } else {
2312                     if (c->stream->loop) {
2313                         av_close_input_file(c->fmt_in);
2314                         c->fmt_in = NULL;
2315                         if (open_input_stream(c, "") < 0)
2316                             goto no_loop;
2317                         goto redo;
2318                     } else {
2319                     no_loop:
2320                         /* must send trailer now because eof or error */
2321                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
2322                     }
2323                 }
2324             } else {
2325                 int source_index = pkt.stream_index;
2326                 /* update first pts if needed */
2327                 if (c->first_pts == AV_NOPTS_VALUE) {
2328                     c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2329                     c->start_time = cur_time;
2330                 }
2331                 /* send it to the appropriate stream */
2332                 if (c->stream->feed) {
2333                     /* if coming from a feed, select the right stream */
2334                     if (c->switch_pending) {
2335                         c->switch_pending = 0;
2336                         for(i=0;i<c->stream->nb_streams;i++) {
2337                             if (c->switch_feed_streams[i] == pkt.stream_index)
2338                                 if (pkt.flags & AV_PKT_FLAG_KEY)
2339                                     c->switch_feed_streams[i] = -1;
2340                             if (c->switch_feed_streams[i] >= 0)
2341                                 c->switch_pending = 1;
2342                         }
2343                     }
2344                     for(i=0;i<c->stream->nb_streams;i++) {
2345                         if (c->stream->feed_streams[i] == pkt.stream_index) {
2346                             AVStream *st = c->fmt_in->streams[source_index];
2347                             pkt.stream_index = i;
2348                             if (pkt.flags & AV_PKT_FLAG_KEY &&
2349                                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2350                                  c->stream->nb_streams == 1))
2351                                 c->got_key_frame = 1;
2352                             if (!c->stream->send_on_key || c->got_key_frame)
2353                                 goto send_it;
2354                         }
2355                     }
2356                 } else {
2357                     AVCodecContext *codec;
2358                     AVStream *ist, *ost;
2359                 send_it:
2360                     ist = c->fmt_in->streams[source_index];
2361                     /* specific handling for RTP: we use several
2362                        output stream (one for each RTP
2363                        connection). XXX: need more abstract handling */
2364                     if (c->is_packetized) {
2365                         /* compute send time and duration */
2366                         c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2367                         c->cur_pts -= c->first_pts;
2368                         c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2369                         /* find RTP context */
2370                         c->packet_stream_index = pkt.stream_index;
2371                         ctx = c->rtp_ctx[c->packet_stream_index];
2372                         if(!ctx) {
2373                             av_free_packet(&pkt);
2374                             break;
2375                         }
2376                         codec = ctx->streams[0]->codec;
2377                         /* only one stream per RTP connection */
2378                         pkt.stream_index = 0;
2379                     } else {
2380                         ctx = &c->fmt_ctx;
2381                         /* Fudge here */
2382                         codec = ctx->streams[pkt.stream_index]->codec;
2383                     }
2384
2385                     if (c->is_packetized) {
2386                         int max_packet_size;
2387                         if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2388                             max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2389                         else
2390                             max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2391                         ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2392                     } else {
2393                         ret = avio_open_dyn_buf(&ctx->pb);
2394                     }
2395                     if (ret < 0) {
2396                         /* XXX: potential leak */
2397                         return -1;
2398                     }
2399                     ost = ctx->streams[pkt.stream_index];
2400
2401                     ctx->pb->seekable = 0;
2402                     if (pkt.dts != AV_NOPTS_VALUE)
2403                         pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2404                     if (pkt.pts != AV_NOPTS_VALUE)
2405                         pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2406                     pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2407                     if (av_write_frame(ctx, &pkt) < 0) {
2408                         http_log("Error writing frame to output\n");
2409                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
2410                     }
2411
2412                     len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2413                     c->cur_frame_bytes = len;
2414                     c->buffer_ptr = c->pb_buffer;
2415                     c->buffer_end = c->pb_buffer + len;
2416
2417                     codec->frame_number++;
2418                     if (len == 0) {
2419                         av_free_packet(&pkt);
2420                         goto redo;
2421                     }
2422                 }
2423                 av_free_packet(&pkt);
2424             }
2425         }
2426         break;
2427     default:
2428     case HTTPSTATE_SEND_DATA_TRAILER:
2429         /* last packet test ? */
2430         if (c->last_packet_sent || c->is_packetized)
2431             return -1;
2432         ctx = &c->fmt_ctx;
2433         /* prepare header */
2434         if (avio_open_dyn_buf(&ctx->pb) < 0) {
2435             /* XXX: potential leak */
2436             return -1;
2437         }
2438         c->fmt_ctx.pb->seekable = 0;
2439         av_write_trailer(ctx);
2440         len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2441         c->buffer_ptr = c->pb_buffer;
2442         c->buffer_end = c->pb_buffer + len;
2443
2444         c->last_packet_sent = 1;
2445         break;
2446     }
2447     return 0;
2448 }
2449
2450 /* should convert the format at the same time */
2451 /* send data starting at c->buffer_ptr to the output connection
2452    (either UDP or TCP connection) */
2453 static int http_send_data(HTTPContext *c)
2454 {
2455     int len, ret;
2456
2457     for(;;) {
2458         if (c->buffer_ptr >= c->buffer_end) {
2459             ret = http_prepare_data(c);
2460             if (ret < 0)
2461                 return -1;
2462             else if (ret != 0)
2463                 /* state change requested */
2464                 break;
2465         } else {
2466             if (c->is_packetized) {
2467                 /* RTP data output */
2468                 len = c->buffer_end - c->buffer_ptr;
2469                 if (len < 4) {
2470                     /* fail safe - should never happen */
2471                 fail1:
2472                     c->buffer_ptr = c->buffer_end;
2473                     return 0;
2474                 }
2475                 len = (c->buffer_ptr[0] << 24) |
2476                     (c->buffer_ptr[1] << 16) |
2477                     (c->buffer_ptr[2] << 8) |
2478                     (c->buffer_ptr[3]);
2479                 if (len > (c->buffer_end - c->buffer_ptr))
2480                     goto fail1;
2481                 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2482                     /* nothing to send yet: we can wait */
2483                     return 0;
2484                 }
2485
2486                 c->data_count += len;
2487                 update_datarate(&c->datarate, c->data_count);
2488                 if (c->stream)
2489                     c->stream->bytes_served += len;
2490
2491                 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2492                     /* RTP packets are sent inside the RTSP TCP connection */
2493                     AVIOContext *pb;
2494                     int interleaved_index, size;
2495                     uint8_t header[4];
2496                     HTTPContext *rtsp_c;
2497
2498                     rtsp_c = c->rtsp_c;
2499                     /* if no RTSP connection left, error */
2500                     if (!rtsp_c)
2501                         return -1;
2502                     /* if already sending something, then wait. */
2503                     if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2504                         break;
2505                     if (avio_open_dyn_buf(&pb) < 0)
2506                         goto fail1;
2507                     interleaved_index = c->packet_stream_index * 2;
2508                     /* RTCP packets are sent at odd indexes */
2509                     if (c->buffer_ptr[1] == 200)
2510                         interleaved_index++;
2511                     /* write RTSP TCP header */
2512                     header[0] = '$';
2513                     header[1] = interleaved_index;
2514                     header[2] = len >> 8;
2515                     header[3] = len;
2516                     avio_write(pb, header, 4);
2517                     /* write RTP packet data */
2518                     c->buffer_ptr += 4;
2519                     avio_write(pb, c->buffer_ptr, len);
2520                     size = avio_close_dyn_buf(pb, &c->packet_buffer);
2521                     /* prepare asynchronous TCP sending */
2522                     rtsp_c->packet_buffer_ptr = c->packet_buffer;
2523                     rtsp_c->packet_buffer_end = c->packet_buffer + size;
2524                     c->buffer_ptr += len;
2525
2526                     /* send everything we can NOW */
2527                     len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2528                                 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2529                     if (len > 0)
2530                         rtsp_c->packet_buffer_ptr += len;
2531                     if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2532                         /* if we could not send all the data, we will
2533                            send it later, so a new state is needed to
2534                            "lock" the RTSP TCP connection */
2535                         rtsp_c->state = RTSPSTATE_SEND_PACKET;
2536                         break;
2537                     } else
2538                         /* all data has been sent */
2539                         av_freep(&c->packet_buffer);
2540                 } else {
2541                     /* send RTP packet directly in UDP */
2542                     c->buffer_ptr += 4;
2543                     url_write(c->rtp_handles[c->packet_stream_index],
2544                               c->buffer_ptr, len);
2545                     c->buffer_ptr += len;
2546                     /* here we continue as we can send several packets per 10 ms slot */
2547                 }
2548             } else {
2549                 /* TCP data output */
2550                 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2551                 if (len < 0) {
2552                     if (ff_neterrno() != AVERROR(EAGAIN) &&
2553                         ff_neterrno() != AVERROR(EINTR))
2554                         /* error : close connection */
2555                         return -1;
2556                     else
2557                         return 0;
2558                 } else
2559                     c->buffer_ptr += len;
2560
2561                 c->data_count += len;
2562                 update_datarate(&c->datarate, c->data_count);
2563                 if (c->stream)
2564                     c->stream->bytes_served += len;
2565                 break;
2566             }
2567         }
2568     } /* for(;;) */
2569     return 0;
2570 }
2571
2572 static int http_start_receive_data(HTTPContext *c)
2573 {
2574     int fd;
2575
2576     if (c->stream->feed_opened)
2577         return -1;
2578
2579     /* Don't permit writing to this one */
2580     if (c->stream->readonly)
2581         return -1;
2582
2583     /* open feed */
2584     fd = open(c->stream->feed_filename, O_RDWR);
2585     if (fd < 0) {
2586         http_log("Error opening feeder file: %s\n", strerror(errno));
2587         return -1;
2588     }
2589     c->feed_fd = fd;
2590
2591     if (c->stream->truncate) {
2592         /* truncate feed file */
2593         ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2594         ftruncate(c->feed_fd, FFM_PACKET_SIZE);
2595         http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2596     } else {
2597         if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2598             http_log("Error reading write index from feed file: %s\n", strerror(errno));
2599             return -1;
2600         }
2601     }
2602
2603     c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2604     c->stream->feed_size = lseek(fd, 0, SEEK_END);
2605     lseek(fd, 0, SEEK_SET);
2606
2607     /* init buffer input */
2608     c->buffer_ptr = c->buffer;
2609     c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2610     c->stream->feed_opened = 1;
2611     c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2612     return 0;
2613 }
2614
2615 static int http_receive_data(HTTPContext *c)
2616 {
2617     HTTPContext *c1;
2618     int len, loop_run = 0;
2619
2620     while (c->chunked_encoding && !c->chunk_size &&
2621            c->buffer_end > c->buffer_ptr) {
2622         /* read chunk header, if present */
2623         len = recv(c->fd, c->buffer_ptr, 1, 0);
2624
2625         if (len < 0) {
2626             if (ff_neterrno() != AVERROR(EAGAIN) &&
2627                 ff_neterrno() != AVERROR(EINTR))
2628                 /* error : close connection */
2629                 goto fail;
2630             return 0;
2631         } else if (len == 0) {
2632             /* end of connection : close it */
2633             goto fail;
2634         } else if (c->buffer_ptr - c->buffer >= 2 &&
2635                    !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2636             c->chunk_size = strtol(c->buffer, 0, 16);
2637             if (c->chunk_size == 0) // end of stream
2638                 goto fail;
2639             c->buffer_ptr = c->buffer;
2640             break;
2641         } else if (++loop_run > 10) {
2642             /* no chunk header, abort */
2643             goto fail;
2644         } else {
2645             c->buffer_ptr++;
2646         }
2647     }
2648
2649     if (c->buffer_end > c->buffer_ptr) {
2650         len = recv(c->fd, c->buffer_ptr,
2651                    FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2652         if (len < 0) {
2653             if (ff_neterrno() != AVERROR(EAGAIN) &&
2654                 ff_neterrno() != AVERROR(EINTR))
2655                 /* error : close connection */
2656                 goto fail;
2657         } else if (len == 0)
2658             /* end of connection : close it */
2659             goto fail;
2660         else {
2661             c->chunk_size -= len;
2662             c->buffer_ptr += len;
2663             c->data_count += len;
2664             update_datarate(&c->datarate, c->data_count);
2665         }
2666     }
2667
2668     if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2669         if (c->buffer[0] != 'f' ||
2670             c->buffer[1] != 'm') {
2671             http_log("Feed stream has become desynchronized -- disconnecting\n");
2672             goto fail;
2673         }
2674     }
2675
2676     if (c->buffer_ptr >= c->buffer_end) {
2677         FFStream *feed = c->stream;
2678         /* a packet has been received : write it in the store, except
2679            if header */
2680         if (c->data_count > FFM_PACKET_SIZE) {
2681
2682             //            printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2683             /* XXX: use llseek or url_seek */
2684             lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2685             if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2686                 http_log("Error writing to feed file: %s\n", strerror(errno));
2687                 goto fail;
2688             }
2689
2690             feed->feed_write_index += FFM_PACKET_SIZE;
2691             /* update file size */
2692             if (feed->feed_write_index > c->stream->feed_size)
2693                 feed->feed_size = feed->feed_write_index;
2694
2695             /* handle wrap around if max file size reached */
2696             if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2697                 feed->feed_write_index = FFM_PACKET_SIZE;
2698
2699             /* write index */
2700             if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2701                 http_log("Error writing index to feed file: %s\n", strerror(errno));
2702                 goto fail;
2703             }
2704
2705             /* wake up any waiting connections */
2706             for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2707                 if (c1->state == HTTPSTATE_WAIT_FEED &&
2708                     c1->stream->feed == c->stream->feed)
2709                     c1->state = HTTPSTATE_SEND_DATA;
2710             }
2711         } else {
2712             /* We have a header in our hands that contains useful data */
2713             AVFormatContext *s = NULL;
2714             AVIOContext *pb;
2715             AVInputFormat *fmt_in;
2716             int i;
2717
2718             /* use feed output format name to find corresponding input format */
2719             fmt_in = av_find_input_format(feed->fmt->name);
2720             if (!fmt_in)
2721                 goto fail;
2722
2723             pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2724                                     0, NULL, NULL, NULL, NULL);
2725             pb->seekable = 0;
2726
2727             if (av_open_input_stream(&s, pb, c->stream->feed_filename, fmt_in, NULL) < 0) {
2728                 av_free(pb);
2729                 goto fail;
2730             }
2731
2732             /* Now we have the actual streams */
2733             if (s->nb_streams != feed->nb_streams) {
2734                 av_close_input_stream(s);
2735                 av_free(pb);
2736                 http_log("Feed '%s' stream number does not match registered feed\n",
2737                          c->stream->feed_filename);
2738                 goto fail;
2739             }
2740
2741             for (i = 0; i < s->nb_streams; i++) {
2742                 AVStream *fst = feed->streams[i];
2743                 AVStream *st = s->streams[i];
2744                 avcodec_copy_context(fst->codec, st->codec);
2745             }
2746
2747             av_close_input_stream(s);
2748             av_free(pb);
2749         }
2750         c->buffer_ptr = c->buffer;
2751     }
2752
2753     return 0;
2754  fail:
2755     c->stream->feed_opened = 0;
2756     close(c->feed_fd);
2757     /* wake up any waiting connections to stop waiting for feed */
2758     for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2759         if (c1->state == HTTPSTATE_WAIT_FEED &&
2760             c1->stream->feed == c->stream->feed)
2761             c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2762     }
2763     return -1;
2764 }
2765
2766 /********************************************************************/
2767 /* RTSP handling */
2768
2769 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2770 {
2771     const char *str;
2772     time_t ti;
2773     struct tm *tm;
2774     char buf2[32];
2775
2776     switch(error_number) {
2777     case RTSP_STATUS_OK:
2778         str = "OK";
2779         break;
2780     case RTSP_STATUS_METHOD:
2781         str = "Method Not Allowed";
2782         break;
2783     case RTSP_STATUS_BANDWIDTH:
2784         str = "Not Enough Bandwidth";
2785         break;
2786     case RTSP_STATUS_SESSION:
2787         str = "Session Not Found";
2788         break;
2789     case RTSP_STATUS_STATE:
2790         str = "Method Not Valid in This State";
2791         break;
2792     case RTSP_STATUS_AGGREGATE:
2793         str = "Aggregate operation not allowed";
2794         break;
2795     case RTSP_STATUS_ONLY_AGGREGATE:
2796         str = "Only aggregate operation allowed";
2797         break;
2798     case RTSP_STATUS_TRANSPORT:
2799         str = "Unsupported transport";
2800         break;
2801     case RTSP_STATUS_INTERNAL:
2802         str = "Internal Server Error";
2803         break;
2804     case RTSP_STATUS_SERVICE:
2805         str = "Service Unavailable";
2806         break;
2807     case RTSP_STATUS_VERSION:
2808         str = "RTSP Version not supported";
2809         break;
2810     default:
2811         str = "Unknown Error";
2812         break;
2813     }
2814
2815     avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2816     avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2817
2818     /* output GMT time */
2819     ti = time(NULL);
2820     tm = gmtime(&ti);
2821     strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2822     avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2823 }
2824
2825 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2826 {
2827     rtsp_reply_header(c, error_number);
2828     avio_printf(c->pb, "\r\n");
2829 }
2830
2831 static int rtsp_parse_request(HTTPContext *c)
2832 {
2833     const char *p, *p1, *p2;
2834     char cmd[32];
2835     char url[1024];
2836     char protocol[32];
2837     char line[1024];
2838     int len;
2839     RTSPMessageHeader header1, *header = &header1;
2840
2841     c->buffer_ptr[0] = '\0';
2842     p = c->buffer;
2843
2844     get_word(cmd, sizeof(cmd), &p);
2845     get_word(url, sizeof(url), &p);
2846     get_word(protocol, sizeof(protocol), &p);
2847
2848     av_strlcpy(c->method, cmd, sizeof(c->method));
2849     av_strlcpy(c->url, url, sizeof(c->url));
2850     av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2851
2852     if (avio_open_dyn_buf(&c->pb) < 0) {
2853         /* XXX: cannot do more */
2854         c->pb = NULL; /* safety */
2855         return -1;
2856     }
2857
2858     /* check version name */
2859     if (strcmp(protocol, "RTSP/1.0") != 0) {
2860         rtsp_reply_error(c, RTSP_STATUS_VERSION);
2861         goto the_end;
2862     }
2863
2864     /* parse each header line */
2865     memset(header, 0, sizeof(*header));
2866     /* skip to next line */
2867     while (*p != '\n' && *p != '\0')
2868         p++;
2869     if (*p == '\n')
2870         p++;
2871     while (*p != '\0') {
2872         p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2873         if (!p1)
2874             break;
2875         p2 = p1;
2876         if (p2 > p && p2[-1] == '\r')
2877             p2--;
2878         /* skip empty line */
2879         if (p2 == p)
2880             break;
2881         len = p2 - p;
2882         if (len > sizeof(line) - 1)
2883             len = sizeof(line) - 1;
2884         memcpy(line, p, len);
2885         line[len] = '\0';
2886         ff_rtsp_parse_line(header, line, NULL, NULL);
2887         p = p1 + 1;
2888     }
2889
2890     /* handle sequence number */
2891     c->seq = header->seq;
2892
2893     if (!strcmp(cmd, "DESCRIBE"))
2894         rtsp_cmd_describe(c, url);
2895     else if (!strcmp(cmd, "OPTIONS"))
2896         rtsp_cmd_options(c, url);
2897     else if (!strcmp(cmd, "SETUP"))
2898         rtsp_cmd_setup(c, url, header);
2899     else if (!strcmp(cmd, "PLAY"))
2900         rtsp_cmd_play(c, url, header);
2901     else if (!strcmp(cmd, "PAUSE"))
2902         rtsp_cmd_pause(c, url, header);
2903     else if (!strcmp(cmd, "TEARDOWN"))
2904         rtsp_cmd_teardown(c, url, header);
2905     else
2906         rtsp_reply_error(c, RTSP_STATUS_METHOD);
2907
2908  the_end:
2909     len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2910     c->pb = NULL; /* safety */
2911     if (len < 0) {
2912         /* XXX: cannot do more */
2913         return -1;
2914     }
2915     c->buffer_ptr = c->pb_buffer;
2916     c->buffer_end = c->pb_buffer + len;
2917     c->state = RTSPSTATE_SEND_REPLY;
2918     return 0;
2919 }
2920
2921 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2922                                    struct in_addr my_ip)
2923 {
2924     AVFormatContext *avc;
2925     AVStream *avs = NULL;
2926     int i;
2927
2928     avc =  avformat_alloc_context();
2929     if (avc == NULL) {
2930         return -1;
2931     }
2932     av_metadata_set2(&avc->metadata, "title",
2933                      stream->title[0] ? stream->title : "No Title", 0);
2934     avc->nb_streams = stream->nb_streams;
2935     if (stream->is_multicast) {
2936         snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2937                  inet_ntoa(stream->multicast_ip),
2938                  stream->multicast_port, stream->multicast_ttl);
2939     } else {
2940         snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2941     }
2942
2943     if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2944         !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2945         goto sdp_done;
2946     if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2947         !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2948         goto sdp_done;
2949
2950     for(i = 0; i < stream->nb_streams; i++) {
2951         avc->streams[i] = &avs[i];
2952         avc->streams[i]->codec = stream->streams[i]->codec;
2953     }
2954     *pbuffer = av_mallocz(2048);
2955     av_sdp_create(&avc, 1, *pbuffer, 2048);
2956
2957  sdp_done:
2958     av_free(avc->streams);
2959     av_metadata_free(&avc->metadata);
2960     av_free(avc);
2961     av_free(avs);
2962
2963     return strlen(*pbuffer);
2964 }
2965
2966 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2967 {
2968 //    rtsp_reply_header(c, RTSP_STATUS_OK);
2969     avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2970     avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2971     avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2972     avio_printf(c->pb, "\r\n");
2973 }
2974
2975 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2976 {
2977     FFStream *stream;
2978     char path1[1024];
2979     const char *path;
2980     uint8_t *content;
2981     int content_length, len;
2982     struct sockaddr_in my_addr;
2983
2984     /* find which url is asked */
2985     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2986     path = path1;
2987     if (*path == '/')
2988         path++;
2989
2990     for(stream = first_stream; stream != NULL; stream = stream->next) {
2991         if (!stream->is_feed &&
2992             stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2993             !strcmp(path, stream->filename)) {
2994             goto found;
2995         }
2996     }
2997     /* no stream found */
2998     rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2999     return;
3000
3001  found:
3002     /* prepare the media description in sdp format */
3003
3004     /* get the host IP */
3005     len = sizeof(my_addr);
3006     getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3007     content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3008     if (content_length < 0) {
3009         rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3010         return;
3011     }
3012     rtsp_reply_header(c, RTSP_STATUS_OK);
3013     avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3014     avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3015     avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3016     avio_printf(c->pb, "\r\n");
3017     avio_write(c->pb, content, content_length);
3018     av_free(content);
3019 }
3020
3021 static HTTPContext *find_rtp_session(const char *session_id)
3022 {
3023     HTTPContext *c;
3024
3025     if (session_id[0] == '\0')
3026         return NULL;
3027
3028     for(c = first_http_ctx; c != NULL; c = c->next) {
3029         if (!strcmp(c->session_id, session_id))
3030             return c;
3031     }
3032     return NULL;
3033 }
3034
3035 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3036 {
3037     RTSPTransportField *th;
3038     int i;
3039
3040     for(i=0;i<h->nb_transports;i++) {
3041         th = &h->transports[i];
3042         if (th->lower_transport == lower_transport)
3043             return th;
3044     }
3045     return NULL;
3046 }
3047
3048 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3049                            RTSPMessageHeader *h)
3050 {
3051     FFStream *stream;
3052     int stream_index, rtp_port, rtcp_port;
3053     char buf[1024];
3054     char path1[1024];
3055     const char *path;
3056     HTTPContext *rtp_c;
3057     RTSPTransportField *th;
3058     struct sockaddr_in dest_addr;
3059     RTSPActionServerSetup setup;
3060
3061     /* find which url is asked */
3062     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3063     path = path1;
3064     if (*path == '/')
3065         path++;
3066
3067     /* now check each stream */
3068     for(stream = first_stream; stream != NULL; stream = stream->next) {
3069         if (!stream->is_feed &&
3070             stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3071             /* accept aggregate filenames only if single stream */
3072             if (!strcmp(path, stream->filename)) {
3073                 if (stream->nb_streams != 1) {
3074                     rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3075                     return;
3076                 }
3077                 stream_index = 0;
3078                 goto found;
3079             }
3080
3081             for(stream_index = 0; stream_index < stream->nb_streams;
3082                 stream_index++) {
3083                 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3084                          stream->filename, stream_index);
3085                 if (!strcmp(path, buf))
3086                     goto found;
3087             }
3088         }
3089     }
3090     /* no stream found */
3091     rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3092     return;
3093  found:
3094
3095     /* generate session id if needed */
3096     if (h->session_id[0] == '\0')
3097         snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3098                  av_lfg_get(&random_state), av_lfg_get(&random_state));
3099
3100     /* find rtp session, and create it if none found */
3101     rtp_c = find_rtp_session(h->session_id);
3102     if (!rtp_c) {
3103         /* always prefer UDP */
3104         th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3105         if (!th) {
3106             th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3107             if (!th) {
3108                 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3109                 return;
3110             }
3111         }
3112
3113         rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3114                                    th->lower_transport);
3115         if (!rtp_c) {
3116             rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3117             return;
3118         }
3119
3120         /* open input stream */
3121         if (open_input_stream(rtp_c, "") < 0) {
3122             rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3123             return;
3124         }
3125     }
3126
3127     /* test if stream is OK (test needed because several SETUP needs
3128        to be done for a given file) */
3129     if (rtp_c->stream != stream) {
3130         rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3131         return;
3132     }
3133
3134     /* test if stream is already set up */
3135     if (rtp_c->rtp_ctx[stream_index]) {
3136         rtsp_reply_error(c, RTSP_STATUS_STATE);
3137         return;
3138     }
3139
3140     /* check transport */
3141     th = find_transport(h, rtp_c->rtp_protocol);
3142     if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3143                 th->client_port_min <= 0)) {
3144         rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3145         return;
3146     }
3147
3148     /* setup default options */
3149     setup.transport_option[0] = '\0';
3150     dest_addr = rtp_c->from_addr;
3151     dest_addr.sin_port = htons(th->client_port_min);
3152
3153     /* setup stream */
3154     if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3155         rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3156         return;
3157     }
3158
3159     /* now everything is OK, so we can send the connection parameters */
3160     rtsp_reply_header(c, RTSP_STATUS_OK);
3161     /* session ID */
3162     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3163
3164     switch(rtp_c->rtp_protocol) {
3165     case RTSP_LOWER_TRANSPORT_UDP:
3166         rtp_port = rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3167         rtcp_port = rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3168         avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3169                     "client_port=%d-%d;server_port=%d-%d",
3170                     th->client_port_min, th->client_port_max,
3171                     rtp_port, rtcp_port);
3172         break;
3173     case RTSP_LOWER_TRANSPORT_TCP:
3174         avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3175                     stream_index * 2, stream_index * 2 + 1);
3176         break;
3177     default:
3178         break;
3179     }
3180     if (setup.transport_option[0] != '\0')
3181         avio_printf(c->pb, ";%s", setup.transport_option);
3182     avio_printf(c->pb, "\r\n");
3183
3184
3185     avio_printf(c->pb, "\r\n");
3186 }
3187
3188
3189 /* find an rtp connection by using the session ID. Check consistency
3190    with filename */
3191 static HTTPContext *find_rtp_session_with_url(const char *url,
3192                                               const char *session_id)
3193 {
3194     HTTPContext *rtp_c;
3195     char path1[1024];
3196     const char *path;
3197     char buf[1024];
3198     int s, len;
3199
3200     rtp_c = find_rtp_session(session_id);
3201     if (!rtp_c)
3202         return NULL;
3203
3204     /* find which url is asked */
3205     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3206     path = path1;
3207     if (*path == '/')
3208         path++;
3209     if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3210     for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3211       snprintf(buf, sizeof(buf), "%s/streamid=%d",
3212         rtp_c->stream->filename, s);
3213       if(!strncmp(path, buf, sizeof(buf))) {
3214     // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3215         return rtp_c;
3216       }
3217     }
3218     len = strlen(path);
3219     if (len > 0 && path[len - 1] == '/' &&
3220         !strncmp(path, rtp_c->stream->filename, len - 1))
3221         return rtp_c;
3222     return NULL;
3223 }
3224
3225 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3226 {
3227     HTTPContext *rtp_c;
3228
3229     rtp_c = find_rtp_session_with_url(url, h->session_id);
3230     if (!rtp_c) {
3231         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3232         return;
3233     }
3234
3235     if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3236         rtp_c->state != HTTPSTATE_WAIT_FEED &&
3237         rtp_c->state != HTTPSTATE_READY) {
3238         rtsp_reply_error(c, RTSP_STATUS_STATE);
3239         return;
3240     }
3241
3242     rtp_c->state = HTTPSTATE_SEND_DATA;
3243
3244     /* now everything is OK, so we can send the connection parameters */
3245     rtsp_reply_header(c, RTSP_STATUS_OK);
3246     /* session ID */
3247     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3248     avio_printf(c->pb, "\r\n");
3249 }
3250
3251 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3252 {
3253     HTTPContext *rtp_c;
3254
3255     rtp_c = find_rtp_session_with_url(url, h->session_id);
3256     if (!rtp_c) {
3257         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3258         return;
3259     }
3260
3261     if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3262         rtp_c->state != HTTPSTATE_WAIT_FEED) {
3263         rtsp_reply_error(c, RTSP_STATUS_STATE);
3264         return;
3265     }
3266
3267     rtp_c->state = HTTPSTATE_READY;
3268     rtp_c->first_pts = AV_NOPTS_VALUE;
3269     /* now everything is OK, so we can send the connection parameters */
3270     rtsp_reply_header(c, RTSP_STATUS_OK);
3271     /* session ID */
3272     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3273     avio_printf(c->pb, "\r\n");
3274 }
3275
3276 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3277 {
3278     HTTPContext *rtp_c;
3279     char session_id[32];
3280
3281     rtp_c = find_rtp_session_with_url(url, h->session_id);
3282     if (!rtp_c) {
3283         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3284         return;
3285     }
3286
3287     av_strlcpy(session_id, rtp_c->session_id, sizeof(session_id));
3288
3289     /* abort the session */
3290     close_connection(rtp_c);
3291
3292     /* now everything is OK, so we can send the connection parameters */
3293     rtsp_reply_header(c, RTSP_STATUS_OK);
3294     /* session ID */
3295     avio_printf(c->pb, "Session: %s\r\n", session_id);
3296     avio_printf(c->pb, "\r\n");
3297 }
3298
3299
3300 /********************************************************************/
3301 /* RTP handling */
3302
3303 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3304                                        FFStream *stream, const char *session_id,
3305                                        enum RTSPLowerTransport rtp_protocol)
3306 {
3307     HTTPContext *c = NULL;
3308     const char *proto_str;
3309
3310     /* XXX: should output a warning page when coming
3311        close to the connection limit */
3312     if (nb_connections >= nb_max_connections)
3313         goto fail;
3314
3315     /* add a new connection */
3316     c = av_mallocz(sizeof(HTTPContext));
3317     if (!c)
3318         goto fail;
3319
3320     c->fd = -1;
3321     c->poll_entry = NULL;
3322     c->from_addr = *from_addr;
3323     c->buffer_size = IOBUFFER_INIT_SIZE;
3324     c->buffer = av_malloc(c->buffer_size);
3325     if (!c->buffer)
3326         goto fail;
3327     nb_connections++;
3328     c->stream = stream;
3329     av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3330     c->state = HTTPSTATE_READY;
3331     c->is_packetized = 1;
3332     c->rtp_protocol = rtp_protocol;
3333
3334     /* protocol is shown in statistics */
3335     switch(c->rtp_protocol) {
3336     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3337         proto_str = "MCAST";
3338         break;
3339     case RTSP_LOWER_TRANSPORT_UDP:
3340         proto_str = "UDP";
3341         break;
3342     case RTSP_LOWER_TRANSPORT_TCP:
3343         proto_str = "TCP";
3344         break;
3345     default:
3346         proto_str = "???";
3347         break;
3348     }
3349     av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3350     av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3351
3352     current_bandwidth += stream->bandwidth;
3353
3354     c->next = first_http_ctx;
3355     first_http_ctx = c;
3356     return c;
3357
3358  fail:
3359     if (c) {
3360         av_free(c->buffer);
3361         av_free(c);
3362     }
3363     return NULL;
3364 }
3365
3366 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3367    command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3368    used. */
3369 static int rtp_new_av_stream(HTTPContext *c,
3370                              int stream_index, struct sockaddr_in *dest_addr,
3371                              HTTPContext *rtsp_c)
3372 {
3373     AVFormatContext *ctx;
3374     AVStream *st;
3375     char *ipaddr;
3376     URLContext *h = NULL;
3377     uint8_t *dummy_buf;
3378     int max_packet_size;
3379
3380     /* now we can open the relevant output stream */
3381     ctx = avformat_alloc_context();
3382     if (!ctx)
3383         return -1;
3384     ctx->oformat = av_guess_format("rtp", NULL, NULL);
3385
3386     st = av_mallocz(sizeof(AVStream));
3387     if (!st)
3388         goto fail;
3389     ctx->nb_streams = 1;
3390     ctx->streams[0] = st;
3391
3392     if (!c->stream->feed ||
3393         c->stream->feed == c->stream)
3394         memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3395     else
3396         memcpy(st,
3397                c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3398                sizeof(AVStream));
3399     st->priv_data = NULL;
3400
3401     /* build destination RTP address */
3402     ipaddr = inet_ntoa(dest_addr->sin_addr);
3403
3404     switch(c->rtp_protocol) {
3405     case RTSP_LOWER_TRANSPORT_UDP:
3406     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3407         /* RTP/UDP case */
3408
3409         /* XXX: also pass as parameter to function ? */
3410         if (c->stream->is_multicast) {
3411             int ttl;
3412             ttl = c->stream->multicast_ttl;
3413             if (!ttl)
3414                 ttl = 16;
3415             snprintf(ctx->filename, sizeof(ctx->filename),
3416                      "rtp://%s:%d?multicast=1&ttl=%d",
3417                      ipaddr, ntohs(dest_addr->sin_port), ttl);
3418         } else {
3419             snprintf(ctx->filename, sizeof(ctx->filename),
3420                      "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3421         }
3422
3423         if (url_open(&h, ctx->filename, AVIO_FLAG_WRITE) < 0)
3424             goto fail;
3425         c->rtp_handles[stream_index] = h;
3426         max_packet_size = url_get_max_packet_size(h);
3427         break;
3428     case RTSP_LOWER_TRANSPORT_TCP:
3429         /* RTP/TCP case */
3430         c->rtsp_c = rtsp_c;
3431         max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3432         break;
3433     default:
3434         goto fail;
3435     }
3436
3437     http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3438              ipaddr, ntohs(dest_addr->sin_port),
3439              c->stream->filename, stream_index, c->protocol);
3440
3441     /* normally, no packets should be output here, but the packet size may be checked */
3442     if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3443         /* XXX: close stream */
3444         goto fail;
3445     }
3446     av_set_parameters(ctx, NULL);
3447     if (av_write_header(ctx) < 0) {
3448     fail:
3449         if (h)
3450             url_close(h);
3451         av_free(ctx);
3452         return -1;
3453     }
3454     avio_close_dyn_buf(ctx->pb, &dummy_buf);
3455     av_free(dummy_buf);
3456
3457     c->rtp_ctx[stream_index] = ctx;
3458     return 0;
3459 }
3460
3461 /********************************************************************/
3462 /* ffserver initialization */
3463
3464 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3465 {
3466     AVStream *fst;
3467
3468     fst = av_mallocz(sizeof(AVStream));
3469     if (!fst)
3470         return NULL;
3471     if (copy) {
3472         fst->codec= avcodec_alloc_context();
3473         memcpy(fst->codec, codec, sizeof(AVCodecContext));
3474         if (codec->extradata_size) {
3475             fst->codec->extradata = av_malloc(codec->extradata_size);
3476             memcpy(fst->codec->extradata, codec->extradata,
3477                 codec->extradata_size);
3478         }
3479     } else {
3480         /* live streams must use the actual feed's codec since it may be
3481          * updated later to carry extradata needed by the streams.
3482          */
3483         fst->codec = codec;
3484     }
3485     fst->priv_data = av_mallocz(sizeof(FeedData));
3486     fst->index = stream->nb_streams;
3487     av_set_pts_info(fst, 33, 1, 90000);
3488     fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3489     stream->streams[stream->nb_streams++] = fst;
3490     return fst;
3491 }
3492
3493 /* return the stream number in the feed */
3494 static int add_av_stream(FFStream *feed, AVStream *st)
3495 {
3496     AVStream *fst;
3497     AVCodecContext *av, *av1;
3498     int i;
3499
3500     av = st->codec;
3501     for(i=0;i<feed->nb_streams;i++) {
3502         st = feed->streams[i];
3503         av1 = st->codec;
3504         if (av1->codec_id == av->codec_id &&
3505             av1->codec_type == av->codec_type &&
3506             av1->bit_rate == av->bit_rate) {
3507
3508             switch(av->codec_type) {
3509             case AVMEDIA_TYPE_AUDIO:
3510                 if (av1->channels == av->channels &&
3511                     av1->sample_rate == av->sample_rate)
3512                     goto found;
3513                 break;
3514             case AVMEDIA_TYPE_VIDEO:
3515                 if (av1->width == av->width &&
3516                     av1->height == av->height &&
3517                     av1->time_base.den == av->time_base.den &&
3518                     av1->time_base.num == av->time_base.num &&
3519                     av1->gop_size == av->gop_size)
3520                     goto found;
3521                 break;
3522             default:
3523                 abort();
3524             }
3525         }
3526     }
3527
3528     fst = add_av_stream1(feed, av, 0);
3529     if (!fst)
3530         return -1;
3531     return feed->nb_streams - 1;
3532  found:
3533     return i;
3534 }
3535
3536 static void remove_stream(FFStream *stream)
3537 {
3538     FFStream **ps;
3539     ps = &first_stream;
3540     while (*ps != NULL) {
3541         if (*ps == stream)
3542             *ps = (*ps)->next;
3543         else
3544             ps = &(*ps)->next;
3545     }
3546 }
3547
3548 /* specific mpeg4 handling : we extract the raw parameters */
3549 static void extract_mpeg4_header(AVFormatContext *infile)
3550 {
3551     int mpeg4_count, i, size;
3552     AVPacket pkt;
3553     AVStream *st;
3554     const uint8_t *p;
3555
3556     mpeg4_count = 0;
3557     for(i=0;i<infile->nb_streams;i++) {
3558         st = infile->streams[i];
3559         if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3560             st->codec->extradata_size == 0) {
3561             mpeg4_count++;
3562         }
3563     }
3564     if (!mpeg4_count)
3565         return;
3566
3567     printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3568     while (mpeg4_count > 0) {
3569         if (av_read_packet(infile, &pkt) < 0)
3570             break;
3571         st = infile->streams[pkt.stream_index];
3572         if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3573             st->codec->extradata_size == 0) {
3574             av_freep(&st->codec->extradata);
3575             /* fill extradata with the header */
3576             /* XXX: we make hard suppositions here ! */
3577             p = pkt.data;
3578             while (p < pkt.data + pkt.size - 4) {
3579                 /* stop when vop header is found */
3580                 if (p[0] == 0x00 && p[1] == 0x00 &&
3581                     p[2] == 0x01 && p[3] == 0xb6) {
3582                     size = p - pkt.data;
3583                     //                    av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3584                     st->codec->extradata = av_malloc(size);
3585                     st->codec->extradata_size = size;
3586                     memcpy(st->codec->extradata, pkt.data, size);
3587                     break;
3588                 }
3589                 p++;
3590             }
3591             mpeg4_count--;
3592         }
3593         av_free_packet(&pkt);
3594     }
3595 }
3596
3597 /* compute the needed AVStream for each file */
3598 static void build_file_streams(void)
3599 {
3600     FFStream *stream, *stream_next;
3601     AVFormatContext *infile;
3602     int i, ret;
3603
3604     /* gather all streams */
3605     for(stream = first_stream; stream != NULL; stream = stream_next) {
3606         stream_next = stream->next;
3607         if (stream->stream_type == STREAM_TYPE_LIVE &&
3608             !stream->feed) {
3609             /* the stream comes from a file */
3610             /* try to open the file */
3611             /* open stream */
3612             stream->ap_in = av_mallocz(sizeof(AVFormatParameters));
3613             if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3614                 /* specific case : if transport stream output to RTP,
3615                    we use a raw transport stream reader */
3616                 stream->ap_in->mpeg2ts_raw = 1;
3617                 stream->ap_in->mpeg2ts_compute_pcr = 1;
3618             }
3619
3620             http_log("Opening file '%s'\n", stream->feed_filename);
3621             if ((ret = av_open_input_file(&infile, stream->feed_filename,
3622                                           stream->ifmt, 0, stream->ap_in)) < 0) {
3623                 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3624                 /* remove stream (no need to spend more time on it) */
3625             fail:
3626                 remove_stream(stream);
3627             } else {
3628                 /* find all the AVStreams inside and reference them in
3629                    'stream' */
3630                 if (av_find_stream_info(infile) < 0) {
3631                     http_log("Could not find codec parameters from '%s'\n",
3632                              stream->feed_filename);
3633                     av_close_input_file(infile);
3634                     goto fail;
3635                 }
3636                 extract_mpeg4_header(infile);
3637
3638                 for(i=0;i<infile->nb_streams;i++)
3639                     add_av_stream1(stream, infile->streams[i]->codec, 1);
3640
3641                 av_close_input_file(infile);
3642             }
3643         }
3644     }
3645 }
3646
3647 /* compute the needed AVStream for each feed */
3648 static void build_feed_streams(void)
3649 {
3650     FFStream *stream, *feed;
3651     int i;
3652
3653     /* gather all streams */
3654     for(stream = first_stream; stream != NULL; stream = stream->next) {
3655         feed = stream->feed;
3656         if (feed) {
3657             if (!stream->is_feed) {
3658                 /* we handle a stream coming from a feed */
3659                 for(i=0;i<stream->nb_streams;i++)
3660                     stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3661             }
3662         }
3663     }
3664
3665     /* gather all streams */
3666     for(stream = first_stream; stream != NULL; stream = stream->next) {
3667         feed = stream->feed;
3668         if (feed) {
3669             if (stream->is_feed) {
3670                 for(i=0;i<stream->nb_streams;i++)
3671                     stream->feed_streams[i] = i;
3672             }
3673         }
3674     }
3675
3676     /* create feed files if needed */
3677     for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3678         int fd;
3679
3680         if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3681             /* See if it matches */
3682             AVFormatContext *s;
3683             int matches = 0;
3684
3685             if (av_open_input_file(&s, feed->feed_filename, NULL, FFM_PACKET_SIZE, NULL) >= 0) {
3686                 /* Now see if it matches */
3687                 if (s->nb_streams == feed->nb_streams) {
3688                     matches = 1;
3689                     for(i=0;i<s->nb_streams;i++) {
3690                         AVStream *sf, *ss;
3691                         sf = feed->streams[i];
3692                         ss = s->streams[i];
3693
3694                         if (sf->index != ss->index ||
3695                             sf->id != ss->id) {
3696                             http_log("Index & Id do not match for stream %d (%s)\n",
3697                                    i, feed->feed_filename);
3698                             matches = 0;
3699                         } else {
3700                             AVCodecContext *ccf, *ccs;
3701
3702                             ccf = sf->codec;
3703                             ccs = ss->codec;
3704 #define CHECK_CODEC(x)  (ccf->x != ccs->x)
3705
3706                             if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3707                                 http_log("Codecs do not match for stream %d\n", i);
3708                                 matches = 0;
3709                             } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3710                                 http_log("Codec bitrates do not match for stream %d\n", i);
3711                                 matches = 0;
3712                             } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3713                                 if (CHECK_CODEC(time_base.den) ||
3714                                     CHECK_CODEC(time_base.num) ||
3715                                     CHECK_CODEC(width) ||
3716                                     CHECK_CODEC(height)) {
3717                                     http_log("Codec width, height and framerate do not match for stream %d\n", i);
3718                                     matches = 0;
3719                                 }
3720                             } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3721                                 if (CHECK_CODEC(sample_rate) ||
3722                                     CHECK_CODEC(channels) ||
3723                                     CHECK_CODEC(frame_size)) {
3724                                     http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3725                                     matches = 0;
3726                                 }
3727                             } else {
3728                                 http_log("Unknown codec type\n");
3729                                 matches = 0;
3730                             }
3731                         }
3732                         if (!matches)
3733                             break;
3734                     }
3735                 } else
3736                     http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3737                         feed->feed_filename, s->nb_streams, feed->nb_streams);
3738
3739                 av_close_input_file(s);
3740             } else
3741                 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3742                         feed->feed_filename);
3743
3744             if (!matches) {
3745                 if (feed->readonly) {
3746                     http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3747                         feed->feed_filename);
3748                     exit(1);
3749                 }
3750                 unlink(feed->feed_filename);
3751             }
3752         }
3753         if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3754             AVFormatContext s1 = {0}, *s = &s1;
3755
3756             if (feed->readonly) {
3757                 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3758                     feed->feed_filename);
3759                 exit(1);
3760             }
3761
3762             /* only write the header of the ffm file */
3763             if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3764                 http_log("Could not open output feed file '%s'\n",
3765                          feed->feed_filename);
3766                 exit(1);
3767             }
3768             s->oformat = feed->fmt;
3769             s->nb_streams = feed->nb_streams;
3770             for(i=0;i<s->nb_streams;i++) {
3771                 AVStream *st;
3772                 st = feed->streams[i];
3773                 s->streams[i] = st;
3774             }
3775             av_set_parameters(s, NULL);
3776             if (av_write_header(s) < 0) {
3777                 http_log("Container doesn't supports the required parameters\n");
3778                 exit(1);
3779             }
3780             /* XXX: need better api */
3781             av_freep(&s->priv_data);
3782             avio_close(s->pb);
3783         }
3784         /* get feed size and write index */
3785         fd = open(feed->feed_filename, O_RDONLY);
3786         if (fd < 0) {
3787             http_log("Could not open output feed file '%s'\n",
3788                     feed->feed_filename);
3789             exit(1);
3790         }
3791
3792         feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3793         feed->feed_size = lseek(fd, 0, SEEK_END);
3794         /* ensure that we do not wrap before the end of file */
3795         if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3796             feed->feed_max_size = feed->feed_size;
3797
3798         close(fd);
3799     }
3800 }
3801
3802 /* compute the bandwidth used by each stream */
3803 static void compute_bandwidth(void)
3804 {
3805     unsigned bandwidth;
3806     int i;
3807     FFStream *stream;
3808
3809     for(stream = first_stream; stream != NULL; stream = stream->next) {
3810         bandwidth = 0;
3811         for(i=0;i<stream->nb_streams;i++) {
3812             AVStream *st = stream->streams[i];
3813             switch(st->codec->codec_type) {
3814             case AVMEDIA_TYPE_AUDIO:
3815             case AVMEDIA_TYPE_VIDEO:
3816                 bandwidth += st->codec->bit_rate;
3817                 break;
3818             default:
3819                 break;
3820             }
3821         }
3822         stream->bandwidth = (bandwidth + 999) / 1000;
3823     }
3824 }
3825
3826 /* add a codec and set the default parameters */
3827 static void add_codec(FFStream *stream, AVCodecContext *av)
3828 {
3829     AVStream *st;
3830
3831     /* compute default parameters */
3832     switch(av->codec_type) {
3833     case AVMEDIA_TYPE_AUDIO:
3834         if (av->bit_rate == 0)
3835             av->bit_rate = 64000;
3836         if (av->sample_rate == 0)
3837             av->sample_rate = 22050;
3838         if (av->channels == 0)
3839             av->channels = 1;
3840         break;
3841     case AVMEDIA_TYPE_VIDEO:
3842         if (av->bit_rate == 0)
3843             av->bit_rate = 64000;
3844         if (av->time_base.num == 0){
3845             av->time_base.den = 5;
3846             av->time_base.num = 1;
3847         }
3848         if (av->width == 0 || av->height == 0) {
3849             av->width = 160;
3850             av->height = 128;
3851         }
3852         /* Bitrate tolerance is less for streaming */
3853         if (av->bit_rate_tolerance == 0)
3854             av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3855                       (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3856         if (av->qmin == 0)
3857             av->qmin = 3;
3858         if (av->qmax == 0)
3859             av->qmax = 31;
3860         if (av->max_qdiff == 0)
3861             av->max_qdiff = 3;
3862         av->qcompress = 0.5;
3863         av->qblur = 0.5;
3864
3865         if (!av->nsse_weight)
3866             av->nsse_weight = 8;
3867
3868         av->frame_skip_cmp = FF_CMP_DCTMAX;
3869         if (!av->me_method)
3870             av->me_method = ME_EPZS;
3871         av->rc_buffer_aggressivity = 1.0;
3872
3873         if (!av->rc_eq)
3874             av->rc_eq = "tex^qComp";
3875         if (!av->i_quant_factor)
3876             av->i_quant_factor = -0.8;
3877         if (!av->b_quant_factor)
3878             av->b_quant_factor = 1.25;
3879         if (!av->b_quant_offset)
3880             av->b_quant_offset = 1.25;
3881         if (!av->rc_max_rate)
3882             av->rc_max_rate = av->bit_rate * 2;
3883
3884         if (av->rc_max_rate && !av->rc_buffer_size) {
3885             av->rc_buffer_size = av->rc_max_rate;
3886         }
3887
3888
3889         break;
3890     default:
3891         abort();
3892     }
3893
3894     st = av_mallocz(sizeof(AVStream));
3895     if (!st)
3896         return;
3897     st->codec = avcodec_alloc_context();
3898     stream->streams[stream->nb_streams++] = st;
3899     memcpy(st->codec, av, sizeof(AVCodecContext));
3900 }
3901
3902 static enum CodecID opt_audio_codec(const char *arg)
3903 {
3904     AVCodec *p= avcodec_find_encoder_by_name(arg);
3905
3906     if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3907         return CODEC_ID_NONE;
3908
3909     return p->id;
3910 }
3911
3912 static enum CodecID opt_video_codec(const char *arg)
3913 {
3914     AVCodec *p= avcodec_find_encoder_by_name(arg);
3915
3916     if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3917         return CODEC_ID_NONE;
3918
3919     return p->id;
3920 }
3921
3922 /* simplistic plugin support */
3923
3924 #if HAVE_DLOPEN
3925 static void load_module(const char *filename)
3926 {
3927     void *dll;
3928     void (*init_func)(void);
3929     dll = dlopen(filename, RTLD_NOW);
3930     if (!dll) {
3931         fprintf(stderr, "Could not load module '%s' - %s\n",
3932                 filename, dlerror());
3933         return;
3934     }
3935
3936     init_func = dlsym(dll, "ffserver_module_init");
3937     if (!init_func) {
3938         fprintf(stderr,
3939                 "%s: init function 'ffserver_module_init()' not found\n",
3940                 filename);
3941         dlclose(dll);
3942     }
3943
3944     init_func();
3945 }
3946 #endif
3947
3948 static int ffserver_opt_default(const char *opt, const char *arg,
3949                        AVCodecContext *avctx, int type)
3950 {
3951     int ret = 0;
3952     const AVOption *o = av_find_opt(avctx, opt, NULL, type, type);
3953     if(o)
3954         ret = av_set_string3(avctx, opt, arg, 1, NULL);
3955     return ret;
3956 }
3957
3958 static int ffserver_opt_preset(const char *arg,
3959                        AVCodecContext *avctx, int type,
3960                        enum CodecID *audio_id, enum CodecID *video_id)
3961 {
3962     FILE *f=NULL;
3963     char filename[1000], tmp[1000], tmp2[1000], line[1000];
3964     int ret = 0;
3965     AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3966
3967     if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3968                               codec ? codec->name : NULL))) {
3969         fprintf(stderr, "File for preset '%s' not found\n", arg);
3970         return 1;
3971     }
3972
3973     while(!feof(f)){
3974         int e= fscanf(f, "%999[^\n]\n", line) - 1;
3975         if(line[0] == '#' && !e)
3976             continue;
3977         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3978         if(e){
3979             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3980             ret = 1;
3981             break;
3982         }
3983         if(!strcmp(tmp, "acodec")){
3984             *audio_id = opt_audio_codec(tmp2);
3985         }else if(!strcmp(tmp, "vcodec")){
3986             *video_id = opt_video_codec(tmp2);
3987         }else if(!strcmp(tmp, "scodec")){
3988             /* opt_subtitle_codec(tmp2); */
3989         }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){
3990             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3991             ret = 1;
3992             break;
3993         }
3994     }
3995
3996     fclose(f);
3997
3998     return ret;
3999 }
4000
4001 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename,
4002                                              const char *mime_type)
4003 {
4004     AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
4005
4006     if (fmt) {
4007         AVOutputFormat *stream_fmt;
4008         char stream_format_name[64];
4009
4010         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
4011         stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
4012
4013         if (stream_fmt)
4014             fmt = stream_fmt;
4015     }
4016
4017     return fmt;
4018 }
4019
4020 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
4021 {
4022     va_list vl;
4023     va_start(vl, fmt);
4024     fprintf(stderr, "%s:%d: ", filename, line_num);
4025     vfprintf(stderr, fmt, vl);
4026     va_end(vl);
4027
4028     (*errors)++;
4029 }
4030
4031 static int parse_ffconfig(const char *filename)
4032 {
4033     FILE *f;
4034     char line[1024];
4035     char cmd[64];
4036     char arg[1024];
4037     const char *p;
4038     int val, errors, line_num;
4039     FFStream **last_stream, *stream, *redirect;
4040     FFStream **last_feed, *feed, *s;
4041     AVCodecContext audio_enc, video_enc;
4042     enum CodecID audio_id, video_id;
4043
4044     f = fopen(filename, "r");
4045     if (!f) {
4046         perror(filename);
4047         return -1;
4048     }
4049
4050     errors = 0;
4051     line_num = 0;
4052     first_stream = NULL;
4053     last_stream = &first_stream;
4054     first_feed = NULL;
4055     last_feed = &first_feed;
4056     stream = NULL;
4057     feed = NULL;
4058     redirect = NULL;
4059     audio_id = CODEC_ID_NONE;
4060     video_id = CODEC_ID_NONE;
4061
4062 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4063     for(;;) {
4064         if (fgets(line, sizeof(line), f) == NULL)
4065             break;
4066         line_num++;
4067         p = line;
4068         while (isspace(*p))
4069             p++;
4070         if (*p == '\0' || *p == '#')
4071             continue;
4072
4073         get_arg(cmd, sizeof(cmd), &p);
4074
4075         if (!strcasecmp(cmd, "Port")) {
4076             get_arg(arg, sizeof(arg), &p);
4077             val = atoi(arg);
4078             if (val < 1 || val > 65536) {
4079                 ERROR("Invalid_port: %s\n", arg);
4080             }
4081             my_http_addr.sin_port = htons(val);
4082         } else if (!strcasecmp(cmd, "BindAddress")) {
4083             get_arg(arg, sizeof(arg), &p);
4084             if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4085                 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4086             }
4087         } else if (!strcasecmp(cmd, "NoDaemon")) {
4088             ffserver_daemon = 0;
4089         } else if (!strcasecmp(cmd, "RTSPPort")) {
4090             get_arg(arg, sizeof(arg), &p);
4091             val = atoi(arg);
4092             if (val < 1 || val > 65536) {
4093                 ERROR("%s:%d: Invalid port: %s\n", arg);
4094             }
4095             my_rtsp_addr.sin_port = htons(atoi(arg));
4096         } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
4097             get_arg(arg, sizeof(arg), &p);
4098             if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4099                 ERROR("Invalid host/IP address: %s\n", arg);
4100             }
4101         } else if (!strcasecmp(cmd, "MaxHTTPConnections")) {
4102             get_arg(arg, sizeof(arg), &p);
4103             val = atoi(arg);
4104             if (val < 1 || val > 65536) {
4105                 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4106             }
4107             nb_max_http_connections = val;
4108         } else if (!strcasecmp(cmd, "MaxClients")) {
4109             get_arg(arg, sizeof(arg), &p);
4110             val = atoi(arg);
4111             if (val < 1 || val > nb_max_http_connections) {
4112                 ERROR("Invalid MaxClients: %s\n", arg);
4113             } else {
4114                 nb_max_connections = val;
4115             }
4116         } else if (!strcasecmp(cmd, "MaxBandwidth")) {
4117             int64_t llval;
4118             get_arg(arg, sizeof(arg), &p);
4119             llval = atoll(arg);
4120             if (llval < 10 || llval > 10000000) {
4121                 ERROR("Invalid MaxBandwidth: %s\n", arg);
4122             } else
4123                 max_bandwidth = llval;
4124         } else if (!strcasecmp(cmd, "CustomLog")) {
4125             if (!ffserver_debug)
4126                 get_arg(logfilename, sizeof(logfilename), &p);
4127         } else if (!strcasecmp(cmd, "<Feed")) {
4128             /*********************************************/
4129             /* Feed related options */
4130             char *q;
4131             if (stream || feed) {
4132                 ERROR("Already in a tag\n");
4133             } else {
4134                 feed = av_mallocz(sizeof(FFStream));
4135                 get_arg(feed->filename, sizeof(feed->filename), &p);
4136                 q = strrchr(feed->filename, '>');
4137                 if (*q)
4138                     *q = '\0';
4139
4140                 for (s = first_feed; s; s = s->next) {
4141                     if (!strcmp(feed->filename, s->filename)) {
4142                         ERROR("Feed '%s' already registered\n", s->filename);
4143                     }
4144                 }
4145
4146                 feed->fmt = av_guess_format("ffm", NULL, NULL);
4147                 /* defaut feed file */
4148                 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4149                          "/tmp/%s.ffm", feed->filename);
4150                 feed->feed_max_size = 5 * 1024 * 1024;
4151                 feed->is_feed = 1;
4152                 feed->feed = feed; /* self feeding :-) */
4153
4154                 /* add in stream list */
4155                 *last_stream = feed;
4156                 last_stream = &feed->next;
4157                 /* add in feed list */
4158                 *last_feed = feed;
4159                 last_feed = &feed->next_feed;
4160             }
4161         } else if (!strcasecmp(cmd, "Launch")) {
4162             if (feed) {
4163                 int i;
4164
4165                 feed->child_argv = av_mallocz(64 * sizeof(char *));
4166
4167                 for (i = 0; i < 62; i++) {
4168                     get_arg(arg, sizeof(arg), &p);
4169                     if (!arg[0])
4170                         break;
4171
4172                     feed->child_argv[i] = av_strdup(arg);
4173                 }
4174
4175                 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
4176
4177                 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
4178                     "http://%s:%d/%s",
4179                         (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4180                     inet_ntoa(my_http_addr.sin_addr),
4181                     ntohs(my_http_addr.sin_port), feed->filename);
4182             }
4183         } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
4184             if (feed) {
4185                 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4186                 feed->readonly = 1;
4187             } else if (stream) {
4188                 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4189             }
4190         } else if (!strcasecmp(cmd, "File")) {
4191             if (feed) {
4192                 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4193             } else if (stream)
4194                 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4195         } else if (!strcasecmp(cmd, "Truncate")) {
4196             if (feed) {
4197                 get_arg(arg, sizeof(arg), &p);
4198                 feed->truncate = strtod(arg, NULL);
4199             }
4200         } else if (!strcasecmp(cmd, "FileMaxSize")) {
4201             if (feed) {
4202                 char *p1;
4203                 double fsize;
4204
4205                 get_arg(arg, sizeof(arg), &p);
4206                 p1 = arg;
4207                 fsize = strtod(p1, &p1);
4208                 switch(toupper(*p1)) {
4209                 case 'K':
4210                     fsize *= 1024;
4211                     break;
4212                 case 'M':
4213                     fsize *= 1024 * 1024;
4214                     break;
4215                 case 'G':
4216                     fsize *= 1024 * 1024 * 1024;
4217                     break;
4218                 }
4219                 feed->feed_max_size = (int64_t)fsize;
4220                 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4221                     ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4222                 }
4223             }
4224         } else if (!strcasecmp(cmd, "</Feed>")) {
4225             if (!feed) {
4226                 ERROR("No corresponding <Feed> for </Feed>\n");
4227             }
4228             feed = NULL;
4229         } else if (!strcasecmp(cmd, "<Stream")) {
4230             /*********************************************/
4231             /* Stream related options */
4232             char *q;
4233             if (stream || feed) {
4234                 ERROR("Already in a tag\n");
4235             } else {
4236                 FFStream *s;
4237                 stream = av_mallocz(sizeof(FFStream));
4238                 get_arg(stream->filename, sizeof(stream->filename), &p);
4239                 q = strrchr(stream->filename, '>');
4240                 if (*q)
4241                     *q = '\0';
4242
4243                 for (s = first_stream; s; s = s->next) {
4244                     if (!strcmp(stream->filename, s->filename)) {
4245                         ERROR("Stream '%s' already registered\n", s->filename);
4246                     }
4247                 }
4248
4249                 stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);
4250                 avcodec_get_context_defaults2(&video_enc, AVMEDIA_TYPE_VIDEO);
4251                 avcodec_get_context_defaults2(&audio_enc, AVMEDIA_TYPE_AUDIO);
4252                 audio_id = CODEC_ID_NONE;
4253                 video_id = CODEC_ID_NONE;
4254                 if (stream->fmt) {
4255                     audio_id = stream->fmt->audio_codec;
4256                     video_id = stream->fmt->video_codec;
4257                 }
4258
4259                 *last_stream = stream;
4260                 last_stream = &stream->next;
4261             }
4262         } else if (!strcasecmp(cmd, "Feed")) {
4263             get_arg(arg, sizeof(arg), &p);
4264             if (stream) {
4265                 FFStream *sfeed;
4266
4267                 sfeed = first_feed;
4268                 while (sfeed != NULL) {
4269                     if (!strcmp(sfeed->filename, arg))
4270                         break;
4271                     sfeed = sfeed->next_feed;
4272                 }
4273                 if (!sfeed)
4274                     ERROR("feed '%s' not defined\n", arg);
4275                 else
4276                     stream->feed = sfeed;
4277             }
4278         } else if (!strcasecmp(cmd, "Format")) {
4279             get_arg(arg, sizeof(arg), &p);
4280             if (stream) {
4281                 if (!strcmp(arg, "status")) {
4282                     stream->stream_type = STREAM_TYPE_STATUS;
4283                     stream->fmt = NULL;
4284                 } else {
4285                     stream->stream_type = STREAM_TYPE_LIVE;
4286                     /* jpeg cannot be used here, so use single frame jpeg */
4287                     if (!strcmp(arg, "jpeg"))
4288                         strcpy(arg, "mjpeg");
4289                     stream->fmt = ffserver_guess_format(arg, NULL, NULL);
4290                     if (!stream->fmt) {
4291                         ERROR("Unknown Format: %s\n", arg);
4292                     }
4293                 }
4294                 if (stream->fmt) {
4295                     audio_id = stream->fmt->audio_codec;
4296                     video_id = stream->fmt->video_codec;
4297                 }
4298             }
4299         } else if (!strcasecmp(cmd, "InputFormat")) {
4300             get_arg(arg, sizeof(arg), &p);
4301             if (stream) {
4302                 stream->ifmt = av_find_input_format(arg);
4303                 if (!stream->ifmt) {
4304                     ERROR("Unknown input format: %s\n", arg);
4305                 }
4306             }
4307         } else if (!strcasecmp(cmd, "FaviconURL")) {
4308             if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4309                 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4310             } else {
4311                 ERROR("FaviconURL only permitted for status streams\n");
4312             }
4313         } else if (!strcasecmp(cmd, "Author")) {
4314             if (stream)
4315                 get_arg(stream->author, sizeof(stream->author), &p);
4316         } else if (!strcasecmp(cmd, "Comment")) {
4317             if (stream)
4318                 get_arg(stream->comment, sizeof(stream->comment), &p);
4319         } else if (!strcasecmp(cmd, "Copyright")) {
4320             if (stream)
4321                 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4322         } else if (!strcasecmp(cmd, "Title")) {
4323             if (stream)
4324                 get_arg(stream->title, sizeof(stream->title), &p);
4325         } else if (!strcasecmp(cmd, "Preroll")) {
4326             get_arg(arg, sizeof(arg), &p);
4327             if (stream)
4328                 stream->prebuffer = atof(arg) * 1000;
4329         } else if (!strcasecmp(cmd, "StartSendOnKey")) {
4330             if (stream)
4331                 stream->send_on_key = 1;
4332         } else if (!strcasecmp(cmd, "AudioCodec")) {
4333             get_arg(arg, sizeof(arg), &p);
4334             audio_id = opt_audio_codec(arg);
4335             if (audio_id == CODEC_ID_NONE) {
4336                 ERROR("Unknown AudioCodec: %s\n", arg);
4337             }
4338         } else if (!strcasecmp(cmd, "VideoCodec")) {
4339             get_arg(arg, sizeof(arg), &p);
4340             video_id = opt_video_codec(arg);
4341             if (video_id == CODEC_ID_NONE) {
4342                 ERROR("Unknown VideoCodec: %s\n", arg);
4343             }
4344         } else if (!strcasecmp(cmd, "MaxTime")) {
4345             get_arg(arg, sizeof(arg), &p);
4346             if (stream)
4347                 stream->max_time = atof(arg) * 1000;
4348         } else if (!strcasecmp(cmd, "AudioBitRate")) {
4349             get_arg(arg, sizeof(arg), &p);
4350             if (stream)
4351                 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4352         } else if (!strcasecmp(cmd, "AudioChannels")) {
4353             get_arg(arg, sizeof(arg), &p);
4354             if (stream)
4355                 audio_enc.channels = atoi(arg);
4356         } else if (!strcasecmp(cmd, "AudioSampleRate")) {
4357             get_arg(arg, sizeof(arg), &p);
4358             if (stream)
4359                 audio_enc.sample_rate = atoi(arg);
4360         } else if (!strcasecmp(cmd, "AudioQuality")) {
4361             get_arg(arg, sizeof(arg), &p);
4362             if (stream) {
4363 //                audio_enc.quality = atof(arg) * 1000;
4364             }
4365         } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
4366             if (stream) {
4367                 int minrate, maxrate;
4368
4369                 get_arg(arg, sizeof(arg), &p);
4370
4371                 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4372                     video_enc.rc_min_rate = minrate * 1000;
4373                     video_enc.rc_max_rate = maxrate * 1000;
4374                 } else {
4375                     ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4376                 }
4377             }
4378         } else if (!strcasecmp(cmd, "Debug")) {
4379             if (stream) {
4380                 get_arg(arg, sizeof(arg), &p);
4381                 video_enc.debug = strtol(arg,0,0);
4382             }
4383         } else if (!strcasecmp(cmd, "Strict")) {
4384             if (stream) {
4385                 get_arg(arg, sizeof(arg), &p);
4386                 video_enc.strict_std_compliance = atoi(arg);
4387             }
4388         } else if (!strcasecmp(cmd, "VideoBufferSize")) {
4389             if (stream) {
4390                 get_arg(arg, sizeof(arg), &p);
4391                 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4392             }
4393         } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
4394             if (stream) {
4395                 get_arg(arg, sizeof(arg), &p);
4396                 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4397             }
4398         } else if (!strcasecmp(cmd, "VideoBitRate")) {
4399             get_arg(arg, sizeof(arg), &p);
4400             if (stream) {
4401                 video_enc.bit_rate = atoi(arg) * 1000;
4402             }
4403         } else if (!strcasecmp(cmd, "VideoSize")) {
4404             get_arg(arg, sizeof(arg), &p);
4405             if (stream) {
4406                 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4407                 if ((video_enc.width % 16) != 0 ||
4408                     (video_enc.height % 16) != 0) {
4409                     ERROR("Image size must be a multiple of 16\n");
4410                 }
4411             }
4412         } else if (!strcasecmp(cmd, "VideoFrameRate")) {
4413             get_arg(arg, sizeof(arg), &p);
4414             if (stream) {
4415                 AVRational frame_rate;
4416                 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4417                     ERROR("Incorrect frame rate: %s\n", arg);
4418                 } else {
4419                     video_enc.time_base.num = frame_rate.den;
4420                     video_enc.time_base.den = frame_rate.num;
4421                 }
4422             }
4423         } else if (!strcasecmp(cmd, "VideoGopSize")) {
4424             get_arg(arg, sizeof(arg), &p);
4425             if (stream)
4426                 video_enc.gop_size = atoi(arg);
4427         } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
4428             if (stream)
4429                 video_enc.gop_size = 1;
4430         } else if (!strcasecmp(cmd, "VideoHighQuality")) {
4431             if (stream)
4432                 video_enc.mb_decision = FF_MB_DECISION_BITS;
4433         } else if (!strcasecmp(cmd, "Video4MotionVector")) {
4434             if (stream) {
4435                 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4436                 video_enc.flags |= CODEC_FLAG_4MV;
4437             }
4438         } else if (!strcasecmp(cmd, "AVOptionVideo") ||
4439                    !strcasecmp(cmd, "AVOptionAudio")) {
4440             char arg2[1024];
4441             AVCodecContext *avctx;
4442             int type;
4443             get_arg(arg, sizeof(arg), &p);
4444             get_arg(arg2, sizeof(arg2), &p);
4445             if (!strcasecmp(cmd, "AVOptionVideo")) {
4446                 avctx = &video_enc;
4447                 type = AV_OPT_FLAG_VIDEO_PARAM;
4448             } else {
4449                 avctx = &audio_enc;
4450                 type = AV_OPT_FLAG_AUDIO_PARAM;
4451             }
4452             if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4453                 ERROR("AVOption error: %s %s\n", arg, arg2);
4454             }
4455         } else if (!strcasecmp(cmd, "AVPresetVideo") ||
4456                    !strcasecmp(cmd, "AVPresetAudio")) {
4457             AVCodecContext *avctx;
4458             int type;
4459             get_arg(arg, sizeof(arg), &p);
4460             if (!strcasecmp(cmd, "AVPresetVideo")) {
4461                 avctx = &video_enc;
4462                 video_enc.codec_id = video_id;
4463                 type = AV_OPT_FLAG_VIDEO_PARAM;
4464             } else {
4465                 avctx = &audio_enc;
4466                 audio_enc.codec_id = audio_id;
4467                 type = AV_OPT_FLAG_AUDIO_PARAM;
4468             }
4469             if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4470                 ERROR("AVPreset error: %s\n", arg);
4471             }
4472         } else if (!strcasecmp(cmd, "VideoTag")) {
4473             get_arg(arg, sizeof(arg), &p);
4474             if ((strlen(arg) == 4) && stream)
4475                 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4476         } else if (!strcasecmp(cmd, "BitExact")) {
4477             if (stream)
4478                 video_enc.flags |= CODEC_FLAG_BITEXACT;
4479         } else if (!strcasecmp(cmd, "DctFastint")) {
4480             if (stream)
4481                 video_enc.dct_algo  = FF_DCT_FASTINT;
4482         } else if (!strcasecmp(cmd, "IdctSimple")) {
4483             if (stream)
4484                 video_enc.idct_algo = FF_IDCT_SIMPLE;
4485         } else if (!strcasecmp(cmd, "Qscale")) {
4486             get_arg(arg, sizeof(arg), &p);
4487             if (stream) {
4488                 video_enc.flags |= CODEC_FLAG_QSCALE;
4489                 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4490             }
4491         } else if (!strcasecmp(cmd, "VideoQDiff")) {
4492             get_arg(arg, sizeof(arg), &p);
4493             if (stream) {
4494                 video_enc.max_qdiff = atoi(arg);
4495                 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4496                     ERROR("VideoQDiff out of range\n");
4497                 }
4498             }
4499         } else if (!strcasecmp(cmd, "VideoQMax")) {
4500             get_arg(arg, sizeof(arg), &p);
4501             if (stream) {
4502                 video_enc.qmax = atoi(arg);
4503                 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4504                     ERROR("VideoQMax out of range\n");
4505                 }
4506             }
4507         } else if (!strcasecmp(cmd, "VideoQMin")) {
4508             get_arg(arg, sizeof(arg), &p);
4509             if (stream) {
4510                 video_enc.qmin = atoi(arg);
4511                 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4512                     ERROR("VideoQMin out of range\n");
4513                 }
4514             }
4515         } else if (!strcasecmp(cmd, "LumaElim")) {
4516             get_arg(arg, sizeof(arg), &p);
4517             if (stream)
4518                 video_enc.luma_elim_threshold = atoi(arg);
4519         } else if (!strcasecmp(cmd, "ChromaElim")) {
4520             get_arg(arg, sizeof(arg), &p);
4521             if (stream)
4522                 video_enc.chroma_elim_threshold = atoi(arg);
4523         } else if (!strcasecmp(cmd, "LumiMask")) {
4524             get_arg(arg, sizeof(arg), &p);
4525             if (stream)
4526                 video_enc.lumi_masking = atof(arg);
4527         } else if (!strcasecmp(cmd, "DarkMask")) {
4528             get_arg(arg, sizeof(arg), &p);
4529             if (stream)
4530                 video_enc.dark_masking = atof(arg);
4531         } else if (!strcasecmp(cmd, "NoVideo")) {
4532             video_id = CODEC_ID_NONE;
4533         } else if (!strcasecmp(cmd, "NoAudio")) {
4534             audio_id = CODEC_ID_NONE;
4535         } else if (!strcasecmp(cmd, "ACL")) {
4536             parse_acl_row(stream, feed, NULL, p, filename, line_num);
4537         } else if (!strcasecmp(cmd, "DynamicACL")) {
4538             if (stream) {
4539                 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4540             }
4541         } else if (!strcasecmp(cmd, "RTSPOption")) {
4542             get_arg(arg, sizeof(arg), &p);
4543             if (stream) {
4544                 av_freep(&stream->rtsp_option);
4545                 stream->rtsp_option = av_strdup(arg);
4546             }
4547         } else if (!strcasecmp(cmd, "MulticastAddress")) {
4548             get_arg(arg, sizeof(arg), &p);
4549             if (stream) {
4550                 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4551                     ERROR("Invalid host/IP address: %s\n", arg);
4552                 }
4553                 stream->is_multicast = 1;
4554                 stream->loop = 1; /* default is looping */
4555             }
4556         } else if (!strcasecmp(cmd, "MulticastPort")) {
4557             get_arg(arg, sizeof(arg), &p);
4558             if (stream)
4559                 stream->multicast_port = atoi(arg);
4560         } else if (!strcasecmp(cmd, "MulticastTTL")) {
4561             get_arg(arg, sizeof(arg), &p);
4562             if (stream)
4563                 stream->multicast_ttl = atoi(arg);
4564         } else if (!strcasecmp(cmd, "NoLoop")) {
4565             if (stream)
4566                 stream->loop = 0;
4567         } else if (!strcasecmp(cmd, "</Stream>")) {
4568             if (!stream) {
4569                 ERROR("No corresponding <Stream> for </Stream>\n");
4570             } else {
4571                 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4572                     if (audio_id != CODEC_ID_NONE) {
4573                         audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4574                         audio_enc.codec_id = audio_id;
4575                         add_codec(stream, &audio_enc);
4576                     }
4577                     if (video_id != CODEC_ID_NONE) {
4578                         video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4579                         video_enc.codec_id = video_id;
4580                         add_codec(stream, &video_enc);
4581                     }
4582                 }
4583                 stream = NULL;
4584             }
4585         } else if (!strcasecmp(cmd, "<Redirect")) {
4586             /*********************************************/
4587             char *q;
4588             if (stream || feed || redirect) {
4589                 ERROR("Already in a tag\n");
4590             } else {
4591                 redirect = av_mallocz(sizeof(FFStream));
4592                 *last_stream = redirect;
4593                 last_stream = &redirect->next;
4594
4595                 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4596                 q = strrchr(redirect->filename, '>');
4597                 if (*q)
4598                     *q = '\0';
4599                 redirect->stream_type = STREAM_TYPE_REDIRECT;
4600             }
4601         } else if (!strcasecmp(cmd, "URL")) {
4602             if (redirect)
4603                 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4604         } else if (!strcasecmp(cmd, "</Redirect>")) {
4605             if (!redirect) {
4606                 ERROR("No corresponding <Redirect> for </Redirect>\n");
4607             } else {
4608                 if (!redirect->feed_filename[0]) {
4609                     ERROR("No URL found for <Redirect>\n");
4610                 }
4611                 redirect = NULL;
4612             }
4613         } else if (!strcasecmp(cmd, "LoadModule")) {
4614             get_arg(arg, sizeof(arg), &p);
4615 #if HAVE_DLOPEN
4616             load_module(arg);
4617 #else
4618             ERROR("Module support not compiled into this version: '%s'\n", arg);
4619 #endif
4620         } else {
4621             ERROR("Incorrect keyword: '%s'\n", cmd);
4622         }
4623     }
4624 #undef ERROR
4625
4626     fclose(f);
4627     if (errors)
4628         return -1;
4629     else
4630         return 0;
4631 }
4632
4633 static void handle_child_exit(int sig)
4634 {
4635     pid_t pid;
4636     int status;
4637
4638     while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4639         FFStream *feed;
4640
4641         for (feed = first_feed; feed; feed = feed->next) {
4642             if (feed->pid == pid) {
4643                 int uptime = time(0) - feed->pid_start;
4644
4645                 feed->pid = 0;
4646                 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4647
4648                 if (uptime < 30)
4649                     /* Turn off any more restarts */
4650                     feed->child_argv = 0;
4651             }
4652         }
4653     }
4654
4655     need_to_start_children = 1;
4656 }
4657
4658 static void opt_debug(void)
4659 {
4660     ffserver_debug = 1;
4661     ffserver_daemon = 0;
4662     logfilename[0] = '-';
4663 }
4664
4665 static void show_help(void)
4666 {
4667     printf("usage: ffserver [options]\n"
4668            "Hyper fast multi format Audio/Video streaming server\n");
4669     printf("\n");
4670     show_help_options(options, "Main options:\n", 0, 0);
4671 }
4672
4673 static const OptionDef options[] = {
4674 #include "cmdutils_common_opts.h"
4675     { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4676     { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4677     { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4678     { NULL },
4679 };
4680
4681 int main(int argc, char **argv)
4682 {
4683     struct sigaction sigact;
4684
4685     av_register_all();
4686
4687     show_banner();
4688
4689     my_program_name = argv[0];
4690     my_program_dir = getcwd(0, 0);
4691     ffserver_daemon = 1;
4692
4693     parse_options(argc, argv, options, NULL);
4694
4695     unsetenv("http_proxy");             /* Kill the http_proxy */
4696
4697     av_lfg_init(&random_state, av_get_random_seed());
4698
4699     memset(&sigact, 0, sizeof(sigact));
4700     sigact.sa_handler = handle_child_exit;
4701     sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4702     sigaction(SIGCHLD, &sigact, 0);
4703
4704     if (parse_ffconfig(config_filename) < 0) {
4705         fprintf(stderr, "Incorrect config file - exiting.\n");
4706         exit(1);
4707     }
4708
4709     /* open log file if needed */
4710     if (logfilename[0] != '\0') {
4711         if (!strcmp(logfilename, "-"))
4712             logfile = stdout;
4713         else
4714             logfile = fopen(logfilename, "a");
4715         av_log_set_callback(http_av_log);
4716     }
4717
4718     build_file_streams();
4719
4720     build_feed_streams();
4721
4722     compute_bandwidth();
4723
4724     /* put the process in background and detach it from its TTY */
4725     if (ffserver_daemon) {
4726         int pid;
4727
4728         pid = fork();
4729         if (pid < 0) {
4730             perror("fork");
4731             exit(1);
4732         } else if (pid > 0) {
4733             /* parent : exit */
4734             exit(0);
4735         } else {
4736             /* child */
4737             setsid();
4738             close(0);
4739             open("/dev/null", O_RDWR);
4740             if (strcmp(logfilename, "-") != 0) {
4741                 close(1);
4742                 dup(0);
4743             }
4744             close(2);
4745             dup(0);
4746         }
4747     }
4748
4749     /* signal init */
4750     signal(SIGPIPE, SIG_IGN);
4751
4752     if (ffserver_daemon)
4753         chdir("/");
4754
4755     if (http_server() < 0) {
4756         http_log("Could not start server\n");
4757         exit(1);
4758     }
4759
4760     return 0;
4761 }