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