06bcb2dba8d0781c3a2b718f64a2f105ae5fbe60
[ffmpeg.git] / ffserver.c
1 /*
2  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * multiple format streaming server based on the FFmpeg libraries
24  */
25
26 #include "config.h"
27 #if !HAVE_CLOSESOCKET
28 #define closesocket close
29 #endif
30 #include <string.h>
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include "libavformat/avformat.h"
34 // FIXME those are internal headers, ffserver _really_ shouldn't use them
35 #include "libavformat/ffm.h"
36 #include "libavformat/network.h"
37 #include "libavformat/os_support.h"
38 #include "libavformat/rtpdec.h"
39 #include "libavformat/rtpproto.h"
40 #include "libavformat/rtsp.h"
41 #include "libavformat/rtspcodes.h"
42 #include "libavformat/avio_internal.h"
43 #include "libavformat/internal.h"
44 #include "libavformat/url.h"
45
46 #include "libavutil/avassert.h"
47 #include "libavutil/avstring.h"
48 #include "libavutil/lfg.h"
49 #include "libavutil/dict.h"
50 #include "libavutil/intreadwrite.h"
51 #include "libavutil/mathematics.h"
52 #include "libavutil/random_seed.h"
53 #include "libavutil/parseutils.h"
54 #include "libavutil/opt.h"
55 #include "libavutil/time.h"
56
57 #include <stdarg.h>
58 #if HAVE_UNISTD_H
59 #include <unistd.h>
60 #endif
61 #include <fcntl.h>
62 #include <sys/ioctl.h>
63 #if HAVE_POLL_H
64 #include <poll.h>
65 #endif
66 #include <errno.h>
67 #include <time.h>
68 #include <sys/wait.h>
69 #include <signal.h>
70
71 #include "cmdutils.h"
72 #include "ffserver_config.h"
73
74 const char program_name[] = "ffserver";
75 const int program_birth_year = 2000;
76
77 static const OptionDef options[];
78
79 enum HTTPState {
80     HTTPSTATE_WAIT_REQUEST,
81     HTTPSTATE_SEND_HEADER,
82     HTTPSTATE_SEND_DATA_HEADER,
83     HTTPSTATE_SEND_DATA,          /* sending TCP or UDP data */
84     HTTPSTATE_SEND_DATA_TRAILER,
85     HTTPSTATE_RECEIVE_DATA,
86     HTTPSTATE_WAIT_FEED,          /* wait for data from the feed */
87     HTTPSTATE_READY,
88
89     RTSPSTATE_WAIT_REQUEST,
90     RTSPSTATE_SEND_REPLY,
91     RTSPSTATE_SEND_PACKET,
92 };
93
94 static const char * const http_state[] = {
95     "HTTP_WAIT_REQUEST",
96     "HTTP_SEND_HEADER",
97
98     "SEND_DATA_HEADER",
99     "SEND_DATA",
100     "SEND_DATA_TRAILER",
101     "RECEIVE_DATA",
102     "WAIT_FEED",
103     "READY",
104
105     "RTSP_WAIT_REQUEST",
106     "RTSP_SEND_REPLY",
107     "RTSP_SEND_PACKET",
108 };
109
110 #define IOBUFFER_INIT_SIZE 8192
111
112 /* timeouts are in ms */
113 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
114 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
115
116 #define SYNC_TIMEOUT (10 * 1000)
117
118 typedef struct RTSPActionServerSetup {
119     uint32_t ipaddr;
120     char transport_option[512];
121 } RTSPActionServerSetup;
122
123 typedef struct {
124     int64_t count1, count2;
125     int64_t time1, time2;
126 } DataRateData;
127
128 /* context associated with one connection */
129 typedef struct HTTPContext {
130     enum HTTPState state;
131     int fd; /* socket file descriptor */
132     struct sockaddr_in from_addr; /* origin */
133     struct pollfd *poll_entry; /* used when polling */
134     int64_t timeout;
135     uint8_t *buffer_ptr, *buffer_end;
136     int http_error;
137     int post;
138     int chunked_encoding;
139     int chunk_size;               /* 0 if it needs to be read */
140     struct HTTPContext *next;
141     int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
142     int64_t data_count;
143     /* feed input */
144     int feed_fd;
145     /* input format handling */
146     AVFormatContext *fmt_in;
147     int64_t start_time;            /* In milliseconds - this wraps fairly often */
148     int64_t first_pts;            /* initial pts value */
149     int64_t cur_pts;             /* current pts value from the stream in us */
150     int64_t cur_frame_duration;  /* duration of the current frame in us */
151     int cur_frame_bytes;       /* output frame size, needed to compute
152                                   the time at which we send each
153                                   packet */
154     int pts_stream_index;        /* stream we choose as clock reference */
155     int64_t cur_clock;           /* current clock reference value in us */
156     /* output format handling */
157     struct FFServerStream *stream;
158     /* -1 is invalid stream */
159     int feed_streams[FFSERVER_MAX_STREAMS]; /* index of streams in the feed */
160     int switch_feed_streams[FFSERVER_MAX_STREAMS]; /* index of streams in the feed */
161     int switch_pending;
162     AVFormatContext fmt_ctx; /* instance of FFServerStream for one user */
163     int last_packet_sent; /* true if last data packet was sent */
164     int suppress_log;
165     DataRateData datarate;
166     int wmp_client_id;
167     char protocol[16];
168     char method[16];
169     char url[128];
170     int buffer_size;
171     uint8_t *buffer;
172     int is_packetized; /* if true, the stream is packetized */
173     int packet_stream_index; /* current stream for output in state machine */
174
175     /* RTSP state specific */
176     uint8_t *pb_buffer; /* XXX: use that in all the code */
177     AVIOContext *pb;
178     int seq; /* RTSP sequence number */
179
180     /* RTP state specific */
181     enum RTSPLowerTransport rtp_protocol;
182     char session_id[32]; /* session id */
183     AVFormatContext *rtp_ctx[FFSERVER_MAX_STREAMS];
184
185     /* RTP/UDP specific */
186     URLContext *rtp_handles[FFSERVER_MAX_STREAMS];
187
188     /* RTP/TCP specific */
189     struct HTTPContext *rtsp_c;
190     uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
191 } HTTPContext;
192
193 typedef struct FeedData {
194     long long data_count;
195     float avg_frame_size;   /* frame size averaged over last frames with exponential mean */
196 } FeedData;
197
198 static HTTPContext *first_http_ctx;
199
200 static FFServerConfig config = {
201     .nb_max_http_connections = 2000,
202     .nb_max_connections = 5,
203     .max_bandwidth = 1000,
204     .use_defaults = 1,
205 };
206
207 static void new_connection(int server_fd, int is_rtsp);
208 static void close_connection(HTTPContext *c);
209
210 /* HTTP handling */
211 static int handle_connection(HTTPContext *c);
212 static int http_parse_request(HTTPContext *c);
213 static int http_send_data(HTTPContext *c);
214 static void compute_status(HTTPContext *c);
215 static int open_input_stream(HTTPContext *c, const char *info);
216 static int http_start_receive_data(HTTPContext *c);
217 static int http_receive_data(HTTPContext *c);
218
219 /* RTSP handling */
220 static int rtsp_parse_request(HTTPContext *c);
221 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
222 static void rtsp_cmd_options(HTTPContext *c, const char *url);
223 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
224                            RTSPMessageHeader *h);
225 static void rtsp_cmd_play(HTTPContext *c, const char *url,
226                           RTSPMessageHeader *h);
227 static void rtsp_cmd_interrupt(HTTPContext *c, const char *url,
228                                RTSPMessageHeader *h, int pause_only);
229
230 /* SDP handling */
231 static int prepare_sdp_description(FFServerStream *stream, uint8_t **pbuffer,
232                                    struct in_addr my_ip);
233
234 /* RTP handling */
235 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
236                                        FFServerStream *stream,
237                                        const char *session_id,
238                                        enum RTSPLowerTransport rtp_protocol);
239 static int rtp_new_av_stream(HTTPContext *c,
240                              int stream_index, struct sockaddr_in *dest_addr,
241                              HTTPContext *rtsp_c);
242
243 static const char *my_program_name;
244
245 static int no_launch;
246 static int need_to_start_children;
247
248 /* maximum number of simultaneous HTTP connections */
249 static unsigned int nb_connections;
250
251 static uint64_t current_bandwidth;
252
253 static int64_t cur_time;           // Making this global saves on passing it around everywhere
254
255 static AVLFG random_state;
256
257 static FILE *logfile = NULL;
258
259 static void htmlstrip(char *s) {
260     while (s && *s) {
261         s += strspn(s, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,. ");
262         if (*s)
263             *s++ = '?';
264     }
265 }
266
267 static int64_t ffm_read_write_index(int fd)
268 {
269     uint8_t buf[8];
270
271     if (lseek(fd, 8, SEEK_SET) < 0)
272         return AVERROR(EIO);
273     if (read(fd, buf, 8) != 8)
274         return AVERROR(EIO);
275     return AV_RB64(buf);
276 }
277
278 static int ffm_write_write_index(int fd, int64_t pos)
279 {
280     uint8_t buf[8];
281     int i;
282
283     for(i=0;i<8;i++)
284         buf[i] = (pos >> (56 - i * 8)) & 0xff;
285     if (lseek(fd, 8, SEEK_SET) < 0)
286         return AVERROR(EIO);
287     if (write(fd, buf, 8) != 8)
288         return AVERROR(EIO);
289     return 8;
290 }
291
292 static void ffm_set_write_index(AVFormatContext *s, int64_t pos,
293                                 int64_t file_size)
294 {
295     FFMContext *ffm = s->priv_data;
296     ffm->write_index = pos;
297     ffm->file_size = file_size;
298 }
299
300 static char *ctime1(char *buf2, int buf_size)
301 {
302     time_t ti;
303     char *p;
304
305     ti = time(NULL);
306     p = ctime(&ti);
307     av_strlcpy(buf2, p, buf_size);
308     p = buf2 + strlen(p) - 1;
309     if (*p == '\n')
310         *p = '\0';
311     return buf2;
312 }
313
314 static void http_vlog(const char *fmt, va_list vargs)
315 {
316     static int print_prefix = 1;
317
318     if (!logfile)
319         return;
320
321     if (print_prefix) {
322         char buf[32];
323         ctime1(buf, sizeof(buf));
324         fprintf(logfile, "%s ", buf);
325     }
326     print_prefix = strstr(fmt, "\n") != NULL;
327     vfprintf(logfile, fmt, vargs);
328     fflush(logfile);
329 }
330
331 #ifdef __GNUC__
332 __attribute__ ((format (printf, 1, 2)))
333 #endif
334 static void http_log(const char *fmt, ...)
335 {
336     va_list vargs;
337     va_start(vargs, fmt);
338     http_vlog(fmt, vargs);
339     va_end(vargs);
340 }
341
342 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
343 {
344     static int print_prefix = 1;
345     AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
346     if (level > av_log_get_level())
347         return;
348     if (print_prefix && avc)
349         http_log("[%s @ %p]", avc->item_name(ptr), ptr);
350     print_prefix = strstr(fmt, "\n") != NULL;
351     http_vlog(fmt, vargs);
352 }
353
354 static void log_connection(HTTPContext *c)
355 {
356     if (c->suppress_log)
357         return;
358
359     http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
360              inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
361              c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
362 }
363
364 static void update_datarate(DataRateData *drd, int64_t count)
365 {
366     if (!drd->time1 && !drd->count1) {
367         drd->time1 = drd->time2 = cur_time;
368         drd->count1 = drd->count2 = count;
369     } else if (cur_time - drd->time2 > 5000) {
370         drd->time1 = drd->time2;
371         drd->count1 = drd->count2;
372         drd->time2 = cur_time;
373         drd->count2 = count;
374     }
375 }
376
377 /* In bytes per second */
378 static int compute_datarate(DataRateData *drd, int64_t count)
379 {
380     if (cur_time == drd->time1)
381         return 0;
382
383     return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
384 }
385
386
387 static void start_children(FFServerStream *feed)
388 {
389     char pathname[1024];
390     char *slash;
391     int i;
392
393     if (no_launch)
394         return;
395
396    /* replace "ffserver" with "ffmpeg" in the path of current
397     * program. Ignore user provided path */
398     av_strlcpy(pathname, my_program_name, sizeof(pathname));
399
400     slash = strrchr(pathname, '/');
401     if (!slash)
402         slash = pathname;
403     else
404         slash++;
405     strcpy(slash, "ffmpeg");
406
407     for (; feed; feed = feed->next) {
408
409         if (!feed->child_argv || feed->pid)
410             continue;
411
412         feed->pid_start = time(0);
413
414         feed->pid = fork();
415         if (feed->pid < 0) {
416             http_log("Unable to create children\n");
417             exit(1);
418         }
419
420         if (feed->pid)
421             continue;
422
423         /* In child */
424
425         http_log("Launch command line: ");
426         http_log("%s ", pathname);
427
428         for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
429             http_log("%s ", feed->child_argv[i]);
430         http_log("\n");
431
432         for (i = 3; i < 256; i++)
433             close(i);
434
435         if (!config.debug) {
436             if (!freopen("/dev/null", "r", stdin))
437                 http_log("failed to redirect STDIN to /dev/null\n;");
438             if (!freopen("/dev/null", "w", stdout))
439                 http_log("failed to redirect STDOUT to /dev/null\n;");
440             if (!freopen("/dev/null", "w", stderr))
441                 http_log("failed to redirect STDERR to /dev/null\n;");
442         }
443
444         signal(SIGPIPE, SIG_DFL);
445         execvp(pathname, feed->child_argv);
446         _exit(1);
447     }
448 }
449
450 /* open a listening socket */
451 static int socket_open_listen(struct sockaddr_in *my_addr)
452 {
453     int server_fd, tmp;
454
455     server_fd = socket(AF_INET,SOCK_STREAM,0);
456     if (server_fd < 0) {
457         perror ("socket");
458         return -1;
459     }
460
461     tmp = 1;
462     if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp)))
463         av_log(NULL, AV_LOG_WARNING, "setsockopt SO_REUSEADDR failed\n");
464
465     my_addr->sin_family = AF_INET;
466     if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
467         char bindmsg[32];
468         snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
469         perror (bindmsg);
470         closesocket(server_fd);
471         return -1;
472     }
473
474     if (listen (server_fd, 5) < 0) {
475         perror ("listen");
476         closesocket(server_fd);
477         return -1;
478     }
479
480     if (ff_socket_nonblock(server_fd, 1) < 0)
481         av_log(NULL, AV_LOG_WARNING, "ff_socket_nonblock failed\n");
482
483     return server_fd;
484 }
485
486 /* start all multicast streams */
487 static void start_multicast(void)
488 {
489     FFServerStream *stream;
490     char session_id[32];
491     HTTPContext *rtp_c;
492     struct sockaddr_in dest_addr = {0};
493     int default_port, stream_index;
494     unsigned int random0, random1;
495
496     default_port = 6000;
497     for(stream = config.first_stream; stream; stream = stream->next) {
498
499         if (!stream->is_multicast)
500             continue;
501
502         random0 = av_lfg_get(&random_state);
503         random1 = av_lfg_get(&random_state);
504
505         /* open the RTP connection */
506         snprintf(session_id, sizeof(session_id), "%08x%08x",
507                  random0, random1);
508
509         /* choose a port if none given */
510         if (stream->multicast_port == 0) {
511             stream->multicast_port = default_port;
512             default_port += 100;
513         }
514
515         dest_addr.sin_family = AF_INET;
516         dest_addr.sin_addr = stream->multicast_ip;
517         dest_addr.sin_port = htons(stream->multicast_port);
518
519         rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
520                                    RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
521         if (!rtp_c)
522             continue;
523
524         if (open_input_stream(rtp_c, "") < 0) {
525             http_log("Could not open input stream for stream '%s'\n",
526                      stream->filename);
527             continue;
528         }
529
530         /* open each RTP stream */
531         for(stream_index = 0; stream_index < stream->nb_streams;
532             stream_index++) {
533             dest_addr.sin_port = htons(stream->multicast_port +
534                                        2 * stream_index);
535             if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) >= 0)
536                 continue;
537
538             http_log("Could not open output stream '%s/streamid=%d'\n",
539                      stream->filename, stream_index);
540             exit(1);
541         }
542
543         rtp_c->state = HTTPSTATE_SEND_DATA;
544     }
545 }
546
547 /* main loop of the HTTP server */
548 static int http_server(void)
549 {
550     int server_fd = 0, rtsp_server_fd = 0;
551     int ret, delay;
552     struct pollfd *poll_table, *poll_entry;
553     HTTPContext *c, *c_next;
554
555     poll_table = av_mallocz_array(config.nb_max_http_connections + 2,
556                                   sizeof(*poll_table));
557     if(!poll_table) {
558         http_log("Impossible to allocate a poll table handling %d "
559                  "connections.\n", config.nb_max_http_connections);
560         return -1;
561     }
562
563     if (config.http_addr.sin_port) {
564         server_fd = socket_open_listen(&config.http_addr);
565         if (server_fd < 0) {
566             av_free(poll_table);
567             return -1;
568         }
569     }
570
571     if (config.rtsp_addr.sin_port) {
572         rtsp_server_fd = socket_open_listen(&config.rtsp_addr);
573         if (rtsp_server_fd < 0) {
574             av_free(poll_table);
575             closesocket(server_fd);
576             return -1;
577         }
578     }
579
580     if (!rtsp_server_fd && !server_fd) {
581         http_log("HTTP and RTSP disabled.\n");
582         av_free(poll_table);
583         return -1;
584     }
585
586     http_log("FFserver started.\n");
587
588     start_children(config.first_feed);
589
590     start_multicast();
591
592     for(;;) {
593         poll_entry = poll_table;
594         if (server_fd) {
595             poll_entry->fd = server_fd;
596             poll_entry->events = POLLIN;
597             poll_entry++;
598         }
599         if (rtsp_server_fd) {
600             poll_entry->fd = rtsp_server_fd;
601             poll_entry->events = POLLIN;
602             poll_entry++;
603         }
604
605         /* wait for events on each HTTP handle */
606         c = first_http_ctx;
607         delay = 1000;
608         while (c) {
609             int fd;
610             fd = c->fd;
611             switch(c->state) {
612             case HTTPSTATE_SEND_HEADER:
613             case RTSPSTATE_SEND_REPLY:
614             case RTSPSTATE_SEND_PACKET:
615                 c->poll_entry = poll_entry;
616                 poll_entry->fd = fd;
617                 poll_entry->events = POLLOUT;
618                 poll_entry++;
619                 break;
620             case HTTPSTATE_SEND_DATA_HEADER:
621             case HTTPSTATE_SEND_DATA:
622             case HTTPSTATE_SEND_DATA_TRAILER:
623                 if (!c->is_packetized) {
624                     /* for TCP, we output as much as we can
625                      * (may need to put a limit) */
626                     c->poll_entry = poll_entry;
627                     poll_entry->fd = fd;
628                     poll_entry->events = POLLOUT;
629                     poll_entry++;
630                 } else {
631                     /* when ffserver is doing the timing, we work by
632                        looking at which packet needs to be sent every
633                        10 ms */
634                     /* one tick wait XXX: 10 ms assumed */
635                     if (delay > 10)
636                         delay = 10;
637                 }
638                 break;
639             case HTTPSTATE_WAIT_REQUEST:
640             case HTTPSTATE_RECEIVE_DATA:
641             case HTTPSTATE_WAIT_FEED:
642             case RTSPSTATE_WAIT_REQUEST:
643                 /* need to catch errors */
644                 c->poll_entry = poll_entry;
645                 poll_entry->fd = fd;
646                 poll_entry->events = POLLIN;/* Maybe this will work */
647                 poll_entry++;
648                 break;
649             default:
650                 c->poll_entry = NULL;
651                 break;
652             }
653             c = c->next;
654         }
655
656         /* wait for an event on one connection. We poll at least every
657            second to handle timeouts */
658         do {
659             ret = poll(poll_table, poll_entry - poll_table, delay);
660             if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
661                 ff_neterrno() != AVERROR(EINTR)) {
662                 av_free(poll_table);
663                 return -1;
664             }
665         } while (ret < 0);
666
667         cur_time = av_gettime() / 1000;
668
669         if (need_to_start_children) {
670             need_to_start_children = 0;
671             start_children(config.first_feed);
672         }
673
674         /* now handle the events */
675         for(c = first_http_ctx; c; c = c_next) {
676             c_next = c->next;
677             if (handle_connection(c) < 0) {
678                 log_connection(c);
679                 /* close and free the connection */
680                 close_connection(c);
681             }
682         }
683
684         poll_entry = poll_table;
685         if (server_fd) {
686             /* new HTTP connection request ? */
687             if (poll_entry->revents & POLLIN)
688                 new_connection(server_fd, 0);
689             poll_entry++;
690         }
691         if (rtsp_server_fd) {
692             /* new RTSP connection request ? */
693             if (poll_entry->revents & POLLIN)
694                 new_connection(rtsp_server_fd, 1);
695         }
696     }
697 }
698
699 /* start waiting for a new HTTP/RTSP request */
700 static void start_wait_request(HTTPContext *c, int is_rtsp)
701 {
702     c->buffer_ptr = c->buffer;
703     c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
704
705     if (is_rtsp) {
706         c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
707         c->state = RTSPSTATE_WAIT_REQUEST;
708     } else {
709         c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
710         c->state = HTTPSTATE_WAIT_REQUEST;
711     }
712 }
713
714 static void http_send_too_busy_reply(int fd)
715 {
716     char buffer[400];
717     int len = snprintf(buffer, sizeof(buffer),
718                        "HTTP/1.0 503 Server too busy\r\n"
719                        "Content-type: text/html\r\n"
720                        "\r\n"
721                        "<html><head><title>Too busy</title></head><body>\r\n"
722                        "<p>The server is too busy to serve your request at this time.</p>\r\n"
723                        "<p>The number of current connections is %u, and this exceeds the limit of %u.</p>\r\n"
724                        "</body></html>\r\n",
725                        nb_connections, config.nb_max_connections);
726     av_assert0(len < sizeof(buffer));
727     if (send(fd, buffer, len, 0) < len)
728         av_log(NULL, AV_LOG_WARNING, "Could not send too-busy reply, send() failed\n");
729 }
730
731
732 static void new_connection(int server_fd, int is_rtsp)
733 {
734     struct sockaddr_in from_addr;
735     socklen_t len;
736     int fd;
737     HTTPContext *c = NULL;
738
739     len = sizeof(from_addr);
740     fd = accept(server_fd, (struct sockaddr *)&from_addr,
741                 &len);
742     if (fd < 0) {
743         http_log("error during accept %s\n", strerror(errno));
744         return;
745     }
746     if (ff_socket_nonblock(fd, 1) < 0)
747         av_log(NULL, AV_LOG_WARNING, "ff_socket_nonblock failed\n");
748
749     if (nb_connections >= config.nb_max_connections) {
750         http_send_too_busy_reply(fd);
751         goto fail;
752     }
753
754     /* add a new connection */
755     c = av_mallocz(sizeof(HTTPContext));
756     if (!c)
757         goto fail;
758
759     c->fd = fd;
760     c->poll_entry = NULL;
761     c->from_addr = from_addr;
762     c->buffer_size = IOBUFFER_INIT_SIZE;
763     c->buffer = av_malloc(c->buffer_size);
764     if (!c->buffer)
765         goto fail;
766
767     c->next = first_http_ctx;
768     first_http_ctx = c;
769     nb_connections++;
770
771     start_wait_request(c, is_rtsp);
772
773     return;
774
775  fail:
776     if (c) {
777         av_freep(&c->buffer);
778         av_free(c);
779     }
780     closesocket(fd);
781 }
782
783 static void close_connection(HTTPContext *c)
784 {
785     HTTPContext **cp, *c1;
786     int i, nb_streams;
787     AVFormatContext *ctx;
788     URLContext *h;
789     AVStream *st;
790
791     /* remove connection from list */
792     cp = &first_http_ctx;
793     while (*cp) {
794         c1 = *cp;
795         if (c1 == c)
796             *cp = c->next;
797         else
798             cp = &c1->next;
799     }
800
801     /* remove references, if any (XXX: do it faster) */
802     for(c1 = first_http_ctx; c1; c1 = c1->next) {
803         if (c1->rtsp_c == c)
804             c1->rtsp_c = NULL;
805     }
806
807     /* remove connection associated resources */
808     if (c->fd >= 0)
809         closesocket(c->fd);
810     if (c->fmt_in) {
811         /* close each frame parser */
812         for(i=0;i<c->fmt_in->nb_streams;i++) {
813             st = c->fmt_in->streams[i];
814             if (st->codec->codec)
815                 avcodec_close(st->codec);
816         }
817         avformat_close_input(&c->fmt_in);
818     }
819
820     /* free RTP output streams if any */
821     nb_streams = 0;
822     if (c->stream)
823         nb_streams = c->stream->nb_streams;
824
825     for(i=0;i<nb_streams;i++) {
826         ctx = c->rtp_ctx[i];
827         if (ctx) {
828             av_write_trailer(ctx);
829             av_dict_free(&ctx->metadata);
830             av_freep(&ctx->streams[0]);
831             av_freep(&ctx);
832         }
833         h = c->rtp_handles[i];
834         if (h)
835             ffurl_close(h);
836     }
837
838     ctx = &c->fmt_ctx;
839
840     if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
841         /* prepare header */
842         if (ctx->oformat && avio_open_dyn_buf(&ctx->pb) >= 0) {
843             av_write_trailer(ctx);
844             av_freep(&c->pb_buffer);
845             avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
846         }
847     }
848
849     for(i=0; i<ctx->nb_streams; i++)
850         av_freep(&ctx->streams[i]);
851     av_freep(&ctx->streams);
852     av_freep(&ctx->priv_data);
853
854     if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
855         current_bandwidth -= c->stream->bandwidth;
856
857     /* signal that there is no feed if we are the feeder socket */
858     if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
859         c->stream->feed_opened = 0;
860         close(c->feed_fd);
861     }
862
863     av_freep(&c->pb_buffer);
864     av_freep(&c->packet_buffer);
865     av_freep(&c->buffer);
866     av_free(c);
867     nb_connections--;
868 }
869
870 static int handle_connection(HTTPContext *c)
871 {
872     int len, ret;
873     uint8_t *ptr;
874
875     switch(c->state) {
876     case HTTPSTATE_WAIT_REQUEST:
877     case RTSPSTATE_WAIT_REQUEST:
878         /* timeout ? */
879         if ((c->timeout - cur_time) < 0)
880             return -1;
881         if (c->poll_entry->revents & (POLLERR | POLLHUP))
882             return -1;
883
884         /* no need to read if no events */
885         if (!(c->poll_entry->revents & POLLIN))
886             return 0;
887         /* read the data */
888     read_loop:
889         if (!(len = recv(c->fd, c->buffer_ptr, 1, 0)))
890             return -1;
891
892         if (len < 0) {
893             if (ff_neterrno() != AVERROR(EAGAIN) &&
894                 ff_neterrno() != AVERROR(EINTR))
895                 return -1;
896             break;
897         }
898             /* search for end of request. */
899             c->buffer_ptr += len;
900             ptr = c->buffer_ptr;
901             if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
902                 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
903                 /* request found : parse it and reply */
904                 if (c->state == HTTPSTATE_WAIT_REQUEST) {
905                     ret = http_parse_request(c);
906                 } else {
907                     ret = rtsp_parse_request(c);
908                 }
909                 if (ret < 0)
910                     return -1;
911             } else if (ptr >= c->buffer_end) {
912                 /* request too long: cannot do anything */
913                 return -1;
914             } else goto read_loop;
915
916         break;
917
918     case HTTPSTATE_SEND_HEADER:
919         if (c->poll_entry->revents & (POLLERR | POLLHUP))
920             return -1;
921
922         /* no need to write if no events */
923         if (!(c->poll_entry->revents & POLLOUT))
924             return 0;
925         len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
926         if (len < 0) {
927             if (ff_neterrno() != AVERROR(EAGAIN) &&
928                 ff_neterrno() != AVERROR(EINTR)) {
929                 goto close_connection;
930             }
931             break;
932         }
933             c->buffer_ptr += len;
934             if (c->stream)
935                 c->stream->bytes_served += len;
936             c->data_count += len;
937             if (c->buffer_ptr >= c->buffer_end) {
938                 av_freep(&c->pb_buffer);
939                 /* if error, exit */
940                 if (c->http_error)
941                     return -1;
942                 /* all the buffer was sent : synchronize to the incoming
943                  * stream */
944                 c->state = HTTPSTATE_SEND_DATA_HEADER;
945                 c->buffer_ptr = c->buffer_end = c->buffer;
946             }
947         break;
948
949     case HTTPSTATE_SEND_DATA:
950     case HTTPSTATE_SEND_DATA_HEADER:
951     case HTTPSTATE_SEND_DATA_TRAILER:
952         /* for packetized output, we consider we can always write (the
953            input streams set the speed). It may be better to verify
954            that we do not rely too much on the kernel queues */
955         if (!c->is_packetized) {
956             if (c->poll_entry->revents & (POLLERR | POLLHUP))
957                 return -1;
958
959             /* no need to read if no events */
960             if (!(c->poll_entry->revents & POLLOUT))
961                 return 0;
962         }
963         if (http_send_data(c) < 0)
964             return -1;
965         /* close connection if trailer sent */
966         if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
967             return -1;
968         break;
969     case HTTPSTATE_RECEIVE_DATA:
970         /* no need to read if no events */
971         if (c->poll_entry->revents & (POLLERR | POLLHUP))
972             return -1;
973         if (!(c->poll_entry->revents & POLLIN))
974             return 0;
975         if (http_receive_data(c) < 0)
976             return -1;
977         break;
978     case HTTPSTATE_WAIT_FEED:
979         /* no need to read if no events */
980         if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
981             return -1;
982
983         /* nothing to do, we'll be waken up by incoming feed packets */
984         break;
985
986     case RTSPSTATE_SEND_REPLY:
987         if (c->poll_entry->revents & (POLLERR | POLLHUP))
988             goto close_connection;
989         /* no need to write if no events */
990         if (!(c->poll_entry->revents & POLLOUT))
991             return 0;
992         len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
993         if (len < 0) {
994             if (ff_neterrno() != AVERROR(EAGAIN) &&
995                 ff_neterrno() != AVERROR(EINTR)) {
996                 goto close_connection;
997             }
998             break;
999         }
1000             c->buffer_ptr += len;
1001             c->data_count += len;
1002             if (c->buffer_ptr >= c->buffer_end) {
1003                 /* all the buffer was sent : wait for a new request */
1004                 av_freep(&c->pb_buffer);
1005                 start_wait_request(c, 1);
1006             }
1007         break;
1008     case RTSPSTATE_SEND_PACKET:
1009         if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1010             av_freep(&c->packet_buffer);
1011             return -1;
1012         }
1013         /* no need to write if no events */
1014         if (!(c->poll_entry->revents & POLLOUT))
1015             return 0;
1016         len = send(c->fd, c->packet_buffer_ptr,
1017                     c->packet_buffer_end - c->packet_buffer_ptr, 0);
1018         if (len < 0) {
1019             if (ff_neterrno() != AVERROR(EAGAIN) &&
1020                 ff_neterrno() != AVERROR(EINTR)) {
1021                 /* error : close connection */
1022                 av_freep(&c->packet_buffer);
1023                 return -1;
1024             }
1025             break;
1026         }
1027             c->packet_buffer_ptr += len;
1028             if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1029                 /* all the buffer was sent : wait for a new request */
1030                 av_freep(&c->packet_buffer);
1031                 c->state = RTSPSTATE_WAIT_REQUEST;
1032             }
1033         break;
1034     case HTTPSTATE_READY:
1035         /* nothing to do */
1036         break;
1037     default:
1038         return -1;
1039     }
1040     return 0;
1041
1042 close_connection:
1043     av_freep(&c->pb_buffer);
1044     return -1;
1045 }
1046
1047 static int extract_rates(char *rates, int ratelen, const char *request)
1048 {
1049     const char *p;
1050
1051     for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1052         if (av_strncasecmp(p, "Pragma:", 7) == 0) {
1053             const char *q = p + 7;
1054
1055             while (*q && *q != '\n' && av_isspace(*q))
1056                 q++;
1057
1058             if (av_strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1059                 int stream_no;
1060                 int rate_no;
1061
1062                 q += 20;
1063
1064                 memset(rates, 0xff, ratelen);
1065
1066                 while (1) {
1067                     while (*q && *q != '\n' && *q != ':')
1068                         q++;
1069
1070                     if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1071                         break;
1072
1073                     stream_no--;
1074                     if (stream_no < ratelen && stream_no >= 0)
1075                         rates[stream_no] = rate_no;
1076
1077                     while (*q && *q != '\n' && !av_isspace(*q))
1078                         q++;
1079                 }
1080
1081                 return 1;
1082             }
1083         }
1084         p = strchr(p, '\n');
1085         if (!p)
1086             break;
1087
1088         p++;
1089     }
1090
1091     return 0;
1092 }
1093
1094 static int find_stream_in_feed(FFServerStream *feed, AVCodecContext *codec, int bit_rate)
1095 {
1096     int i;
1097     int best_bitrate = 100000000;
1098     int best = -1;
1099
1100     for (i = 0; i < feed->nb_streams; i++) {
1101         AVCodecContext *feed_codec = feed->streams[i]->codec;
1102
1103         if (feed_codec->codec_id != codec->codec_id ||
1104             feed_codec->sample_rate != codec->sample_rate ||
1105             feed_codec->width != codec->width ||
1106             feed_codec->height != codec->height)
1107             continue;
1108
1109         /* Potential stream */
1110
1111         /* We want the fastest stream less than bit_rate, or the slowest
1112          * faster than bit_rate
1113          */
1114
1115         if (feed_codec->bit_rate <= bit_rate) {
1116             if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1117                 best_bitrate = feed_codec->bit_rate;
1118                 best = i;
1119             }
1120         } else {
1121             if (feed_codec->bit_rate < best_bitrate) {
1122                 best_bitrate = feed_codec->bit_rate;
1123                 best = i;
1124             }
1125         }
1126     }
1127
1128     return best;
1129 }
1130
1131 static int modify_current_stream(HTTPContext *c, char *rates)
1132 {
1133     int i;
1134     FFServerStream *req = c->stream;
1135     int action_required = 0;
1136
1137     /* Not much we can do for a feed */
1138     if (!req->feed)
1139         return 0;
1140
1141     for (i = 0; i < req->nb_streams; i++) {
1142         AVCodecContext *codec = req->streams[i]->codec;
1143
1144         switch(rates[i]) {
1145             case 0:
1146                 c->switch_feed_streams[i] = req->feed_streams[i];
1147                 break;
1148             case 1:
1149                 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1150                 break;
1151             case 2:
1152                 /* Wants off or slow */
1153                 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1154 #ifdef WANTS_OFF
1155                 /* This doesn't work well when it turns off the only stream! */
1156                 c->switch_feed_streams[i] = -2;
1157                 c->feed_streams[i] = -2;
1158 #endif
1159                 break;
1160         }
1161
1162         if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1163             action_required = 1;
1164     }
1165
1166     return action_required;
1167 }
1168
1169 static void get_word(char *buf, int buf_size, const char **pp)
1170 {
1171     const char *p;
1172     char *q;
1173
1174     p = *pp;
1175     p += strspn(p, SPACE_CHARS);
1176     q = buf;
1177     while (!av_isspace(*p) && *p != '\0') {
1178         if ((q - buf) < buf_size - 1)
1179             *q++ = *p;
1180         p++;
1181     }
1182     if (buf_size > 0)
1183         *q = '\0';
1184     *pp = p;
1185 }
1186
1187 static FFServerIPAddressACL* parse_dynamic_acl(FFServerStream *stream, HTTPContext *c)
1188 {
1189     FILE* f;
1190     char line[1024];
1191     char  cmd[1024];
1192     FFServerIPAddressACL *acl = NULL;
1193     int line_num = 0;
1194     const char *p;
1195
1196     f = fopen(stream->dynamic_acl, "r");
1197     if (!f) {
1198         perror(stream->dynamic_acl);
1199         return NULL;
1200     }
1201
1202     acl = av_mallocz(sizeof(FFServerIPAddressACL));
1203
1204     /* Build ACL */
1205     while (fgets(line, sizeof(line), f)) {
1206         line_num++;
1207         p = line;
1208         while (av_isspace(*p))
1209             p++;
1210         if (*p == '\0' || *p == '#')
1211             continue;
1212         ffserver_get_arg(cmd, sizeof(cmd), &p);
1213
1214         if (!av_strcasecmp(cmd, "ACL"))
1215             ffserver_parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1216     }
1217     fclose(f);
1218     return acl;
1219 }
1220
1221
1222 static void free_acl_list(FFServerIPAddressACL *in_acl)
1223 {
1224     FFServerIPAddressACL *pacl, *pacl2;
1225
1226     pacl = in_acl;
1227     while(pacl) {
1228         pacl2 = pacl;
1229         pacl = pacl->next;
1230         av_freep(pacl2);
1231     }
1232 }
1233
1234 static int validate_acl_list(FFServerIPAddressACL *in_acl, HTTPContext *c)
1235 {
1236     enum FFServerIPAddressAction last_action = IP_DENY;
1237     FFServerIPAddressACL *acl;
1238     struct in_addr *src = &c->from_addr.sin_addr;
1239     unsigned long src_addr = src->s_addr;
1240
1241     for (acl = in_acl; acl; acl = acl->next) {
1242         if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1243             return (acl->action == IP_ALLOW) ? 1 : 0;
1244         last_action = acl->action;
1245     }
1246
1247     /* Nothing matched, so return not the last action */
1248     return (last_action == IP_DENY) ? 1 : 0;
1249 }
1250
1251 static int validate_acl(FFServerStream *stream, HTTPContext *c)
1252 {
1253     int ret = 0;
1254     FFServerIPAddressACL *acl;
1255
1256     /* if stream->acl is null validate_acl_list will return 1 */
1257     ret = validate_acl_list(stream->acl, c);
1258
1259     if (stream->dynamic_acl[0]) {
1260         acl = parse_dynamic_acl(stream, c);
1261
1262         ret = validate_acl_list(acl, c);
1263
1264         free_acl_list(acl);
1265     }
1266
1267     return ret;
1268 }
1269
1270 /* compute the real filename of a file by matching it without its
1271    extensions to all the stream's filenames */
1272 static void compute_real_filename(char *filename, int max_size)
1273 {
1274     char file1[1024];
1275     char file2[1024];
1276     char *p;
1277     FFServerStream *stream;
1278
1279     /* compute filename by matching without the file extensions */
1280     av_strlcpy(file1, filename, sizeof(file1));
1281     p = strrchr(file1, '.');
1282     if (p)
1283         *p = '\0';
1284     for(stream = config.first_stream; stream; stream = stream->next) {
1285         av_strlcpy(file2, stream->filename, sizeof(file2));
1286         p = strrchr(file2, '.');
1287         if (p)
1288             *p = '\0';
1289         if (!strcmp(file1, file2)) {
1290             av_strlcpy(filename, stream->filename, max_size);
1291             break;
1292         }
1293     }
1294 }
1295
1296 enum RedirType {
1297     REDIR_NONE,
1298     REDIR_ASX,
1299     REDIR_RAM,
1300     REDIR_ASF,
1301     REDIR_RTSP,
1302     REDIR_SDP,
1303 };
1304
1305 /* parse HTTP request and prepare header */
1306 static int http_parse_request(HTTPContext *c)
1307 {
1308     const char *p;
1309     char *p1;
1310     enum RedirType redir_type;
1311     char cmd[32];
1312     char info[1024], filename[1024];
1313     char url[1024], *q;
1314     char protocol[32];
1315     char msg[1024];
1316     const char *mime_type;
1317     FFServerStream *stream;
1318     int i;
1319     char ratebuf[32];
1320     const char *useragent = 0;
1321
1322     p = c->buffer;
1323     get_word(cmd, sizeof(cmd), &p);
1324     av_strlcpy(c->method, cmd, sizeof(c->method));
1325
1326     if (!strcmp(cmd, "GET"))
1327         c->post = 0;
1328     else if (!strcmp(cmd, "POST"))
1329         c->post = 1;
1330     else
1331         return -1;
1332
1333     get_word(url, sizeof(url), &p);
1334     av_strlcpy(c->url, url, sizeof(c->url));
1335
1336     get_word(protocol, sizeof(protocol), (const char **)&p);
1337     if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1338         return -1;
1339
1340     av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1341
1342     if (config.debug)
1343         http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1344
1345     /* find the filename and the optional info string in the request */
1346     p1 = strchr(url, '?');
1347     if (p1) {
1348         av_strlcpy(info, p1, sizeof(info));
1349         *p1 = '\0';
1350     } else
1351         info[0] = '\0';
1352
1353     av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1354
1355     for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1356         if (av_strncasecmp(p, "User-Agent:", 11) == 0) {
1357             useragent = p + 11;
1358             if (*useragent && *useragent != '\n' && av_isspace(*useragent))
1359                 useragent++;
1360             break;
1361         }
1362         p = strchr(p, '\n');
1363         if (!p)
1364             break;
1365
1366         p++;
1367     }
1368
1369     redir_type = REDIR_NONE;
1370     if (av_match_ext(filename, "asx")) {
1371         redir_type = REDIR_ASX;
1372         filename[strlen(filename)-1] = 'f';
1373     } else if (av_match_ext(filename, "asf") &&
1374         (!useragent || av_strncasecmp(useragent, "NSPlayer", 8))) {
1375         /* if this isn't WMP or lookalike, return the redirector file */
1376         redir_type = REDIR_ASF;
1377     } else if (av_match_ext(filename, "rpm,ram")) {
1378         redir_type = REDIR_RAM;
1379         strcpy(filename + strlen(filename)-2, "m");
1380     } else if (av_match_ext(filename, "rtsp")) {
1381         redir_type = REDIR_RTSP;
1382         compute_real_filename(filename, sizeof(filename) - 1);
1383     } else if (av_match_ext(filename, "sdp")) {
1384         redir_type = REDIR_SDP;
1385         compute_real_filename(filename, sizeof(filename) - 1);
1386     }
1387
1388     // "redirect" / request to index.html
1389     if (!strlen(filename))
1390         av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1391
1392     stream = config.first_stream;
1393     while (stream) {
1394         if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1395             break;
1396         stream = stream->next;
1397     }
1398     if (!stream) {
1399         snprintf(msg, sizeof(msg), "File '%s' not found", url);
1400         http_log("File '%s' not found\n", url);
1401         goto send_error;
1402     }
1403
1404     c->stream = stream;
1405     memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1406     memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1407
1408     if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1409         c->http_error = 301;
1410         q = c->buffer;
1411         snprintf(q, c->buffer_size,
1412                       "HTTP/1.0 301 Moved\r\n"
1413                       "Location: %s\r\n"
1414                       "Content-type: text/html\r\n"
1415                       "\r\n"
1416                       "<html><head><title>Moved</title></head><body>\r\n"
1417                       "You should be <a href=\"%s\">redirected</a>.\r\n"
1418                       "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1419         q += strlen(q);
1420         /* prepare output buffer */
1421         c->buffer_ptr = c->buffer;
1422         c->buffer_end = q;
1423         c->state = HTTPSTATE_SEND_HEADER;
1424         return 0;
1425     }
1426
1427     /* If this is WMP, get the rate information */
1428     if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1429         if (modify_current_stream(c, ratebuf)) {
1430             for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1431                 if (c->switch_feed_streams[i] >= 0)
1432                     c->switch_feed_streams[i] = -1;
1433             }
1434         }
1435     }
1436
1437     if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1438         current_bandwidth += stream->bandwidth;
1439
1440     /* If already streaming this feed, do not let start another feeder. */
1441     if (stream->feed_opened) {
1442         snprintf(msg, sizeof(msg), "This feed is already being received.");
1443         http_log("Feed '%s' already being received\n", stream->feed_filename);
1444         goto send_error;
1445     }
1446
1447     if (c->post == 0 && config.max_bandwidth < current_bandwidth) {
1448         c->http_error = 503;
1449         q = c->buffer;
1450         snprintf(q, c->buffer_size,
1451                       "HTTP/1.0 503 Server too busy\r\n"
1452                       "Content-type: text/html\r\n"
1453                       "\r\n"
1454                       "<html><head><title>Too busy</title></head><body>\r\n"
1455                       "<p>The server is too busy to serve your request at this time.</p>\r\n"
1456                       "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1457                       "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1458                       "</body></html>\r\n", current_bandwidth, config.max_bandwidth);
1459         q += strlen(q);
1460         /* prepare output buffer */
1461         c->buffer_ptr = c->buffer;
1462         c->buffer_end = q;
1463         c->state = HTTPSTATE_SEND_HEADER;
1464         return 0;
1465     }
1466
1467     if (redir_type != REDIR_NONE) {
1468         const char *hostinfo = 0;
1469
1470         for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1471             if (av_strncasecmp(p, "Host:", 5) == 0) {
1472                 hostinfo = p + 5;
1473                 break;
1474             }
1475             p = strchr(p, '\n');
1476             if (!p)
1477                 break;
1478
1479             p++;
1480         }
1481
1482         if (hostinfo) {
1483             char *eoh;
1484             char hostbuf[260];
1485
1486             while (av_isspace(*hostinfo))
1487                 hostinfo++;
1488
1489             eoh = strchr(hostinfo, '\n');
1490             if (eoh) {
1491                 if (eoh[-1] == '\r')
1492                     eoh--;
1493
1494                 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1495                     memcpy(hostbuf, hostinfo, eoh - hostinfo);
1496                     hostbuf[eoh - hostinfo] = 0;
1497
1498                     c->http_error = 200;
1499                     q = c->buffer;
1500                     switch(redir_type) {
1501                     case REDIR_ASX:
1502                         snprintf(q, c->buffer_size,
1503                                       "HTTP/1.0 200 ASX Follows\r\n"
1504                                       "Content-type: video/x-ms-asf\r\n"
1505                                       "\r\n"
1506                                       "<ASX Version=\"3\">\r\n"
1507                                       //"<!-- Autogenerated by ffserver -->\r\n"
1508                                       "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1509                                       "</ASX>\r\n", hostbuf, filename, info);
1510                         q += strlen(q);
1511                         break;
1512                     case REDIR_RAM:
1513                         snprintf(q, c->buffer_size,
1514                                       "HTTP/1.0 200 RAM Follows\r\n"
1515                                       "Content-type: audio/x-pn-realaudio\r\n"
1516                                       "\r\n"
1517                                       "# Autogenerated by ffserver\r\n"
1518                                       "http://%s/%s%s\r\n", hostbuf, filename, info);
1519                         q += strlen(q);
1520                         break;
1521                     case REDIR_ASF:
1522                         snprintf(q, c->buffer_size,
1523                                       "HTTP/1.0 200 ASF Redirect follows\r\n"
1524                                       "Content-type: video/x-ms-asf\r\n"
1525                                       "\r\n"
1526                                       "[Reference]\r\n"
1527                                       "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1528                         q += strlen(q);
1529                         break;
1530                     case REDIR_RTSP:
1531                         {
1532                             char hostname[256], *p;
1533                             /* extract only hostname */
1534                             av_strlcpy(hostname, hostbuf, sizeof(hostname));
1535                             p = strrchr(hostname, ':');
1536                             if (p)
1537                                 *p = '\0';
1538                             snprintf(q, c->buffer_size,
1539                                           "HTTP/1.0 200 RTSP Redirect follows\r\n"
1540                                           /* XXX: incorrect MIME type ? */
1541                                           "Content-type: application/x-rtsp\r\n"
1542                                           "\r\n"
1543                                           "rtsp://%s:%d/%s\r\n", hostname, ntohs(config.rtsp_addr.sin_port), filename);
1544                             q += strlen(q);
1545                         }
1546                         break;
1547                     case REDIR_SDP:
1548                         {
1549                             uint8_t *sdp_data;
1550                             int sdp_data_size;
1551                             socklen_t len;
1552                             struct sockaddr_in my_addr;
1553
1554                             snprintf(q, c->buffer_size,
1555                                           "HTTP/1.0 200 OK\r\n"
1556                                           "Content-type: application/sdp\r\n"
1557                                           "\r\n");
1558                             q += strlen(q);
1559
1560                             len = sizeof(my_addr);
1561
1562                             /* XXX: Should probably fail? */
1563                             if (getsockname(c->fd, (struct sockaddr *)&my_addr, &len))
1564                                 http_log("getsockname() failed\n");
1565
1566                             /* XXX: should use a dynamic buffer */
1567                             sdp_data_size = prepare_sdp_description(stream,
1568                                                                     &sdp_data,
1569                                                                     my_addr.sin_addr);
1570                             if (sdp_data_size > 0) {
1571                                 memcpy(q, sdp_data, sdp_data_size);
1572                                 q += sdp_data_size;
1573                                 *q = '\0';
1574                                 av_free(sdp_data);
1575                             }
1576                         }
1577                         break;
1578                     default:
1579                         abort();
1580                         break;
1581                     }
1582
1583                     /* prepare output buffer */
1584                     c->buffer_ptr = c->buffer;
1585                     c->buffer_end = q;
1586                     c->state = HTTPSTATE_SEND_HEADER;
1587                     return 0;
1588                 }
1589             }
1590         }
1591
1592         snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1593         goto send_error;
1594     }
1595
1596     stream->conns_served++;
1597
1598     /* XXX: add there authenticate and IP match */
1599
1600     if (c->post) {
1601         /* if post, it means a feed is being sent */
1602         if (!stream->is_feed) {
1603             /* However it might be a status report from WMP! Let us log the
1604              * data as it might come handy one day. */
1605             const char *logline = 0;
1606             int client_id = 0;
1607
1608             for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1609                 if (av_strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1610                     logline = p;
1611                     break;
1612                 }
1613                 if (av_strncasecmp(p, "Pragma: client-id=", 18) == 0)
1614                     client_id = strtol(p + 18, 0, 10);
1615                 p = strchr(p, '\n');
1616                 if (!p)
1617                     break;
1618
1619                 p++;
1620             }
1621
1622             if (logline) {
1623                 char *eol = strchr(logline, '\n');
1624
1625                 logline += 17;
1626
1627                 if (eol) {
1628                     if (eol[-1] == '\r')
1629                         eol--;
1630                     http_log("%.*s\n", (int) (eol - logline), logline);
1631                     c->suppress_log = 1;
1632                 }
1633             }
1634
1635 #ifdef DEBUG
1636             http_log("\nGot request:\n%s\n", c->buffer);
1637 #endif
1638
1639             if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1640                 HTTPContext *wmpc;
1641
1642                 /* Now we have to find the client_id */
1643                 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1644                     if (wmpc->wmp_client_id == client_id)
1645                         break;
1646                 }
1647
1648                 if (wmpc && modify_current_stream(wmpc, ratebuf))
1649                     wmpc->switch_pending = 1;
1650             }
1651
1652             snprintf(msg, sizeof(msg), "POST command not handled");
1653             c->stream = 0;
1654             goto send_error;
1655         }
1656         if (http_start_receive_data(c) < 0) {
1657             snprintf(msg, sizeof(msg), "could not open feed");
1658             goto send_error;
1659         }
1660         c->http_error = 0;
1661         c->state = HTTPSTATE_RECEIVE_DATA;
1662         return 0;
1663     }
1664
1665 #ifdef DEBUG
1666     if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1667         http_log("\nGot request:\n%s\n", c->buffer);
1668 #endif
1669
1670     if (c->stream->stream_type == STREAM_TYPE_STATUS)
1671         goto send_status;
1672
1673     /* open input stream */
1674     if (open_input_stream(c, info) < 0) {
1675         snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1676         goto send_error;
1677     }
1678
1679     /* prepare HTTP header */
1680     c->buffer[0] = 0;
1681     av_strlcatf(c->buffer, c->buffer_size, "HTTP/1.0 200 OK\r\n");
1682     mime_type = c->stream->fmt->mime_type;
1683     if (!mime_type)
1684         mime_type = "application/x-octet-stream";
1685     av_strlcatf(c->buffer, c->buffer_size, "Pragma: no-cache\r\n");
1686
1687     /* for asf, we need extra headers */
1688     if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1689         /* Need to allocate a client id */
1690
1691         c->wmp_client_id = av_lfg_get(&random_state);
1692
1693         av_strlcatf(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);
1694     }
1695     av_strlcatf(c->buffer, c->buffer_size, "Content-Type: %s\r\n", mime_type);
1696     av_strlcatf(c->buffer, c->buffer_size, "\r\n");
1697     q = c->buffer + strlen(c->buffer);
1698
1699     /* prepare output buffer */
1700     c->http_error = 0;
1701     c->buffer_ptr = c->buffer;
1702     c->buffer_end = q;
1703     c->state = HTTPSTATE_SEND_HEADER;
1704     return 0;
1705  send_error:
1706     c->http_error = 404;
1707     q = c->buffer;
1708     htmlstrip(msg);
1709     snprintf(q, c->buffer_size,
1710                   "HTTP/1.0 404 Not Found\r\n"
1711                   "Content-type: text/html\r\n"
1712                   "\r\n"
1713                   "<html>\n"
1714                   "<head><title>404 Not Found</title></head>\n"
1715                   "<body>%s</body>\n"
1716                   "</html>\n", msg);
1717     q += strlen(q);
1718     /* prepare output buffer */
1719     c->buffer_ptr = c->buffer;
1720     c->buffer_end = q;
1721     c->state = HTTPSTATE_SEND_HEADER;
1722     return 0;
1723  send_status:
1724     compute_status(c);
1725     c->http_error = 200; /* horrible : we use this value to avoid
1726                             going to the send data state */
1727     c->state = HTTPSTATE_SEND_HEADER;
1728     return 0;
1729 }
1730
1731 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1732 {
1733     static const char suffix[] = " kMGTP";
1734     const char *s;
1735
1736     for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1737
1738     avio_printf(pb, "%"PRId64"%c", count, *s);
1739 }
1740
1741 static void compute_status(HTTPContext *c)
1742 {
1743     HTTPContext *c1;
1744     FFServerStream *stream;
1745     char *p;
1746     time_t ti;
1747     int i, len;
1748     AVIOContext *pb;
1749
1750     if (avio_open_dyn_buf(&pb) < 0) {
1751         /* XXX: return an error ? */
1752         c->buffer_ptr = c->buffer;
1753         c->buffer_end = c->buffer;
1754         return;
1755     }
1756
1757     avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1758     avio_printf(pb, "Content-type: text/html\r\n");
1759     avio_printf(pb, "Pragma: no-cache\r\n");
1760     avio_printf(pb, "\r\n");
1761
1762     avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1763     if (c->stream->feed_filename[0])
1764         avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1765     avio_printf(pb, "</head>\n<body>");
1766     avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1767     /* format status */
1768     avio_printf(pb, "<h2>Available Streams</h2>\n");
1769     avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1770     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");
1771     stream = config.first_stream;
1772     while (stream) {
1773         char sfilename[1024];
1774         char *eosf;
1775
1776         if (stream->feed == stream) {
1777             stream = stream->next;
1778             continue;
1779         }
1780
1781         av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1782         eosf = sfilename + strlen(sfilename);
1783         if (eosf - sfilename >= 4) {
1784             if (strcmp(eosf - 4, ".asf") == 0)
1785                 strcpy(eosf - 4, ".asx");
1786             else if (strcmp(eosf - 3, ".rm") == 0)
1787                 strcpy(eosf - 3, ".ram");
1788             else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1789                 /* generate a sample RTSP director if
1790                    unicast. Generate an SDP redirector if
1791                    multicast */
1792                 eosf = strrchr(sfilename, '.');
1793                 if (!eosf)
1794                     eosf = sfilename + strlen(sfilename);
1795                 if (stream->is_multicast)
1796                     strcpy(eosf, ".sdp");
1797                 else
1798                     strcpy(eosf, ".rtsp");
1799             }
1800         }
1801
1802         avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1803                     sfilename, stream->filename);
1804         avio_printf(pb, "<td align=right> %d <td align=right> ",
1805                     stream->conns_served);
1806         fmt_bytecount(pb, stream->bytes_served);
1807
1808         switch(stream->stream_type) {
1809         case STREAM_TYPE_LIVE: {
1810             int audio_bit_rate = 0;
1811             int video_bit_rate = 0;
1812             const char *audio_codec_name = "";
1813             const char *video_codec_name = "";
1814             const char *audio_codec_name_extra = "";
1815             const char *video_codec_name_extra = "";
1816
1817             for(i=0;i<stream->nb_streams;i++) {
1818                 AVStream *st = stream->streams[i];
1819                 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1820
1821                 switch(st->codec->codec_type) {
1822                 case AVMEDIA_TYPE_AUDIO:
1823                     audio_bit_rate += st->codec->bit_rate;
1824                     if (codec) {
1825                         if (*audio_codec_name)
1826                             audio_codec_name_extra = "...";
1827                         audio_codec_name = codec->name;
1828                     }
1829                     break;
1830                 case AVMEDIA_TYPE_VIDEO:
1831                     video_bit_rate += st->codec->bit_rate;
1832                     if (codec) {
1833                         if (*video_codec_name)
1834                             video_codec_name_extra = "...";
1835                         video_codec_name = codec->name;
1836                     }
1837                     break;
1838                 case AVMEDIA_TYPE_DATA:
1839                     video_bit_rate += st->codec->bit_rate;
1840                     break;
1841                 default:
1842                     abort();
1843                 }
1844             }
1845
1846             avio_printf(pb, "<td align=center> %s <td align=right> %d "
1847                             "<td align=right> %d <td> %s %s <td align=right> "
1848                             "%d <td> %s %s",
1849                         stream->fmt->name, stream->bandwidth,
1850                         video_bit_rate / 1000, video_codec_name,
1851                         video_codec_name_extra, audio_bit_rate / 1000,
1852                         audio_codec_name, audio_codec_name_extra);
1853
1854             if (stream->feed)
1855                 avio_printf(pb, "<td>%s", stream->feed->filename);
1856             else
1857                 avio_printf(pb, "<td>%s", stream->feed_filename);
1858             avio_printf(pb, "\n");
1859         }
1860             break;
1861         default:
1862             avio_printf(pb, "<td align=center> - <td align=right> - "
1863                             "<td align=right> - <td><td align=right> - <td>\n");
1864             break;
1865         }
1866         stream = stream->next;
1867     }
1868     avio_printf(pb, "</table>\n");
1869
1870     stream = config.first_stream;
1871     while (stream) {
1872
1873         if (stream->feed != stream) {
1874             stream = stream->next;
1875             continue;
1876         }
1877
1878         avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
1879         if (stream->pid) {
1880             avio_printf(pb, "Running as pid %d.\n", stream->pid);
1881
1882 #if defined(linux)
1883             {
1884                 FILE *pid_stat;
1885                 char ps_cmd[64];
1886
1887                 /* This is somewhat linux specific I guess */
1888                 snprintf(ps_cmd, sizeof(ps_cmd),
1889                          "ps -o \"%%cpu,cputime\" --no-headers %d",
1890                          stream->pid);
1891
1892                  pid_stat = popen(ps_cmd, "r");
1893                  if (pid_stat) {
1894                      char cpuperc[10];
1895                      char cpuused[64];
1896
1897                      if (fscanf(pid_stat, "%9s %63s", cpuperc, cpuused) == 2) {
1898                          avio_printf(pb, "Currently using %s%% of the cpu. "
1899                                          "Total time used %s.\n",
1900                                      cpuperc, cpuused);
1901                      }
1902                      fclose(pid_stat);
1903                  }
1904             }
1905 #endif
1906
1907             avio_printf(pb, "<p>");
1908         }
1909
1910         avio_printf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>"
1911                         "type<th>kbits/s<th align=left>codec<th align=left>"
1912                         "Parameters\n");
1913
1914         for (i = 0; i < stream->nb_streams; i++) {
1915             AVStream *st = stream->streams[i];
1916             AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1917             const char *type = "unknown";
1918             char parameters[64];
1919
1920             parameters[0] = 0;
1921
1922             switch(st->codec->codec_type) {
1923             case AVMEDIA_TYPE_AUDIO:
1924                 type = "audio";
1925                 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz",
1926                          st->codec->channels, st->codec->sample_rate);
1927                 break;
1928             case AVMEDIA_TYPE_VIDEO:
1929                 type = "video";
1930                 snprintf(parameters, sizeof(parameters),
1931                          "%dx%d, q=%d-%d, fps=%d", st->codec->width,
1932                          st->codec->height, st->codec->qmin, st->codec->qmax,
1933                          st->codec->time_base.den / st->codec->time_base.num);
1934                 break;
1935             default:
1936                 abort();
1937             }
1938
1939             avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d"
1940                             "<td>%s<td>%s\n",
1941                         i, type, st->codec->bit_rate/1000,
1942                         codec ? codec->name : "", parameters);
1943         }
1944
1945         avio_printf(pb, "</table>\n");
1946         stream = stream->next;
1947     }
1948
1949     /* connection status */
1950     avio_printf(pb, "<h2>Connection Status</h2>\n");
1951
1952     avio_printf(pb, "Number of connections: %d / %d<br>\n",
1953                 nb_connections, config.nb_max_connections);
1954
1955     avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
1956                 current_bandwidth, config.max_bandwidth);
1957
1958     avio_printf(pb, "<table>\n");
1959     avio_printf(pb, "<tr><th>#<th>File<th>IP<th>Proto<th>State<th>Target "
1960                     "bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
1961     c1 = first_http_ctx;
1962     i = 0;
1963     while (c1) {
1964         int bitrate;
1965         int j;
1966
1967         bitrate = 0;
1968         if (c1->stream) {
1969             for (j = 0; j < c1->stream->nb_streams; j++) {
1970                 if (!c1->stream->feed)
1971                     bitrate += c1->stream->streams[j]->codec->bit_rate;
1972                 else if (c1->feed_streams[j] >= 0)
1973                     bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
1974             }
1975         }
1976
1977         i++;
1978         p = inet_ntoa(c1->from_addr.sin_addr);
1979         avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s"
1980                         "<td align=right>",
1981                     i, c1->stream ? c1->stream->filename : "",
1982                     c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "", p,
1983                     c1->protocol, http_state[c1->state]);
1984         fmt_bytecount(pb, bitrate);
1985         avio_printf(pb, "<td align=right>");
1986         fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
1987         avio_printf(pb, "<td align=right>");
1988         fmt_bytecount(pb, c1->data_count);
1989         avio_printf(pb, "\n");
1990         c1 = c1->next;
1991     }
1992     avio_printf(pb, "</table>\n");
1993
1994     /* date */
1995     ti = time(NULL);
1996     p = ctime(&ti);
1997     avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
1998     avio_printf(pb, "</body>\n</html>\n");
1999
2000     len = avio_close_dyn_buf(pb, &c->pb_buffer);
2001     c->buffer_ptr = c->pb_buffer;
2002     c->buffer_end = c->pb_buffer + len;
2003 }
2004
2005 static int open_input_stream(HTTPContext *c, const char *info)
2006 {
2007     char buf[128];
2008     char input_filename[1024];
2009     AVFormatContext *s = NULL;
2010     int buf_size, i, ret;
2011     int64_t stream_pos;
2012
2013     /* find file name */
2014     if (c->stream->feed) {
2015         strcpy(input_filename, c->stream->feed->feed_filename);
2016         buf_size = FFM_PACKET_SIZE;
2017         /* compute position (absolute time) */
2018         if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2019             if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0) {
2020                 http_log("Invalid date specification '%s' for stream\n", buf);
2021                 return ret;
2022             }
2023         } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2024             int prebuffer = strtol(buf, 0, 10);
2025             stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2026         } else
2027             stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2028     } else {
2029         strcpy(input_filename, c->stream->feed_filename);
2030         buf_size = 0;
2031         /* compute position (relative time) */
2032         if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2033             if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0) {
2034                 http_log("Invalid date specification '%s' for stream\n", buf);
2035                 return ret;
2036             }
2037         } else
2038             stream_pos = 0;
2039     }
2040     if (!input_filename[0]) {
2041         http_log("No filename was specified for stream\n");
2042         return AVERROR(EINVAL);
2043     }
2044
2045     /* open stream */
2046     if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2047         http_log("Could not open input '%s': %s\n", input_filename, av_err2str(ret));
2048         return ret;
2049     }
2050
2051     /* set buffer size */
2052     if (buf_size > 0) ffio_set_buf_size(s->pb, buf_size);
2053
2054     s->flags |= AVFMT_FLAG_GENPTS;
2055     c->fmt_in = s;
2056     if (strcmp(s->iformat->name, "ffm") &&
2057         (ret = avformat_find_stream_info(c->fmt_in, NULL)) < 0) {
2058         http_log("Could not find stream info for input '%s'\n", input_filename);
2059         avformat_close_input(&s);
2060         return ret;
2061     }
2062
2063     /* choose stream as clock source (we favor the video stream if
2064      * present) for packet sending */
2065     c->pts_stream_index = 0;
2066     for(i=0;i<c->stream->nb_streams;i++) {
2067         if (c->pts_stream_index == 0 &&
2068             c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2069             c->pts_stream_index = i;
2070         }
2071     }
2072
2073     if (c->fmt_in->iformat->read_seek)
2074         av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2075     /* set the start time (needed for maxtime and RTP packet timing) */
2076     c->start_time = cur_time;
2077     c->first_pts = AV_NOPTS_VALUE;
2078     return 0;
2079 }
2080
2081 /* return the server clock (in us) */
2082 static int64_t get_server_clock(HTTPContext *c)
2083 {
2084     /* compute current pts value from system time */
2085     return (cur_time - c->start_time) * 1000;
2086 }
2087
2088 /* return the estimated time at which the current packet must be sent
2089    (in us) */
2090 static int64_t get_packet_send_clock(HTTPContext *c)
2091 {
2092     int bytes_left, bytes_sent, frame_bytes;
2093
2094     frame_bytes = c->cur_frame_bytes;
2095     if (frame_bytes <= 0)
2096         return c->cur_pts;
2097     else {
2098         bytes_left = c->buffer_end - c->buffer_ptr;
2099         bytes_sent = frame_bytes - bytes_left;
2100         return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2101     }
2102 }
2103
2104
2105 static int http_prepare_data(HTTPContext *c)
2106 {
2107     int i, len, ret;
2108     AVFormatContext *ctx;
2109
2110     av_freep(&c->pb_buffer);
2111     switch(c->state) {
2112     case HTTPSTATE_SEND_DATA_HEADER:
2113         ctx = avformat_alloc_context();
2114         c->fmt_ctx = *ctx;
2115         av_freep(&ctx);
2116         av_dict_copy(&(c->fmt_ctx.metadata), c->stream->metadata, 0);
2117         c->fmt_ctx.streams = av_mallocz_array(c->stream->nb_streams, sizeof(AVStream *));
2118
2119         for(i=0;i<c->stream->nb_streams;i++) {
2120             AVStream *src;
2121             c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2122             /* if file or feed, then just take streams from FFServerStream struct */
2123             if (!c->stream->feed ||
2124                 c->stream->feed == c->stream)
2125                 src = c->stream->streams[i];
2126             else
2127                 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2128
2129             *(c->fmt_ctx.streams[i]) = *src;
2130             c->fmt_ctx.streams[i]->priv_data = 0;
2131             /* XXX: should be done in AVStream, not in codec */
2132             c->fmt_ctx.streams[i]->codec->frame_number = 0;
2133         }
2134         /* set output format parameters */
2135         c->fmt_ctx.oformat = c->stream->fmt;
2136         c->fmt_ctx.nb_streams = c->stream->nb_streams;
2137
2138         c->got_key_frame = 0;
2139
2140         /* prepare header and save header data in a stream */
2141         if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2142             /* XXX: potential leak */
2143             return -1;
2144         }
2145         c->fmt_ctx.pb->seekable = 0;
2146
2147         /*
2148          * HACK to avoid MPEG-PS muxer to spit many underflow errors
2149          * Default value from FFmpeg
2150          * Try to set it using configuration option
2151          */
2152         c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2153
2154         if ((ret = avformat_write_header(&c->fmt_ctx, NULL)) < 0) {
2155             http_log("Error writing output header for stream '%s': %s\n",
2156                      c->stream->filename, av_err2str(ret));
2157             return ret;
2158         }
2159         av_dict_free(&c->fmt_ctx.metadata);
2160
2161         len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2162         c->buffer_ptr = c->pb_buffer;
2163         c->buffer_end = c->pb_buffer + len;
2164
2165         c->state = HTTPSTATE_SEND_DATA;
2166         c->last_packet_sent = 0;
2167         break;
2168     case HTTPSTATE_SEND_DATA:
2169         /* find a new packet */
2170         /* read a packet from the input stream */
2171         if (c->stream->feed)
2172             ffm_set_write_index(c->fmt_in,
2173                                 c->stream->feed->feed_write_index,
2174                                 c->stream->feed->feed_size);
2175
2176         if (c->stream->max_time &&
2177             c->stream->max_time + c->start_time - cur_time < 0)
2178             /* We have timed out */
2179             c->state = HTTPSTATE_SEND_DATA_TRAILER;
2180         else {
2181             AVPacket pkt;
2182         redo:
2183             ret = av_read_frame(c->fmt_in, &pkt);
2184             if (ret < 0) {
2185                 if (c->stream->feed) {
2186                     /* if coming from feed, it means we reached the end of the
2187                        ffm file, so must wait for more data */
2188                     c->state = HTTPSTATE_WAIT_FEED;
2189                     return 1; /* state changed */
2190                 } else if (ret == AVERROR(EAGAIN)) {
2191                     /* input not ready, come back later */
2192                     return 0;
2193                 } else {
2194                     if (c->stream->loop) {
2195                         avformat_close_input(&c->fmt_in);
2196                         if (open_input_stream(c, "") < 0)
2197                             goto no_loop;
2198                         goto redo;
2199                     } else {
2200                     no_loop:
2201                         /* must send trailer now because EOF or error */
2202                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
2203                     }
2204                 }
2205             } else {
2206                 int source_index = pkt.stream_index;
2207                 /* update first pts if needed */
2208                 if (c->first_pts == AV_NOPTS_VALUE) {
2209                     c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2210                     c->start_time = cur_time;
2211                 }
2212                 /* send it to the appropriate stream */
2213                 if (c->stream->feed) {
2214                     /* if coming from a feed, select the right stream */
2215                     if (c->switch_pending) {
2216                         c->switch_pending = 0;
2217                         for(i=0;i<c->stream->nb_streams;i++) {
2218                             if (c->switch_feed_streams[i] == pkt.stream_index)
2219                                 if (pkt.flags & AV_PKT_FLAG_KEY)
2220                                     c->switch_feed_streams[i] = -1;
2221                             if (c->switch_feed_streams[i] >= 0)
2222                                 c->switch_pending = 1;
2223                         }
2224                     }
2225                     for(i=0;i<c->stream->nb_streams;i++) {
2226                         if (c->stream->feed_streams[i] == pkt.stream_index) {
2227                             AVStream *st = c->fmt_in->streams[source_index];
2228                             pkt.stream_index = i;
2229                             if (pkt.flags & AV_PKT_FLAG_KEY &&
2230                                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2231                                  c->stream->nb_streams == 1))
2232                                 c->got_key_frame = 1;
2233                             if (!c->stream->send_on_key || c->got_key_frame)
2234                                 goto send_it;
2235                         }
2236                     }
2237                 } else {
2238                     AVCodecContext *codec;
2239                     AVStream *ist, *ost;
2240                 send_it:
2241                     ist = c->fmt_in->streams[source_index];
2242                     /* specific handling for RTP: we use several
2243                      * output streams (one for each RTP connection).
2244                      * XXX: need more abstract handling */
2245                     if (c->is_packetized) {
2246                         /* compute send time and duration */
2247                         c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2248                         c->cur_pts -= c->first_pts;
2249                         c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2250                         /* find RTP context */
2251                         c->packet_stream_index = pkt.stream_index;
2252                         ctx = c->rtp_ctx[c->packet_stream_index];
2253                         if(!ctx) {
2254                             av_free_packet(&pkt);
2255                             break;
2256                         }
2257                         codec = ctx->streams[0]->codec;
2258                         /* only one stream per RTP connection */
2259                         pkt.stream_index = 0;
2260                     } else {
2261                         ctx = &c->fmt_ctx;
2262                         /* Fudge here */
2263                         codec = ctx->streams[pkt.stream_index]->codec;
2264                     }
2265
2266                     if (c->is_packetized) {
2267                         int max_packet_size;
2268                         if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2269                             max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2270                         else
2271                             max_packet_size = c->rtp_handles[c->packet_stream_index]->max_packet_size;
2272                         ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2273                     } else {
2274                         ret = avio_open_dyn_buf(&ctx->pb);
2275                     }
2276                     if (ret < 0) {
2277                         /* XXX: potential leak */
2278                         return -1;
2279                     }
2280                     ost = ctx->streams[pkt.stream_index];
2281
2282                     ctx->pb->seekable = 0;
2283                     if (pkt.dts != AV_NOPTS_VALUE)
2284                         pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2285                     if (pkt.pts != AV_NOPTS_VALUE)
2286                         pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2287                     pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2288                     if ((ret = av_write_frame(ctx, &pkt)) < 0) {
2289                         http_log("Error writing frame to output for stream '%s': %s\n",
2290                                  c->stream->filename, av_err2str(ret));
2291                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
2292                     }
2293
2294                     av_freep(&c->pb_buffer);
2295                     len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2296                     c->cur_frame_bytes = len;
2297                     c->buffer_ptr = c->pb_buffer;
2298                     c->buffer_end = c->pb_buffer + len;
2299
2300                     codec->frame_number++;
2301                     if (len == 0) {
2302                         av_free_packet(&pkt);
2303                         goto redo;
2304                     }
2305                 }
2306                 av_free_packet(&pkt);
2307             }
2308         }
2309         break;
2310     default:
2311     case HTTPSTATE_SEND_DATA_TRAILER:
2312         /* last packet test ? */
2313         if (c->last_packet_sent || c->is_packetized)
2314             return -1;
2315         ctx = &c->fmt_ctx;
2316         /* prepare header */
2317         if (avio_open_dyn_buf(&ctx->pb) < 0) {
2318             /* XXX: potential leak */
2319             return -1;
2320         }
2321         c->fmt_ctx.pb->seekable = 0;
2322         av_write_trailer(ctx);
2323         len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2324         c->buffer_ptr = c->pb_buffer;
2325         c->buffer_end = c->pb_buffer + len;
2326
2327         c->last_packet_sent = 1;
2328         break;
2329     }
2330     return 0;
2331 }
2332
2333 /* should convert the format at the same time */
2334 /* send data starting at c->buffer_ptr to the output connection
2335  * (either UDP or TCP) */
2336 static int http_send_data(HTTPContext *c)
2337 {
2338     int len, ret;
2339
2340     for(;;) {
2341         if (c->buffer_ptr >= c->buffer_end) {
2342             ret = http_prepare_data(c);
2343             if (ret < 0)
2344                 return -1;
2345             else if (ret)
2346                 /* state change requested */
2347                 break;
2348         } else {
2349             if (c->is_packetized) {
2350                 /* RTP data output */
2351                 len = c->buffer_end - c->buffer_ptr;
2352                 if (len < 4) {
2353                     /* fail safe - should never happen */
2354                 fail1:
2355                     c->buffer_ptr = c->buffer_end;
2356                     return 0;
2357                 }
2358                 len = (c->buffer_ptr[0] << 24) |
2359                     (c->buffer_ptr[1] << 16) |
2360                     (c->buffer_ptr[2] << 8) |
2361                     (c->buffer_ptr[3]);
2362                 if (len > (c->buffer_end - c->buffer_ptr))
2363                     goto fail1;
2364                 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2365                     /* nothing to send yet: we can wait */
2366                     return 0;
2367                 }
2368
2369                 c->data_count += len;
2370                 update_datarate(&c->datarate, c->data_count);
2371                 if (c->stream)
2372                     c->stream->bytes_served += len;
2373
2374                 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2375                     /* RTP packets are sent inside the RTSP TCP connection */
2376                     AVIOContext *pb;
2377                     int interleaved_index, size;
2378                     uint8_t header[4];
2379                     HTTPContext *rtsp_c;
2380
2381                     rtsp_c = c->rtsp_c;
2382                     /* if no RTSP connection left, error */
2383                     if (!rtsp_c)
2384                         return -1;
2385                     /* if already sending something, then wait. */
2386                     if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2387                         break;
2388                     if (avio_open_dyn_buf(&pb) < 0)
2389                         goto fail1;
2390                     interleaved_index = c->packet_stream_index * 2;
2391                     /* RTCP packets are sent at odd indexes */
2392                     if (c->buffer_ptr[1] == 200)
2393                         interleaved_index++;
2394                     /* write RTSP TCP header */
2395                     header[0] = '$';
2396                     header[1] = interleaved_index;
2397                     header[2] = len >> 8;
2398                     header[3] = len;
2399                     avio_write(pb, header, 4);
2400                     /* write RTP packet data */
2401                     c->buffer_ptr += 4;
2402                     avio_write(pb, c->buffer_ptr, len);
2403                     size = avio_close_dyn_buf(pb, &c->packet_buffer);
2404                     /* prepare asynchronous TCP sending */
2405                     rtsp_c->packet_buffer_ptr = c->packet_buffer;
2406                     rtsp_c->packet_buffer_end = c->packet_buffer + size;
2407                     c->buffer_ptr += len;
2408
2409                     /* send everything we can NOW */
2410                     len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2411                                 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2412                     if (len > 0)
2413                         rtsp_c->packet_buffer_ptr += len;
2414                     if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2415                         /* if we could not send all the data, we will
2416                            send it later, so a new state is needed to
2417                            "lock" the RTSP TCP connection */
2418                         rtsp_c->state = RTSPSTATE_SEND_PACKET;
2419                         break;
2420                     } else
2421                         /* all data has been sent */
2422                         av_freep(&c->packet_buffer);
2423                 } else {
2424                     /* send RTP packet directly in UDP */
2425                     c->buffer_ptr += 4;
2426                     ffurl_write(c->rtp_handles[c->packet_stream_index],
2427                                 c->buffer_ptr, len);
2428                     c->buffer_ptr += len;
2429                     /* here we continue as we can send several packets per 10 ms slot */
2430                 }
2431             } else {
2432                 /* TCP data output */
2433                 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2434                 if (len < 0) {
2435                     if (ff_neterrno() != AVERROR(EAGAIN) &&
2436                         ff_neterrno() != AVERROR(EINTR))
2437                         /* error : close connection */
2438                         return -1;
2439                     else
2440                         return 0;
2441                 }
2442                 c->buffer_ptr += len;
2443
2444                 c->data_count += len;
2445                 update_datarate(&c->datarate, c->data_count);
2446                 if (c->stream)
2447                     c->stream->bytes_served += len;
2448                 break;
2449             }
2450         }
2451     } /* for(;;) */
2452     return 0;
2453 }
2454
2455 static int http_start_receive_data(HTTPContext *c)
2456 {
2457     int fd;
2458     int ret;
2459
2460     if (c->stream->feed_opened) {
2461         http_log("Stream feed '%s' was not opened\n", c->stream->feed_filename);
2462         return AVERROR(EINVAL);
2463     }
2464
2465     /* Don't permit writing to this one */
2466     if (c->stream->readonly) {
2467         http_log("Cannot write to read-only file '%s'\n", c->stream->feed_filename);
2468         return AVERROR(EINVAL);
2469     }
2470
2471     /* open feed */
2472     fd = open(c->stream->feed_filename, O_RDWR);
2473     if (fd < 0) {
2474         ret = AVERROR(errno);
2475         http_log("Could not open feed file '%s': %s\n",
2476                  c->stream->feed_filename, strerror(errno));
2477         return ret;
2478     }
2479     c->feed_fd = fd;
2480
2481     if (c->stream->truncate) {
2482         /* truncate feed file */
2483         ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2484         http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2485         if (ftruncate(c->feed_fd, FFM_PACKET_SIZE) < 0) {
2486             ret = AVERROR(errno);
2487             http_log("Error truncating feed file '%s': %s\n",
2488                      c->stream->feed_filename, strerror(errno));
2489             return ret;
2490         }
2491     } else {
2492         ret = ffm_read_write_index(fd);
2493         if (ret < 0) {
2494             http_log("Error reading write index from feed file '%s': %s\n",
2495                      c->stream->feed_filename, strerror(errno));
2496             return ret;
2497         } else {
2498             c->stream->feed_write_index = ret;
2499         }
2500     }
2501
2502     c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2503     c->stream->feed_size = lseek(fd, 0, SEEK_END);
2504     lseek(fd, 0, SEEK_SET);
2505
2506     /* init buffer input */
2507     c->buffer_ptr = c->buffer;
2508     c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2509     c->stream->feed_opened = 1;
2510     c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2511     return 0;
2512 }
2513
2514 static int http_receive_data(HTTPContext *c)
2515 {
2516     HTTPContext *c1;
2517     int len, loop_run = 0;
2518
2519     while (c->chunked_encoding && !c->chunk_size &&
2520            c->buffer_end > c->buffer_ptr) {
2521         /* read chunk header, if present */
2522         len = recv(c->fd, c->buffer_ptr, 1, 0);
2523
2524         if (len < 0) {
2525             if (ff_neterrno() != AVERROR(EAGAIN) &&
2526                 ff_neterrno() != AVERROR(EINTR))
2527                 /* error : close connection */
2528                 goto fail;
2529             return 0;
2530         } else if (len == 0) {
2531             /* end of connection : close it */
2532             goto fail;
2533         } else if (c->buffer_ptr - c->buffer >= 2 &&
2534                    !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2535             c->chunk_size = strtol(c->buffer, 0, 16);
2536             if (c->chunk_size == 0) // end of stream
2537                 goto fail;
2538             c->buffer_ptr = c->buffer;
2539             break;
2540         } else if (++loop_run > 10) {
2541             /* no chunk header, abort */
2542             goto fail;
2543         } else {
2544             c->buffer_ptr++;
2545         }
2546     }
2547
2548     if (c->buffer_end > c->buffer_ptr) {
2549         len = recv(c->fd, c->buffer_ptr,
2550                    FFMIN(c->chunk_size, 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                 goto fail;
2556         } else if (len == 0)
2557             /* end of connection : close it */
2558             goto fail;
2559         else {
2560             c->chunk_size -= len;
2561             c->buffer_ptr += len;
2562             c->data_count += len;
2563             update_datarate(&c->datarate, c->data_count);
2564         }
2565     }
2566
2567     if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2568         if (c->buffer[0] != 'f' ||
2569             c->buffer[1] != 'm') {
2570             http_log("Feed stream has become desynchronized -- disconnecting\n");
2571             goto fail;
2572         }
2573     }
2574
2575     if (c->buffer_ptr >= c->buffer_end) {
2576         FFServerStream *feed = c->stream;
2577         /* a packet has been received : write it in the store, except
2578            if header */
2579         if (c->data_count > FFM_PACKET_SIZE) {
2580             /* XXX: use llseek or url_seek
2581              * XXX: Should probably fail? */
2582             if (lseek(c->feed_fd, feed->feed_write_index, SEEK_SET) == -1)
2583                 http_log("Seek to %"PRId64" failed\n", feed->feed_write_index);
2584
2585             if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2586                 http_log("Error writing to feed file: %s\n", strerror(errno));
2587                 goto fail;
2588             }
2589
2590             feed->feed_write_index += FFM_PACKET_SIZE;
2591             /* update file size */
2592             if (feed->feed_write_index > c->stream->feed_size)
2593                 feed->feed_size = feed->feed_write_index;
2594
2595             /* handle wrap around if max file size reached */
2596             if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2597                 feed->feed_write_index = FFM_PACKET_SIZE;
2598
2599             /* write index */
2600             if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2601                 http_log("Error writing index to feed file: %s\n", strerror(errno));
2602                 goto fail;
2603             }
2604
2605             /* wake up any waiting connections */
2606             for(c1 = first_http_ctx; c1; c1 = c1->next) {
2607                 if (c1->state == HTTPSTATE_WAIT_FEED &&
2608                     c1->stream->feed == c->stream->feed)
2609                     c1->state = HTTPSTATE_SEND_DATA;
2610             }
2611         } else {
2612             /* We have a header in our hands that contains useful data */
2613             AVFormatContext *s = avformat_alloc_context();
2614             AVIOContext *pb;
2615             AVInputFormat *fmt_in;
2616             int i;
2617
2618             if (!s)
2619                 goto fail;
2620
2621             /* use feed output format name to find corresponding input format */
2622             fmt_in = av_find_input_format(feed->fmt->name);
2623             if (!fmt_in)
2624                 goto fail;
2625
2626             pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2627                                     0, NULL, NULL, NULL, NULL);
2628             pb->seekable = 0;
2629
2630             s->pb = pb;
2631             if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2632                 av_freep(&pb);
2633                 goto fail;
2634             }
2635
2636             /* Now we have the actual streams */
2637             if (s->nb_streams != feed->nb_streams) {
2638                 avformat_close_input(&s);
2639                 av_freep(&pb);
2640                 http_log("Feed '%s' stream number does not match registered feed\n",
2641                          c->stream->feed_filename);
2642                 goto fail;
2643             }
2644
2645             for (i = 0; i < s->nb_streams; i++) {
2646                 AVStream *fst = feed->streams[i];
2647                 AVStream *st = s->streams[i];
2648                 avcodec_copy_context(fst->codec, st->codec);
2649             }
2650
2651             avformat_close_input(&s);
2652             av_freep(&pb);
2653         }
2654         c->buffer_ptr = c->buffer;
2655     }
2656
2657     return 0;
2658  fail:
2659     c->stream->feed_opened = 0;
2660     close(c->feed_fd);
2661     /* wake up any waiting connections to stop waiting for feed */
2662     for(c1 = first_http_ctx; c1; c1 = c1->next) {
2663         if (c1->state == HTTPSTATE_WAIT_FEED &&
2664             c1->stream->feed == c->stream->feed)
2665             c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2666     }
2667     return -1;
2668 }
2669
2670 /********************************************************************/
2671 /* RTSP handling */
2672
2673 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2674 {
2675     const char *str;
2676     time_t ti;
2677     struct tm *tm;
2678     char buf2[32];
2679
2680     str = RTSP_STATUS_CODE2STRING(error_number);
2681     if (!str)
2682         str = "Unknown Error";
2683
2684     avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2685     avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2686
2687     /* output GMT time */
2688     ti = time(NULL);
2689     tm = gmtime(&ti);
2690     strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2691     avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2692 }
2693
2694 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2695 {
2696     rtsp_reply_header(c, error_number);
2697     avio_printf(c->pb, "\r\n");
2698 }
2699
2700 static int rtsp_parse_request(HTTPContext *c)
2701 {
2702     const char *p, *p1, *p2;
2703     char cmd[32];
2704     char url[1024];
2705     char protocol[32];
2706     char line[1024];
2707     int len;
2708     RTSPMessageHeader header1 = { 0 }, *header = &header1;
2709
2710     c->buffer_ptr[0] = '\0';
2711     p = c->buffer;
2712
2713     get_word(cmd, sizeof(cmd), &p);
2714     get_word(url, sizeof(url), &p);
2715     get_word(protocol, sizeof(protocol), &p);
2716
2717     av_strlcpy(c->method, cmd, sizeof(c->method));
2718     av_strlcpy(c->url, url, sizeof(c->url));
2719     av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2720
2721     if (avio_open_dyn_buf(&c->pb) < 0) {
2722         /* XXX: cannot do more */
2723         c->pb = NULL; /* safety */
2724         return -1;
2725     }
2726
2727     /* check version name */
2728     if (strcmp(protocol, "RTSP/1.0")) {
2729         rtsp_reply_error(c, RTSP_STATUS_VERSION);
2730         goto the_end;
2731     }
2732
2733     /* parse each header line */
2734     /* skip to next line */
2735     while (*p != '\n' && *p != '\0')
2736         p++;
2737     if (*p == '\n')
2738         p++;
2739     while (*p != '\0') {
2740         p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2741         if (!p1)
2742             break;
2743         p2 = p1;
2744         if (p2 > p && p2[-1] == '\r')
2745             p2--;
2746         /* skip empty line */
2747         if (p2 == p)
2748             break;
2749         len = p2 - p;
2750         if (len > sizeof(line) - 1)
2751             len = sizeof(line) - 1;
2752         memcpy(line, p, len);
2753         line[len] = '\0';
2754         ff_rtsp_parse_line(header, line, NULL, NULL);
2755         p = p1 + 1;
2756     }
2757
2758     /* handle sequence number */
2759     c->seq = header->seq;
2760
2761     if (!strcmp(cmd, "DESCRIBE"))
2762         rtsp_cmd_describe(c, url);
2763     else if (!strcmp(cmd, "OPTIONS"))
2764         rtsp_cmd_options(c, url);
2765     else if (!strcmp(cmd, "SETUP"))
2766         rtsp_cmd_setup(c, url, header);
2767     else if (!strcmp(cmd, "PLAY"))
2768         rtsp_cmd_play(c, url, header);
2769     else if (!strcmp(cmd, "PAUSE"))
2770         rtsp_cmd_interrupt(c, url, header, 1);
2771     else if (!strcmp(cmd, "TEARDOWN"))
2772         rtsp_cmd_interrupt(c, url, header, 0);
2773     else
2774         rtsp_reply_error(c, RTSP_STATUS_METHOD);
2775
2776  the_end:
2777     len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2778     c->pb = NULL; /* safety */
2779     if (len < 0) {
2780         /* XXX: cannot do more */
2781         return -1;
2782     }
2783     c->buffer_ptr = c->pb_buffer;
2784     c->buffer_end = c->pb_buffer + len;
2785     c->state = RTSPSTATE_SEND_REPLY;
2786     return 0;
2787 }
2788
2789 static int prepare_sdp_description(FFServerStream *stream, uint8_t **pbuffer,
2790                                    struct in_addr my_ip)
2791 {
2792     AVFormatContext *avc;
2793     AVStream *avs = NULL;
2794     AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
2795     AVDictionaryEntry *entry = av_dict_get(stream->metadata, "title", NULL, 0);
2796     int i;
2797
2798     *pbuffer = NULL;
2799
2800     avc =  avformat_alloc_context();
2801     if (!avc || !rtp_format) {
2802         return -1;
2803     }
2804     avc->oformat = rtp_format;
2805     av_dict_set(&avc->metadata, "title",
2806                 entry ? entry->value : "No Title", 0);
2807     avc->nb_streams = stream->nb_streams;
2808     if (stream->is_multicast) {
2809         snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2810                  inet_ntoa(stream->multicast_ip),
2811                  stream->multicast_port, stream->multicast_ttl);
2812     } else {
2813         snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2814     }
2815
2816     if (!(avc->streams = av_malloc_array(avc->nb_streams, sizeof(*avc->streams))))
2817         goto sdp_done;
2818     if (!(avs = av_malloc_array(avc->nb_streams, sizeof(*avs))))
2819         goto sdp_done;
2820
2821     for(i = 0; i < stream->nb_streams; i++) {
2822         avc->streams[i] = &avs[i];
2823         avc->streams[i]->codec = stream->streams[i]->codec;
2824     }
2825     *pbuffer = av_mallocz(2048);
2826     av_sdp_create(&avc, 1, *pbuffer, 2048);
2827
2828  sdp_done:
2829     av_freep(&avc->streams);
2830     av_dict_free(&avc->metadata);
2831     av_free(avc);
2832     av_free(avs);
2833
2834     return *pbuffer ? strlen(*pbuffer) : AVERROR(ENOMEM);
2835 }
2836
2837 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2838 {
2839 //    rtsp_reply_header(c, RTSP_STATUS_OK);
2840     avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2841     avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2842     avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2843     avio_printf(c->pb, "\r\n");
2844 }
2845
2846 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2847 {
2848     FFServerStream *stream;
2849     char path1[1024];
2850     const char *path;
2851     uint8_t *content;
2852     int content_length;
2853     socklen_t len;
2854     struct sockaddr_in my_addr;
2855
2856     /* find which URL is asked */
2857     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2858     path = path1;
2859     if (*path == '/')
2860         path++;
2861
2862     for(stream = config.first_stream; stream; stream = stream->next) {
2863         if (!stream->is_feed &&
2864             stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2865             !strcmp(path, stream->filename)) {
2866             goto found;
2867         }
2868     }
2869     /* no stream found */
2870     rtsp_reply_error(c, RTSP_STATUS_NOT_FOUND);
2871     return;
2872
2873  found:
2874     /* prepare the media description in SDP format */
2875
2876     /* get the host IP */
2877     len = sizeof(my_addr);
2878     getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2879     content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
2880     if (content_length < 0) {
2881         rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2882         return;
2883     }
2884     rtsp_reply_header(c, RTSP_STATUS_OK);
2885     avio_printf(c->pb, "Content-Base: %s/\r\n", url);
2886     avio_printf(c->pb, "Content-Type: application/sdp\r\n");
2887     avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
2888     avio_printf(c->pb, "\r\n");
2889     avio_write(c->pb, content, content_length);
2890     av_free(content);
2891 }
2892
2893 static HTTPContext *find_rtp_session(const char *session_id)
2894 {
2895     HTTPContext *c;
2896
2897     if (session_id[0] == '\0')
2898         return NULL;
2899
2900     for(c = first_http_ctx; c; c = c->next) {
2901         if (!strcmp(c->session_id, session_id))
2902             return c;
2903     }
2904     return NULL;
2905 }
2906
2907 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
2908 {
2909     RTSPTransportField *th;
2910     int i;
2911
2912     for(i=0;i<h->nb_transports;i++) {
2913         th = &h->transports[i];
2914         if (th->lower_transport == lower_transport)
2915             return th;
2916     }
2917     return NULL;
2918 }
2919
2920 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
2921                            RTSPMessageHeader *h)
2922 {
2923     FFServerStream *stream;
2924     int stream_index, rtp_port, rtcp_port;
2925     char buf[1024];
2926     char path1[1024];
2927     const char *path;
2928     HTTPContext *rtp_c;
2929     RTSPTransportField *th;
2930     struct sockaddr_in dest_addr;
2931     RTSPActionServerSetup setup;
2932
2933     /* find which URL is asked */
2934     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2935     path = path1;
2936     if (*path == '/')
2937         path++;
2938
2939     /* now check each stream */
2940     for(stream = config.first_stream; stream; stream = stream->next) {
2941         if (stream->is_feed || !stream->fmt ||
2942             strcmp(stream->fmt->name, "rtp")) {
2943             continue;
2944         }
2945         /* accept aggregate filenames only if single stream */
2946         if (!strcmp(path, stream->filename)) {
2947             if (stream->nb_streams != 1) {
2948                 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
2949                 return;
2950             }
2951             stream_index = 0;
2952             goto found;
2953         }
2954
2955         for(stream_index = 0; stream_index < stream->nb_streams;
2956             stream_index++) {
2957             snprintf(buf, sizeof(buf), "%s/streamid=%d",
2958                      stream->filename, stream_index);
2959             if (!strcmp(path, buf))
2960                 goto found;
2961         }
2962     }
2963     /* no stream found */
2964     rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2965     return;
2966  found:
2967
2968     /* generate session id if needed */
2969     if (h->session_id[0] == '\0') {
2970         unsigned random0 = av_lfg_get(&random_state);
2971         unsigned random1 = av_lfg_get(&random_state);
2972         snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
2973                  random0, random1);
2974     }
2975
2976     /* find RTP session, and create it if none found */
2977     rtp_c = find_rtp_session(h->session_id);
2978     if (!rtp_c) {
2979         /* always prefer UDP */
2980         th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
2981         if (!th) {
2982             th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
2983             if (!th) {
2984                 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2985                 return;
2986             }
2987         }
2988
2989         rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
2990                                    th->lower_transport);
2991         if (!rtp_c) {
2992             rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
2993             return;
2994         }
2995
2996         /* open input stream */
2997         if (open_input_stream(rtp_c, "") < 0) {
2998             rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2999             return;
3000         }
3001     }
3002
3003     /* test if stream is OK (test needed because several SETUP needs
3004        to be done for a given file) */
3005     if (rtp_c->stream != stream) {
3006         rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3007         return;
3008     }
3009
3010     /* test if stream is already set up */
3011     if (rtp_c->rtp_ctx[stream_index]) {
3012         rtsp_reply_error(c, RTSP_STATUS_STATE);
3013         return;
3014     }
3015
3016     /* check transport */
3017     th = find_transport(h, rtp_c->rtp_protocol);
3018     if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3019                 th->client_port_min <= 0)) {
3020         rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3021         return;
3022     }
3023
3024     /* setup default options */
3025     setup.transport_option[0] = '\0';
3026     dest_addr = rtp_c->from_addr;
3027     dest_addr.sin_port = htons(th->client_port_min);
3028
3029     /* setup stream */
3030     if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3031         rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3032         return;
3033     }
3034
3035     /* now everything is OK, so we can send the connection parameters */
3036     rtsp_reply_header(c, RTSP_STATUS_OK);
3037     /* session ID */
3038     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3039
3040     switch(rtp_c->rtp_protocol) {
3041     case RTSP_LOWER_TRANSPORT_UDP:
3042         rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3043         rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3044         avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3045                     "client_port=%d-%d;server_port=%d-%d",
3046                     th->client_port_min, th->client_port_max,
3047                     rtp_port, rtcp_port);
3048         break;
3049     case RTSP_LOWER_TRANSPORT_TCP:
3050         avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3051                     stream_index * 2, stream_index * 2 + 1);
3052         break;
3053     default:
3054         break;
3055     }
3056     if (setup.transport_option[0] != '\0')
3057         avio_printf(c->pb, ";%s", setup.transport_option);
3058     avio_printf(c->pb, "\r\n");
3059
3060
3061     avio_printf(c->pb, "\r\n");
3062 }
3063
3064
3065 /* find an RTP connection by using the session ID. Check consistency
3066    with filename */
3067 static HTTPContext *find_rtp_session_with_url(const char *url,
3068                                               const char *session_id)
3069 {
3070     HTTPContext *rtp_c;
3071     char path1[1024];
3072     const char *path;
3073     char buf[1024];
3074     int s, len;
3075
3076     rtp_c = find_rtp_session(session_id);
3077     if (!rtp_c)
3078         return NULL;
3079
3080     /* find which URL is asked */
3081     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3082     path = path1;
3083     if (*path == '/')
3084         path++;
3085     if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3086     for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3087       snprintf(buf, sizeof(buf), "%s/streamid=%d",
3088         rtp_c->stream->filename, s);
3089       if(!strncmp(path, buf, sizeof(buf))) {
3090     // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3091         return rtp_c;
3092       }
3093     }
3094     len = strlen(path);
3095     if (len > 0 && path[len - 1] == '/' &&
3096         !strncmp(path, rtp_c->stream->filename, len - 1))
3097         return rtp_c;
3098     return NULL;
3099 }
3100
3101 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3102 {
3103     HTTPContext *rtp_c;
3104
3105     rtp_c = find_rtp_session_with_url(url, h->session_id);
3106     if (!rtp_c) {
3107         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3108         return;
3109     }
3110
3111     if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3112         rtp_c->state != HTTPSTATE_WAIT_FEED &&
3113         rtp_c->state != HTTPSTATE_READY) {
3114         rtsp_reply_error(c, RTSP_STATUS_STATE);
3115         return;
3116     }
3117
3118     rtp_c->state = HTTPSTATE_SEND_DATA;
3119
3120     /* now everything is OK, so we can send the connection parameters */
3121     rtsp_reply_header(c, RTSP_STATUS_OK);
3122     /* session ID */
3123     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3124     avio_printf(c->pb, "\r\n");
3125 }
3126
3127 static void rtsp_cmd_interrupt(HTTPContext *c, const char *url, RTSPMessageHeader *h, int pause_only)
3128 {
3129     HTTPContext *rtp_c;
3130
3131     rtp_c = find_rtp_session_with_url(url, h->session_id);
3132     if (!rtp_c) {
3133         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3134         return;
3135     }
3136
3137     if (pause_only) {
3138         if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3139             rtp_c->state != HTTPSTATE_WAIT_FEED) {
3140             rtsp_reply_error(c, RTSP_STATUS_STATE);
3141             return;
3142         }
3143         rtp_c->state = HTTPSTATE_READY;
3144         rtp_c->first_pts = AV_NOPTS_VALUE;
3145     }
3146
3147     /* now everything is OK, so we can send the connection parameters */
3148     rtsp_reply_header(c, RTSP_STATUS_OK);
3149     /* session ID */
3150     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3151     avio_printf(c->pb, "\r\n");
3152
3153     if (!pause_only)
3154         close_connection(rtp_c);
3155 }
3156
3157 /********************************************************************/
3158 /* RTP handling */
3159
3160 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3161                                        FFServerStream *stream, const char *session_id,
3162                                        enum RTSPLowerTransport rtp_protocol)
3163 {
3164     HTTPContext *c = NULL;
3165     const char *proto_str;
3166
3167     /* XXX: should output a warning page when coming
3168        close to the connection limit */
3169     if (nb_connections >= config.nb_max_connections)
3170         goto fail;
3171
3172     /* add a new connection */
3173     c = av_mallocz(sizeof(HTTPContext));
3174     if (!c)
3175         goto fail;
3176
3177     c->fd = -1;
3178     c->poll_entry = NULL;
3179     c->from_addr = *from_addr;
3180     c->buffer_size = IOBUFFER_INIT_SIZE;
3181     c->buffer = av_malloc(c->buffer_size);
3182     if (!c->buffer)
3183         goto fail;
3184     nb_connections++;
3185     c->stream = stream;
3186     av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3187     c->state = HTTPSTATE_READY;
3188     c->is_packetized = 1;
3189     c->rtp_protocol = rtp_protocol;
3190
3191     /* protocol is shown in statistics */
3192     switch(c->rtp_protocol) {
3193     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3194         proto_str = "MCAST";
3195         break;
3196     case RTSP_LOWER_TRANSPORT_UDP:
3197         proto_str = "UDP";
3198         break;
3199     case RTSP_LOWER_TRANSPORT_TCP:
3200         proto_str = "TCP";
3201         break;
3202     default:
3203         proto_str = "???";
3204         break;
3205     }
3206     av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3207     av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3208
3209     current_bandwidth += stream->bandwidth;
3210
3211     c->next = first_http_ctx;
3212     first_http_ctx = c;
3213     return c;
3214
3215  fail:
3216     if (c) {
3217         av_freep(&c->buffer);
3218         av_free(c);
3219     }
3220     return NULL;
3221 }
3222
3223 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3224    command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3225    used. */
3226 static int rtp_new_av_stream(HTTPContext *c,
3227                              int stream_index, struct sockaddr_in *dest_addr,
3228                              HTTPContext *rtsp_c)
3229 {
3230     AVFormatContext *ctx;
3231     AVStream *st;
3232     char *ipaddr;
3233     URLContext *h = NULL;
3234     uint8_t *dummy_buf;
3235     int max_packet_size;
3236
3237     /* now we can open the relevant output stream */
3238     ctx = avformat_alloc_context();
3239     if (!ctx)
3240         return -1;
3241     ctx->oformat = av_guess_format("rtp", NULL, NULL);
3242
3243     st = av_mallocz(sizeof(AVStream));
3244     if (!st)
3245         goto fail;
3246     ctx->nb_streams = 1;
3247     ctx->streams = av_mallocz_array(ctx->nb_streams, sizeof(AVStream *));
3248     if (!ctx->streams)
3249       goto fail;
3250     ctx->streams[0] = st;
3251
3252     if (!c->stream->feed ||
3253         c->stream->feed == c->stream)
3254         memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3255     else
3256         memcpy(st,
3257                c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3258                sizeof(AVStream));
3259     st->priv_data = NULL;
3260
3261     /* build destination RTP address */
3262     ipaddr = inet_ntoa(dest_addr->sin_addr);
3263
3264     switch(c->rtp_protocol) {
3265     case RTSP_LOWER_TRANSPORT_UDP:
3266     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3267         /* RTP/UDP case */
3268
3269         /* XXX: also pass as parameter to function ? */
3270         if (c->stream->is_multicast) {
3271             int ttl;
3272             ttl = c->stream->multicast_ttl;
3273             if (!ttl)
3274                 ttl = 16;
3275             snprintf(ctx->filename, sizeof(ctx->filename),
3276                      "rtp://%s:%d?multicast=1&ttl=%d",
3277                      ipaddr, ntohs(dest_addr->sin_port), ttl);
3278         } else {
3279             snprintf(ctx->filename, sizeof(ctx->filename),
3280                      "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3281         }
3282
3283         if (ffurl_open(&h, ctx->filename, AVIO_FLAG_WRITE, NULL, NULL) < 0)
3284             goto fail;
3285         c->rtp_handles[stream_index] = h;
3286         max_packet_size = h->max_packet_size;
3287         break;
3288     case RTSP_LOWER_TRANSPORT_TCP:
3289         /* RTP/TCP case */
3290         c->rtsp_c = rtsp_c;
3291         max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3292         break;
3293     default:
3294         goto fail;
3295     }
3296
3297     http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3298              ipaddr, ntohs(dest_addr->sin_port),
3299              c->stream->filename, stream_index, c->protocol);
3300
3301     /* normally, no packets should be output here, but the packet size may
3302      * be checked */
3303     if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3304         /* XXX: close stream */
3305         goto fail;
3306     }
3307     if (avformat_write_header(ctx, NULL) < 0) {
3308     fail:
3309         if (h)
3310             ffurl_close(h);
3311         av_free(st);
3312         av_free(ctx);
3313         return -1;
3314     }
3315     avio_close_dyn_buf(ctx->pb, &dummy_buf);
3316     av_free(dummy_buf);
3317
3318     c->rtp_ctx[stream_index] = ctx;
3319     return 0;
3320 }
3321
3322 /********************************************************************/
3323 /* ffserver initialization */
3324
3325 static AVStream *add_av_stream1(FFServerStream *stream, AVCodecContext *codec, int copy)
3326 {
3327     AVStream *fst;
3328
3329     if(stream->nb_streams >= FF_ARRAY_ELEMS(stream->streams))
3330         return NULL;
3331
3332     fst = av_mallocz(sizeof(AVStream));
3333     if (!fst)
3334         return NULL;
3335     if (copy) {
3336         fst->codec = avcodec_alloc_context3(codec->codec);
3337         avcodec_copy_context(fst->codec, codec);
3338     } else {
3339         /* live streams must use the actual feed's codec since it may be
3340          * updated later to carry extradata needed by them.
3341          */
3342         fst->codec = codec;
3343     }
3344     fst->priv_data = av_mallocz(sizeof(FeedData));
3345     fst->index = stream->nb_streams;
3346     avpriv_set_pts_info(fst, 33, 1, 90000);
3347     fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3348     stream->streams[stream->nb_streams++] = fst;
3349     return fst;
3350 }
3351
3352 /* return the stream number in the feed */
3353 static int add_av_stream(FFServerStream *feed, AVStream *st)
3354 {
3355     AVStream *fst;
3356     AVCodecContext *av, *av1;
3357     int i;
3358
3359     av = st->codec;
3360     for(i=0;i<feed->nb_streams;i++) {
3361         av1 = feed->streams[i]->codec;
3362         if (av1->codec_id == av->codec_id &&
3363             av1->codec_type == av->codec_type &&
3364             av1->bit_rate == av->bit_rate) {
3365
3366             switch(av->codec_type) {
3367             case AVMEDIA_TYPE_AUDIO:
3368                 if (av1->channels == av->channels &&
3369                     av1->sample_rate == av->sample_rate)
3370                     return i;
3371                 break;
3372             case AVMEDIA_TYPE_VIDEO:
3373                 if (av1->width == av->width &&
3374                     av1->height == av->height &&
3375                     av1->time_base.den == av->time_base.den &&
3376                     av1->time_base.num == av->time_base.num &&
3377                     av1->gop_size == av->gop_size)
3378                     return i;
3379                 break;
3380             default:
3381                 abort();
3382             }
3383         }
3384     }
3385
3386     fst = add_av_stream1(feed, av, 0);
3387     if (!fst)
3388         return -1;
3389     if (av_stream_get_recommended_encoder_configuration(st))
3390         av_stream_set_recommended_encoder_configuration(fst,
3391             av_strdup(av_stream_get_recommended_encoder_configuration(st)));
3392     return feed->nb_streams - 1;
3393 }
3394
3395 static void remove_stream(FFServerStream *stream)
3396 {
3397     FFServerStream **ps;
3398     ps = &config.first_stream;
3399     while (*ps) {
3400         if (*ps == stream)
3401             *ps = (*ps)->next;
3402         else
3403             ps = &(*ps)->next;
3404     }
3405 }
3406
3407 /* specific MPEG4 handling : we extract the raw parameters */
3408 static void extract_mpeg4_header(AVFormatContext *infile)
3409 {
3410     int mpeg4_count, i, size;
3411     AVPacket pkt;
3412     AVStream *st;
3413     const uint8_t *p;
3414
3415     infile->flags |= AVFMT_FLAG_NOFILLIN | AVFMT_FLAG_NOPARSE;
3416
3417     mpeg4_count = 0;
3418     for(i=0;i<infile->nb_streams;i++) {
3419         st = infile->streams[i];
3420         if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3421             st->codec->extradata_size == 0) {
3422             mpeg4_count++;
3423         }
3424     }
3425     if (!mpeg4_count)
3426         return;
3427
3428     printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3429     while (mpeg4_count > 0) {
3430         if (av_read_frame(infile, &pkt) < 0)
3431             break;
3432         st = infile->streams[pkt.stream_index];
3433         if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3434             st->codec->extradata_size == 0) {
3435             av_freep(&st->codec->extradata);
3436             /* fill extradata with the header */
3437             /* XXX: we make hard suppositions here ! */
3438             p = pkt.data;
3439             while (p < pkt.data + pkt.size - 4) {
3440                 /* stop when vop header is found */
3441                 if (p[0] == 0x00 && p[1] == 0x00 &&
3442                     p[2] == 0x01 && p[3] == 0xb6) {
3443                     size = p - pkt.data;
3444                     //                    av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3445                     st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
3446                     st->codec->extradata_size = size;
3447                     memcpy(st->codec->extradata, pkt.data, size);
3448                     break;
3449                 }
3450                 p++;
3451             }
3452             mpeg4_count--;
3453         }
3454         av_free_packet(&pkt);
3455     }
3456 }
3457
3458 /* compute the needed AVStream for each file */
3459 static void build_file_streams(void)
3460 {
3461     FFServerStream *stream, *stream_next;
3462     int i, ret;
3463
3464     /* gather all streams */
3465     for(stream = config.first_stream; stream; stream = stream_next) {
3466         AVFormatContext *infile = NULL;
3467         stream_next = stream->next;
3468         if (stream->stream_type == STREAM_TYPE_LIVE &&
3469             !stream->feed) {
3470             /* the stream comes from a file */
3471             /* try to open the file */
3472             /* open stream */
3473             if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3474                 /* specific case : if transport stream output to RTP,
3475                    we use a raw transport stream reader */
3476                 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3477             }
3478
3479             if (!stream->feed_filename[0]) {
3480                 http_log("Unspecified feed file for stream '%s'\n", stream->filename);
3481                 goto fail;
3482             }
3483
3484             http_log("Opening feed file '%s' for stream '%s'\n", stream->feed_filename, stream->filename);
3485             if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3486                 http_log("Could not open '%s': %s\n", stream->feed_filename, av_err2str(ret));
3487                 /* remove stream (no need to spend more time on it) */
3488             fail:
3489                 remove_stream(stream);
3490             } else {
3491                 /* find all the AVStreams inside and reference them in
3492                    'stream' */
3493                 if (avformat_find_stream_info(infile, NULL) < 0) {
3494                     http_log("Could not find codec parameters from '%s'\n",
3495                              stream->feed_filename);
3496                     avformat_close_input(&infile);
3497                     goto fail;
3498                 }
3499                 extract_mpeg4_header(infile);
3500
3501                 for(i=0;i<infile->nb_streams;i++)
3502                     add_av_stream1(stream, infile->streams[i]->codec, 1);
3503
3504                 avformat_close_input(&infile);
3505             }
3506         }
3507     }
3508 }
3509
3510 /* compute the needed AVStream for each feed */
3511 static void build_feed_streams(void)
3512 {
3513     FFServerStream *stream, *feed;
3514     int i;
3515
3516     /* gather all streams */
3517     for(stream = config.first_stream; stream; stream = stream->next) {
3518         feed = stream->feed;
3519         if (feed) {
3520             if (stream->is_feed) {
3521                 for(i=0;i<stream->nb_streams;i++)
3522                     stream->feed_streams[i] = i;
3523             } else {
3524                 /* we handle a stream coming from a feed */
3525                 for(i=0;i<stream->nb_streams;i++)
3526                     stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3527             }
3528         }
3529     }
3530
3531     /* create feed files if needed */
3532     for(feed = config.first_feed; feed; feed = feed->next_feed) {
3533         int fd;
3534
3535         if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3536             /* See if it matches */
3537             AVFormatContext *s = NULL;
3538             int matches = 0;
3539
3540             if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3541                 /* set buffer size */
3542                 ffio_set_buf_size(s->pb, FFM_PACKET_SIZE);
3543                 /* Now see if it matches */
3544                 if (s->nb_streams == feed->nb_streams) {
3545                     matches = 1;
3546                     for(i=0;i<s->nb_streams;i++) {
3547                         AVStream *sf, *ss;
3548                         sf = feed->streams[i];
3549                         ss = s->streams[i];
3550
3551                         if (sf->index != ss->index ||
3552                             sf->id != ss->id) {
3553                             http_log("Index & Id do not match for stream %d (%s)\n",
3554                                    i, feed->feed_filename);
3555                             matches = 0;
3556                         } else {
3557                             AVCodecContext *ccf, *ccs;
3558
3559                             ccf = sf->codec;
3560                             ccs = ss->codec;
3561 #define CHECK_CODEC(x)  (ccf->x != ccs->x)
3562
3563                             if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3564                                 http_log("Codecs do not match for stream %d\n", i);
3565                                 matches = 0;
3566                             } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3567                                 http_log("Codec bitrates do not match for stream %d\n", i);
3568                                 matches = 0;
3569                             } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3570                                 if (CHECK_CODEC(time_base.den) ||
3571                                     CHECK_CODEC(time_base.num) ||
3572                                     CHECK_CODEC(width) ||
3573                                     CHECK_CODEC(height)) {
3574                                     http_log("Codec width, height and framerate do not match for stream %d\n", i);
3575                                     matches = 0;
3576                                 }
3577                             } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3578                                 if (CHECK_CODEC(sample_rate) ||
3579                                     CHECK_CODEC(channels) ||
3580                                     CHECK_CODEC(frame_size)) {
3581                                     http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3582                                     matches = 0;
3583                                 }
3584                             } else {
3585                                 http_log("Unknown codec type\n");
3586                                 matches = 0;
3587                             }
3588                         }
3589                         if (!matches)
3590                             break;
3591                     }
3592                 } else
3593                     http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3594                         feed->feed_filename, s->nb_streams, feed->nb_streams);
3595
3596                 avformat_close_input(&s);
3597             } else
3598                 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3599                         feed->feed_filename);
3600
3601             if (!matches) {
3602                 if (feed->readonly) {
3603                     http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3604                         feed->feed_filename);
3605                     exit(1);
3606                 }
3607                 unlink(feed->feed_filename);
3608             }
3609         }
3610         if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3611             AVFormatContext *s = avformat_alloc_context();
3612
3613             if (feed->readonly) {
3614                 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3615                     feed->feed_filename);
3616                 exit(1);
3617             }
3618
3619             /* only write the header of the ffm file */
3620             if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3621                 http_log("Could not open output feed file '%s'\n",
3622                          feed->feed_filename);
3623                 exit(1);
3624             }
3625             s->oformat = feed->fmt;
3626             s->nb_streams = feed->nb_streams;
3627             s->streams = feed->streams;
3628             if (avformat_write_header(s, NULL) < 0) {
3629                 http_log("Container doesn't support the required parameters\n");
3630                 exit(1);
3631             }
3632             /* XXX: need better API */
3633             av_freep(&s->priv_data);
3634             avio_closep(&s->pb);
3635             s->streams = NULL;
3636             s->nb_streams = 0;
3637             avformat_free_context(s);
3638         }
3639         /* get feed size and write index */
3640         fd = open(feed->feed_filename, O_RDONLY);
3641         if (fd < 0) {
3642             http_log("Could not open output feed file '%s'\n",
3643                     feed->feed_filename);
3644             exit(1);
3645         }
3646
3647         feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3648         feed->feed_size = lseek(fd, 0, SEEK_END);
3649         /* ensure that we do not wrap before the end of file */
3650         if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3651             feed->feed_max_size = feed->feed_size;
3652
3653         close(fd);
3654     }
3655 }
3656
3657 /* compute the bandwidth used by each stream */
3658 static void compute_bandwidth(void)
3659 {
3660     unsigned bandwidth;
3661     int i;
3662     FFServerStream *stream;
3663
3664     for(stream = config.first_stream; stream; stream = stream->next) {
3665         bandwidth = 0;
3666         for(i=0;i<stream->nb_streams;i++) {
3667             AVStream *st = stream->streams[i];
3668             switch(st->codec->codec_type) {
3669             case AVMEDIA_TYPE_AUDIO:
3670             case AVMEDIA_TYPE_VIDEO:
3671                 bandwidth += st->codec->bit_rate;
3672                 break;
3673             default:
3674                 break;
3675             }
3676         }
3677         stream->bandwidth = (bandwidth + 999) / 1000;
3678     }
3679 }
3680
3681 static void handle_child_exit(int sig)
3682 {
3683     pid_t pid;
3684     int status;
3685
3686     while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
3687         FFServerStream *feed;
3688
3689         for (feed = config.first_feed; feed; feed = feed->next) {
3690             if (feed->pid == pid) {
3691                 int uptime = time(0) - feed->pid_start;
3692
3693                 feed->pid = 0;
3694                 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
3695
3696                 if (uptime < 30)
3697                     /* Turn off any more restarts */
3698                     ffserver_free_child_args(&feed->child_argv);
3699             }
3700         }
3701     }
3702
3703     need_to_start_children = 1;
3704 }
3705
3706 static void opt_debug(void)
3707 {
3708     config.debug = 1;
3709     snprintf(config.logfilename, sizeof(config.logfilename), "-");
3710 }
3711
3712 void show_help_default(const char *opt, const char *arg)
3713 {
3714     printf("usage: ffserver [options]\n"
3715            "Hyper fast multi format Audio/Video streaming server\n");
3716     printf("\n");
3717     show_help_options(options, "Main options:", 0, 0, 0);
3718 }
3719
3720 static const OptionDef options[] = {
3721 #include "cmdutils_common_opts.h"
3722     { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
3723     { "d", 0, {(void*)opt_debug}, "enable debug mode" },
3724     { "f", HAS_ARG | OPT_STRING, {(void*)&config.filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
3725     { NULL },
3726 };
3727
3728 int main(int argc, char **argv)
3729 {
3730     struct sigaction sigact = { { 0 } };
3731     int ret = 0;
3732
3733     config.filename = av_strdup("/etc/ffserver.conf");
3734
3735     parse_loglevel(argc, argv, options);
3736     av_register_all();
3737     avformat_network_init();
3738
3739     show_banner(argc, argv, options);
3740
3741     my_program_name = argv[0];
3742
3743     parse_options(NULL, argc, argv, options, NULL);
3744
3745     unsetenv("http_proxy");             /* Kill the http_proxy */
3746
3747     av_lfg_init(&random_state, av_get_random_seed());
3748
3749     sigact.sa_handler = handle_child_exit;
3750     sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
3751     sigaction(SIGCHLD, &sigact, 0);
3752
3753     if ((ret = ffserver_parse_ffconfig(config.filename, &config)) < 0) {
3754         fprintf(stderr, "Error reading configuration file '%s': %s\n",
3755                 config.filename, av_err2str(ret));
3756         exit(1);
3757     }
3758     av_freep(&config.filename);
3759
3760     /* open log file if needed */
3761     if (config.logfilename[0] != '\0') {
3762         if (!strcmp(config.logfilename, "-"))
3763             logfile = stdout;
3764         else
3765             logfile = fopen(config.logfilename, "a");
3766         av_log_set_callback(http_av_log);
3767     }
3768
3769     build_file_streams();
3770
3771     build_feed_streams();
3772
3773     compute_bandwidth();
3774
3775     /* signal init */
3776     signal(SIGPIPE, SIG_IGN);
3777
3778     if (http_server() < 0) {
3779         http_log("Could not start server\n");
3780         exit(1);
3781     }
3782
3783     return 0;
3784 }