ffserver: break some 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     ret = avformat_open_input(&s, input_filename, c->stream->ifmt,
2056                               &c->stream->in_opts);
2057     if (ret < 0) {
2058         http_log("Could not open input '%s': %s\n",
2059                  input_filename, av_err2str(ret));
2060         return ret;
2061     }
2062
2063     /* set buffer size */
2064     if (buf_size > 0) ffio_set_buf_size(s->pb, buf_size);
2065
2066     s->flags |= AVFMT_FLAG_GENPTS;
2067     c->fmt_in = s;
2068     if (strcmp(s->iformat->name, "ffm") &&
2069         (ret = avformat_find_stream_info(c->fmt_in, NULL)) < 0) {
2070         http_log("Could not find stream info for input '%s'\n", input_filename);
2071         avformat_close_input(&s);
2072         return ret;
2073     }
2074
2075     /* choose stream as clock source (we favor the video stream if
2076      * present) for packet sending */
2077     c->pts_stream_index = 0;
2078     for(i=0;i<c->stream->nb_streams;i++) {
2079         if (c->pts_stream_index == 0 &&
2080             c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2081             c->pts_stream_index = i;
2082         }
2083     }
2084
2085     if (c->fmt_in->iformat->read_seek)
2086         av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2087     /* set the start time (needed for maxtime and RTP packet timing) */
2088     c->start_time = cur_time;
2089     c->first_pts = AV_NOPTS_VALUE;
2090     return 0;
2091 }
2092
2093 /* return the server clock (in us) */
2094 static int64_t get_server_clock(HTTPContext *c)
2095 {
2096     /* compute current pts value from system time */
2097     return (cur_time - c->start_time) * 1000;
2098 }
2099
2100 /* return the estimated time at which the current packet must be sent
2101    (in us) */
2102 static int64_t get_packet_send_clock(HTTPContext *c)
2103 {
2104     int bytes_left, bytes_sent, frame_bytes;
2105
2106     frame_bytes = c->cur_frame_bytes;
2107     if (frame_bytes <= 0)
2108         return c->cur_pts;
2109     else {
2110         bytes_left = c->buffer_end - c->buffer_ptr;
2111         bytes_sent = frame_bytes - bytes_left;
2112         return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2113     }
2114 }
2115
2116
2117 static int http_prepare_data(HTTPContext *c)
2118 {
2119     int i, len, ret;
2120     AVFormatContext *ctx;
2121
2122     av_freep(&c->pb_buffer);
2123     switch(c->state) {
2124     case HTTPSTATE_SEND_DATA_HEADER:
2125         ctx = avformat_alloc_context();
2126         c->fmt_ctx = *ctx;
2127         av_freep(&ctx);
2128         av_dict_copy(&(c->fmt_ctx.metadata), c->stream->metadata, 0);
2129         c->fmt_ctx.streams = av_mallocz_array(c->stream->nb_streams,
2130                                               sizeof(AVStream *));
2131
2132         for(i=0;i<c->stream->nb_streams;i++) {
2133             AVStream *src;
2134             c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2135             /* if file or feed, then just take streams from FFServerStream struct */
2136             if (!c->stream->feed ||
2137                 c->stream->feed == c->stream)
2138                 src = c->stream->streams[i];
2139             else
2140                 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2141
2142             *(c->fmt_ctx.streams[i]) = *src;
2143             c->fmt_ctx.streams[i]->priv_data = 0;
2144             /* XXX: should be done in AVStream, not in codec */
2145             c->fmt_ctx.streams[i]->codec->frame_number = 0;
2146         }
2147         /* set output format parameters */
2148         c->fmt_ctx.oformat = c->stream->fmt;
2149         c->fmt_ctx.nb_streams = c->stream->nb_streams;
2150
2151         c->got_key_frame = 0;
2152
2153         /* prepare header and save header data in a stream */
2154         if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2155             /* XXX: potential leak */
2156             return -1;
2157         }
2158         c->fmt_ctx.pb->seekable = 0;
2159
2160         /*
2161          * HACK to avoid MPEG-PS muxer to spit many underflow errors
2162          * Default value from FFmpeg
2163          * Try to set it using configuration option
2164          */
2165         c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2166
2167         if ((ret = avformat_write_header(&c->fmt_ctx, NULL)) < 0) {
2168             http_log("Error writing output header for stream '%s': %s\n",
2169                      c->stream->filename, av_err2str(ret));
2170             return ret;
2171         }
2172         av_dict_free(&c->fmt_ctx.metadata);
2173
2174         len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2175         c->buffer_ptr = c->pb_buffer;
2176         c->buffer_end = c->pb_buffer + len;
2177
2178         c->state = HTTPSTATE_SEND_DATA;
2179         c->last_packet_sent = 0;
2180         break;
2181     case HTTPSTATE_SEND_DATA:
2182         /* find a new packet */
2183         /* read a packet from the input stream */
2184         if (c->stream->feed)
2185             ffm_set_write_index(c->fmt_in,
2186                                 c->stream->feed->feed_write_index,
2187                                 c->stream->feed->feed_size);
2188
2189         if (c->stream->max_time &&
2190             c->stream->max_time + c->start_time - cur_time < 0)
2191             /* We have timed out */
2192             c->state = HTTPSTATE_SEND_DATA_TRAILER;
2193         else {
2194             AVPacket pkt;
2195         redo:
2196             ret = av_read_frame(c->fmt_in, &pkt);
2197             if (ret < 0) {
2198                 if (c->stream->feed) {
2199                     /* if coming from feed, it means we reached the end of the
2200                        ffm file, so must wait for more data */
2201                     c->state = HTTPSTATE_WAIT_FEED;
2202                     return 1; /* state changed */
2203                 } else if (ret == AVERROR(EAGAIN)) {
2204                     /* input not ready, come back later */
2205                     return 0;
2206                 } else {
2207                     if (c->stream->loop) {
2208                         avformat_close_input(&c->fmt_in);
2209                         if (open_input_stream(c, "") < 0)
2210                             goto no_loop;
2211                         goto redo;
2212                     } else {
2213                     no_loop:
2214                         /* must send trailer now because EOF or error */
2215                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
2216                     }
2217                 }
2218             } else {
2219                 int source_index = pkt.stream_index;
2220                 /* update first pts if needed */
2221                 if (c->first_pts == AV_NOPTS_VALUE) {
2222                     c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2223                     c->start_time = cur_time;
2224                 }
2225                 /* send it to the appropriate stream */
2226                 if (c->stream->feed) {
2227                     /* if coming from a feed, select the right stream */
2228                     if (c->switch_pending) {
2229                         c->switch_pending = 0;
2230                         for(i=0;i<c->stream->nb_streams;i++) {
2231                             if (c->switch_feed_streams[i] == pkt.stream_index)
2232                                 if (pkt.flags & AV_PKT_FLAG_KEY)
2233                                     c->switch_feed_streams[i] = -1;
2234                             if (c->switch_feed_streams[i] >= 0)
2235                                 c->switch_pending = 1;
2236                         }
2237                     }
2238                     for(i=0;i<c->stream->nb_streams;i++) {
2239                         if (c->stream->feed_streams[i] == pkt.stream_index) {
2240                             AVStream *st = c->fmt_in->streams[source_index];
2241                             pkt.stream_index = i;
2242                             if (pkt.flags & AV_PKT_FLAG_KEY &&
2243                                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2244                                  c->stream->nb_streams == 1))
2245                                 c->got_key_frame = 1;
2246                             if (!c->stream->send_on_key || c->got_key_frame)
2247                                 goto send_it;
2248                         }
2249                     }
2250                 } else {
2251                     AVCodecContext *codec;
2252                     AVStream *ist, *ost;
2253                 send_it:
2254                     ist = c->fmt_in->streams[source_index];
2255                     /* specific handling for RTP: we use several
2256                      * output streams (one for each RTP connection).
2257                      * XXX: need more abstract handling */
2258                     if (c->is_packetized) {
2259                         /* compute send time and duration */
2260                         c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2261                         c->cur_pts -= c->first_pts;
2262                         c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2263                         /* find RTP context */
2264                         c->packet_stream_index = pkt.stream_index;
2265                         ctx = c->rtp_ctx[c->packet_stream_index];
2266                         if(!ctx) {
2267                             av_free_packet(&pkt);
2268                             break;
2269                         }
2270                         codec = ctx->streams[0]->codec;
2271                         /* only one stream per RTP connection */
2272                         pkt.stream_index = 0;
2273                     } else {
2274                         ctx = &c->fmt_ctx;
2275                         /* Fudge here */
2276                         codec = ctx->streams[pkt.stream_index]->codec;
2277                     }
2278
2279                     if (c->is_packetized) {
2280                         int max_packet_size;
2281                         if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2282                             max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2283                         else
2284                             max_packet_size = c->rtp_handles[c->packet_stream_index]->max_packet_size;
2285                         ret = ffio_open_dyn_packet_buf(&ctx->pb,
2286                                                        max_packet_size);
2287                     } else {
2288                         ret = avio_open_dyn_buf(&ctx->pb);
2289                     }
2290                     if (ret < 0) {
2291                         /* XXX: potential leak */
2292                         return -1;
2293                     }
2294                     ost = ctx->streams[pkt.stream_index];
2295
2296                     ctx->pb->seekable = 0;
2297                     if (pkt.dts != AV_NOPTS_VALUE)
2298                         pkt.dts = av_rescale_q(pkt.dts, ist->time_base,
2299                                                ost->time_base);
2300                     if (pkt.pts != AV_NOPTS_VALUE)
2301                         pkt.pts = av_rescale_q(pkt.pts, ist->time_base,
2302                                                ost->time_base);
2303                     pkt.duration = av_rescale_q(pkt.duration, ist->time_base,
2304                                                 ost->time_base);
2305                     if ((ret = av_write_frame(ctx, &pkt)) < 0) {
2306                         http_log("Error writing frame to output for stream '%s': %s\n",
2307                                  c->stream->filename, av_err2str(ret));
2308                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
2309                     }
2310
2311                     av_freep(&c->pb_buffer);
2312                     len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2313                     c->cur_frame_bytes = len;
2314                     c->buffer_ptr = c->pb_buffer;
2315                     c->buffer_end = c->pb_buffer + len;
2316
2317                     codec->frame_number++;
2318                     if (len == 0) {
2319                         av_free_packet(&pkt);
2320                         goto redo;
2321                     }
2322                 }
2323                 av_free_packet(&pkt);
2324             }
2325         }
2326         break;
2327     default:
2328     case HTTPSTATE_SEND_DATA_TRAILER:
2329         /* last packet test ? */
2330         if (c->last_packet_sent || c->is_packetized)
2331             return -1;
2332         ctx = &c->fmt_ctx;
2333         /* prepare header */
2334         if (avio_open_dyn_buf(&ctx->pb) < 0) {
2335             /* XXX: potential leak */
2336             return -1;
2337         }
2338         c->fmt_ctx.pb->seekable = 0;
2339         av_write_trailer(ctx);
2340         len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2341         c->buffer_ptr = c->pb_buffer;
2342         c->buffer_end = c->pb_buffer + len;
2343
2344         c->last_packet_sent = 1;
2345         break;
2346     }
2347     return 0;
2348 }
2349
2350 /* should convert the format at the same time */
2351 /* send data starting at c->buffer_ptr to the output connection
2352  * (either UDP or TCP) */
2353 static int http_send_data(HTTPContext *c)
2354 {
2355     int len, ret;
2356
2357     for(;;) {
2358         if (c->buffer_ptr >= c->buffer_end) {
2359             ret = http_prepare_data(c);
2360             if (ret < 0)
2361                 return -1;
2362             else if (ret)
2363                 /* state change requested */
2364                 break;
2365         } else {
2366             if (c->is_packetized) {
2367                 /* RTP data output */
2368                 len = c->buffer_end - c->buffer_ptr;
2369                 if (len < 4) {
2370                     /* fail safe - should never happen */
2371                 fail1:
2372                     c->buffer_ptr = c->buffer_end;
2373                     return 0;
2374                 }
2375                 len = (c->buffer_ptr[0] << 24) |
2376                     (c->buffer_ptr[1] << 16) |
2377                     (c->buffer_ptr[2] << 8) |
2378                     (c->buffer_ptr[3]);
2379                 if (len > (c->buffer_end - c->buffer_ptr))
2380                     goto fail1;
2381                 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2382                     /* nothing to send yet: we can wait */
2383                     return 0;
2384                 }
2385
2386                 c->data_count += len;
2387                 update_datarate(&c->datarate, c->data_count);
2388                 if (c->stream)
2389                     c->stream->bytes_served += len;
2390
2391                 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2392                     /* RTP packets are sent inside the RTSP TCP connection */
2393                     AVIOContext *pb;
2394                     int interleaved_index, size;
2395                     uint8_t header[4];
2396                     HTTPContext *rtsp_c;
2397
2398                     rtsp_c = c->rtsp_c;
2399                     /* if no RTSP connection left, error */
2400                     if (!rtsp_c)
2401                         return -1;
2402                     /* if already sending something, then wait. */
2403                     if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2404                         break;
2405                     if (avio_open_dyn_buf(&pb) < 0)
2406                         goto fail1;
2407                     interleaved_index = c->packet_stream_index * 2;
2408                     /* RTCP packets are sent at odd indexes */
2409                     if (c->buffer_ptr[1] == 200)
2410                         interleaved_index++;
2411                     /* write RTSP TCP header */
2412                     header[0] = '$';
2413                     header[1] = interleaved_index;
2414                     header[2] = len >> 8;
2415                     header[3] = len;
2416                     avio_write(pb, header, 4);
2417                     /* write RTP packet data */
2418                     c->buffer_ptr += 4;
2419                     avio_write(pb, c->buffer_ptr, len);
2420                     size = avio_close_dyn_buf(pb, &c->packet_buffer);
2421                     /* prepare asynchronous TCP sending */
2422                     rtsp_c->packet_buffer_ptr = c->packet_buffer;
2423                     rtsp_c->packet_buffer_end = c->packet_buffer + size;
2424                     c->buffer_ptr += len;
2425
2426                     /* send everything we can NOW */
2427                     len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2428                                rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2429                     if (len > 0)
2430                         rtsp_c->packet_buffer_ptr += len;
2431                     if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2432                         /* if we could not send all the data, we will
2433                            send it later, so a new state is needed to
2434                            "lock" the RTSP TCP connection */
2435                         rtsp_c->state = RTSPSTATE_SEND_PACKET;
2436                         break;
2437                     } else
2438                         /* all data has been sent */
2439                         av_freep(&c->packet_buffer);
2440                 } else {
2441                     /* send RTP packet directly in UDP */
2442                     c->buffer_ptr += 4;
2443                     ffurl_write(c->rtp_handles[c->packet_stream_index],
2444                                 c->buffer_ptr, len);
2445                     c->buffer_ptr += len;
2446                     /* here we continue as we can send several packets
2447                      * per 10 ms slot */
2448                 }
2449             } else {
2450                 /* TCP data output */
2451                 len = send(c->fd, c->buffer_ptr,
2452                            c->buffer_end - c->buffer_ptr, 0);
2453                 if (len < 0) {
2454                     if (ff_neterrno() != AVERROR(EAGAIN) &&
2455                         ff_neterrno() != AVERROR(EINTR))
2456                         /* error : close connection */
2457                         return -1;
2458                     else
2459                         return 0;
2460                 }
2461                 c->buffer_ptr += len;
2462
2463                 c->data_count += len;
2464                 update_datarate(&c->datarate, c->data_count);
2465                 if (c->stream)
2466                     c->stream->bytes_served += len;
2467                 break;
2468             }
2469         }
2470     } /* for(;;) */
2471     return 0;
2472 }
2473
2474 static int http_start_receive_data(HTTPContext *c)
2475 {
2476     int fd;
2477     int ret;
2478
2479     if (c->stream->feed_opened) {
2480         http_log("Stream feed '%s' was not opened\n",
2481                  c->stream->feed_filename);
2482         return AVERROR(EINVAL);
2483     }
2484
2485     /* Don't permit writing to this one */
2486     if (c->stream->readonly) {
2487         http_log("Cannot write to read-only file '%s'\n",
2488                  c->stream->feed_filename);
2489         return AVERROR(EINVAL);
2490     }
2491
2492     /* open feed */
2493     fd = open(c->stream->feed_filename, O_RDWR);
2494     if (fd < 0) {
2495         ret = AVERROR(errno);
2496         http_log("Could not open feed file '%s': %s\n",
2497                  c->stream->feed_filename, strerror(errno));
2498         return ret;
2499     }
2500     c->feed_fd = fd;
2501
2502     if (c->stream->truncate) {
2503         /* truncate feed file */
2504         ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2505         http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2506         if (ftruncate(c->feed_fd, FFM_PACKET_SIZE) < 0) {
2507             ret = AVERROR(errno);
2508             http_log("Error truncating feed file '%s': %s\n",
2509                      c->stream->feed_filename, strerror(errno));
2510             return ret;
2511         }
2512     } else {
2513         ret = ffm_read_write_index(fd);
2514         if (ret < 0) {
2515             http_log("Error reading write index from feed file '%s': %s\n",
2516                      c->stream->feed_filename, strerror(errno));
2517             return ret;
2518         } else {
2519             c->stream->feed_write_index = ret;
2520         }
2521     }
2522
2523     c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd),
2524                                         FFM_PACKET_SIZE);
2525     c->stream->feed_size = lseek(fd, 0, SEEK_END);
2526     lseek(fd, 0, SEEK_SET);
2527
2528     /* init buffer input */
2529     c->buffer_ptr = c->buffer;
2530     c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2531     c->stream->feed_opened = 1;
2532     c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2533     return 0;
2534 }
2535
2536 static int http_receive_data(HTTPContext *c)
2537 {
2538     HTTPContext *c1;
2539     int len, loop_run = 0;
2540
2541     while (c->chunked_encoding && !c->chunk_size &&
2542            c->buffer_end > c->buffer_ptr) {
2543         /* read chunk header, if present */
2544         len = recv(c->fd, c->buffer_ptr, 1, 0);
2545
2546         if (len < 0) {
2547             if (ff_neterrno() != AVERROR(EAGAIN) &&
2548                 ff_neterrno() != AVERROR(EINTR))
2549                 /* error : close connection */
2550                 goto fail;
2551             return 0;
2552         } else if (len == 0) {
2553             /* end of connection : close it */
2554             goto fail;
2555         } else if (c->buffer_ptr - c->buffer >= 2 &&
2556                    !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2557             c->chunk_size = strtol(c->buffer, 0, 16);
2558             if (c->chunk_size == 0) // end of stream
2559                 goto fail;
2560             c->buffer_ptr = c->buffer;
2561             break;
2562         } else if (++loop_run > 10) {
2563             /* no chunk header, abort */
2564             goto fail;
2565         } else {
2566             c->buffer_ptr++;
2567         }
2568     }
2569
2570     if (c->buffer_end > c->buffer_ptr) {
2571         len = recv(c->fd, c->buffer_ptr,
2572                    FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2573         if (len < 0) {
2574             if (ff_neterrno() != AVERROR(EAGAIN) &&
2575                 ff_neterrno() != AVERROR(EINTR))
2576                 /* error : close connection */
2577                 goto fail;
2578         } else if (len == 0)
2579             /* end of connection : close it */
2580             goto fail;
2581         else {
2582             c->chunk_size -= len;
2583             c->buffer_ptr += len;
2584             c->data_count += len;
2585             update_datarate(&c->datarate, c->data_count);
2586         }
2587     }
2588
2589     if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2590         if (c->buffer[0] != 'f' ||
2591             c->buffer[1] != 'm') {
2592             http_log("Feed stream has become desynchronized -- disconnecting\n");
2593             goto fail;
2594         }
2595     }
2596
2597     if (c->buffer_ptr >= c->buffer_end) {
2598         FFServerStream *feed = c->stream;
2599         /* a packet has been received : write it in the store, except
2600            if header */
2601         if (c->data_count > FFM_PACKET_SIZE) {
2602             /* XXX: use llseek or url_seek
2603              * XXX: Should probably fail? */
2604             if (lseek(c->feed_fd, feed->feed_write_index, SEEK_SET) == -1)
2605                 http_log("Seek to %"PRId64" failed\n", feed->feed_write_index);
2606
2607             if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2608                 http_log("Error writing to feed file: %s\n", strerror(errno));
2609                 goto fail;
2610             }
2611
2612             feed->feed_write_index += FFM_PACKET_SIZE;
2613             /* update file size */
2614             if (feed->feed_write_index > c->stream->feed_size)
2615                 feed->feed_size = feed->feed_write_index;
2616
2617             /* handle wrap around if max file size reached */
2618             if (c->stream->feed_max_size &&
2619                 feed->feed_write_index >= c->stream->feed_max_size)
2620                 feed->feed_write_index = FFM_PACKET_SIZE;
2621
2622             /* write index */
2623             if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2624                 http_log("Error writing index to feed file: %s\n",
2625                          strerror(errno));
2626                 goto fail;
2627             }
2628
2629             /* wake up any waiting connections */
2630             for(c1 = first_http_ctx; c1; c1 = c1->next) {
2631                 if (c1->state == HTTPSTATE_WAIT_FEED &&
2632                     c1->stream->feed == c->stream->feed)
2633                     c1->state = HTTPSTATE_SEND_DATA;
2634             }
2635         } else {
2636             /* We have a header in our hands that contains useful data */
2637             AVFormatContext *s = avformat_alloc_context();
2638             AVIOContext *pb;
2639             AVInputFormat *fmt_in;
2640             int i;
2641
2642             if (!s)
2643                 goto fail;
2644
2645             /* use feed output format name to find corresponding input format */
2646             fmt_in = av_find_input_format(feed->fmt->name);
2647             if (!fmt_in)
2648                 goto fail;
2649
2650             pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2651                                     0, NULL, NULL, NULL, NULL);
2652             pb->seekable = 0;
2653
2654             s->pb = pb;
2655             if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2656                 av_freep(&pb);
2657                 goto fail;
2658             }
2659
2660             /* Now we have the actual streams */
2661             if (s->nb_streams != feed->nb_streams) {
2662                 avformat_close_input(&s);
2663                 av_freep(&pb);
2664                 http_log("Feed '%s' stream number does not match registered feed\n",
2665                          c->stream->feed_filename);
2666                 goto fail;
2667             }
2668
2669             for (i = 0; i < s->nb_streams; i++) {
2670                 AVStream *fst = feed->streams[i];
2671                 AVStream *st = s->streams[i];
2672                 avcodec_copy_context(fst->codec, st->codec);
2673             }
2674
2675             avformat_close_input(&s);
2676             av_freep(&pb);
2677         }
2678         c->buffer_ptr = c->buffer;
2679     }
2680
2681     return 0;
2682  fail:
2683     c->stream->feed_opened = 0;
2684     close(c->feed_fd);
2685     /* wake up any waiting connections to stop waiting for feed */
2686     for(c1 = first_http_ctx; c1; c1 = c1->next) {
2687         if (c1->state == HTTPSTATE_WAIT_FEED &&
2688             c1->stream->feed == c->stream->feed)
2689             c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2690     }
2691     return -1;
2692 }
2693
2694 /********************************************************************/
2695 /* RTSP handling */
2696
2697 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2698 {
2699     const char *str;
2700     time_t ti;
2701     struct tm *tm;
2702     char buf2[32];
2703
2704     str = RTSP_STATUS_CODE2STRING(error_number);
2705     if (!str)
2706         str = "Unknown Error";
2707
2708     avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2709     avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2710
2711     /* output GMT time */
2712     ti = time(NULL);
2713     tm = gmtime(&ti);
2714     strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2715     avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2716 }
2717
2718 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2719 {
2720     rtsp_reply_header(c, error_number);
2721     avio_printf(c->pb, "\r\n");
2722 }
2723
2724 static int rtsp_parse_request(HTTPContext *c)
2725 {
2726     const char *p, *p1, *p2;
2727     char cmd[32];
2728     char url[1024];
2729     char protocol[32];
2730     char line[1024];
2731     int len;
2732     RTSPMessageHeader header1 = { 0 }, *header = &header1;
2733
2734     c->buffer_ptr[0] = '\0';
2735     p = c->buffer;
2736
2737     get_word(cmd, sizeof(cmd), &p);
2738     get_word(url, sizeof(url), &p);
2739     get_word(protocol, sizeof(protocol), &p);
2740
2741     av_strlcpy(c->method, cmd, sizeof(c->method));
2742     av_strlcpy(c->url, url, sizeof(c->url));
2743     av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2744
2745     if (avio_open_dyn_buf(&c->pb) < 0) {
2746         /* XXX: cannot do more */
2747         c->pb = NULL; /* safety */
2748         return -1;
2749     }
2750
2751     /* check version name */
2752     if (strcmp(protocol, "RTSP/1.0")) {
2753         rtsp_reply_error(c, RTSP_STATUS_VERSION);
2754         goto the_end;
2755     }
2756
2757     /* parse each header line */
2758     /* skip to next line */
2759     while (*p != '\n' && *p != '\0')
2760         p++;
2761     if (*p == '\n')
2762         p++;
2763     while (*p != '\0') {
2764         p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2765         if (!p1)
2766             break;
2767         p2 = p1;
2768         if (p2 > p && p2[-1] == '\r')
2769             p2--;
2770         /* skip empty line */
2771         if (p2 == p)
2772             break;
2773         len = p2 - p;
2774         if (len > sizeof(line) - 1)
2775             len = sizeof(line) - 1;
2776         memcpy(line, p, len);
2777         line[len] = '\0';
2778         ff_rtsp_parse_line(header, line, NULL, NULL);
2779         p = p1 + 1;
2780     }
2781
2782     /* handle sequence number */
2783     c->seq = header->seq;
2784
2785     if (!strcmp(cmd, "DESCRIBE"))
2786         rtsp_cmd_describe(c, url);
2787     else if (!strcmp(cmd, "OPTIONS"))
2788         rtsp_cmd_options(c, url);
2789     else if (!strcmp(cmd, "SETUP"))
2790         rtsp_cmd_setup(c, url, header);
2791     else if (!strcmp(cmd, "PLAY"))
2792         rtsp_cmd_play(c, url, header);
2793     else if (!strcmp(cmd, "PAUSE"))
2794         rtsp_cmd_interrupt(c, url, header, 1);
2795     else if (!strcmp(cmd, "TEARDOWN"))
2796         rtsp_cmd_interrupt(c, url, header, 0);
2797     else
2798         rtsp_reply_error(c, RTSP_STATUS_METHOD);
2799
2800  the_end:
2801     len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2802     c->pb = NULL; /* safety */
2803     if (len < 0) {
2804         /* XXX: cannot do more */
2805         return -1;
2806     }
2807     c->buffer_ptr = c->pb_buffer;
2808     c->buffer_end = c->pb_buffer + len;
2809     c->state = RTSPSTATE_SEND_REPLY;
2810     return 0;
2811 }
2812
2813 static int prepare_sdp_description(FFServerStream *stream, uint8_t **pbuffer,
2814                                    struct in_addr my_ip)
2815 {
2816     AVFormatContext *avc;
2817     AVStream *avs = NULL;
2818     AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
2819     AVDictionaryEntry *entry = av_dict_get(stream->metadata, "title", NULL, 0);
2820     int i;
2821
2822     *pbuffer = NULL;
2823
2824     avc =  avformat_alloc_context();
2825     if (!avc || !rtp_format) {
2826         return -1;
2827     }
2828     avc->oformat = rtp_format;
2829     av_dict_set(&avc->metadata, "title",
2830                 entry ? entry->value : "No Title", 0);
2831     avc->nb_streams = stream->nb_streams;
2832     if (stream->is_multicast) {
2833         snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2834                  inet_ntoa(stream->multicast_ip),
2835                  stream->multicast_port, stream->multicast_ttl);
2836     } else {
2837         snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2838     }
2839
2840     if (!(avc->streams = av_malloc_array(avc->nb_streams, sizeof(*avc->streams))))
2841         goto sdp_done;
2842     if (!(avs = av_malloc_array(avc->nb_streams, sizeof(*avs))))
2843         goto sdp_done;
2844
2845     for(i = 0; i < stream->nb_streams; i++) {
2846         avc->streams[i] = &avs[i];
2847         avc->streams[i]->codec = stream->streams[i]->codec;
2848     }
2849     *pbuffer = av_mallocz(2048);
2850     av_sdp_create(&avc, 1, *pbuffer, 2048);
2851
2852  sdp_done:
2853     av_freep(&avc->streams);
2854     av_dict_free(&avc->metadata);
2855     av_free(avc);
2856     av_free(avs);
2857
2858     return *pbuffer ? strlen(*pbuffer) : AVERROR(ENOMEM);
2859 }
2860
2861 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2862 {
2863 //    rtsp_reply_header(c, RTSP_STATUS_OK);
2864     avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2865     avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2866     avio_printf(c->pb, "Public: %s\r\n",
2867                 "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2868     avio_printf(c->pb, "\r\n");
2869 }
2870
2871 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2872 {
2873     FFServerStream *stream;
2874     char path1[1024];
2875     const char *path;
2876     uint8_t *content;
2877     int content_length;
2878     socklen_t len;
2879     struct sockaddr_in my_addr;
2880
2881     /* find which URL is asked */
2882     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2883     path = path1;
2884     if (*path == '/')
2885         path++;
2886
2887     for(stream = config.first_stream; stream; stream = stream->next) {
2888         if (!stream->is_feed &&
2889             stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2890             !strcmp(path, stream->filename)) {
2891             goto found;
2892         }
2893     }
2894     /* no stream found */
2895     rtsp_reply_error(c, RTSP_STATUS_NOT_FOUND);
2896     return;
2897
2898  found:
2899     /* prepare the media description in SDP format */
2900
2901     /* get the host IP */
2902     len = sizeof(my_addr);
2903     getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2904     content_length = prepare_sdp_description(stream, &content,
2905                                              my_addr.sin_addr);
2906     if (content_length < 0) {
2907         rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2908         return;
2909     }
2910     rtsp_reply_header(c, RTSP_STATUS_OK);
2911     avio_printf(c->pb, "Content-Base: %s/\r\n", url);
2912     avio_printf(c->pb, "Content-Type: application/sdp\r\n");
2913     avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
2914     avio_printf(c->pb, "\r\n");
2915     avio_write(c->pb, content, content_length);
2916     av_free(content);
2917 }
2918
2919 static HTTPContext *find_rtp_session(const char *session_id)
2920 {
2921     HTTPContext *c;
2922
2923     if (session_id[0] == '\0')
2924         return NULL;
2925
2926     for(c = first_http_ctx; c; c = c->next) {
2927         if (!strcmp(c->session_id, session_id))
2928             return c;
2929     }
2930     return NULL;
2931 }
2932
2933 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
2934 {
2935     RTSPTransportField *th;
2936     int i;
2937
2938     for(i=0;i<h->nb_transports;i++) {
2939         th = &h->transports[i];
2940         if (th->lower_transport == lower_transport)
2941             return th;
2942     }
2943     return NULL;
2944 }
2945
2946 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
2947                            RTSPMessageHeader *h)
2948 {
2949     FFServerStream *stream;
2950     int stream_index, rtp_port, rtcp_port;
2951     char buf[1024];
2952     char path1[1024];
2953     const char *path;
2954     HTTPContext *rtp_c;
2955     RTSPTransportField *th;
2956     struct sockaddr_in dest_addr;
2957     RTSPActionServerSetup setup;
2958
2959     /* find which URL is asked */
2960     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2961     path = path1;
2962     if (*path == '/')
2963         path++;
2964
2965     /* now check each stream */
2966     for(stream = config.first_stream; stream; stream = stream->next) {
2967         if (stream->is_feed || !stream->fmt ||
2968             strcmp(stream->fmt->name, "rtp")) {
2969             continue;
2970         }
2971         /* accept aggregate filenames only if single stream */
2972         if (!strcmp(path, stream->filename)) {
2973             if (stream->nb_streams != 1) {
2974                 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
2975                 return;
2976             }
2977             stream_index = 0;
2978             goto found;
2979         }
2980
2981         for(stream_index = 0; stream_index < stream->nb_streams;
2982             stream_index++) {
2983             snprintf(buf, sizeof(buf), "%s/streamid=%d",
2984                      stream->filename, stream_index);
2985             if (!strcmp(path, buf))
2986                 goto found;
2987         }
2988     }
2989     /* no stream found */
2990     rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2991     return;
2992  found:
2993
2994     /* generate session id if needed */
2995     if (h->session_id[0] == '\0') {
2996         unsigned random0 = av_lfg_get(&random_state);
2997         unsigned random1 = av_lfg_get(&random_state);
2998         snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
2999                  random0, random1);
3000     }
3001
3002     /* find RTP session, and create it if none found */
3003     rtp_c = find_rtp_session(h->session_id);
3004     if (!rtp_c) {
3005         /* always prefer UDP */
3006         th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3007         if (!th) {
3008             th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3009             if (!th) {
3010                 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3011                 return;
3012             }
3013         }
3014
3015         rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3016                                    th->lower_transport);
3017         if (!rtp_c) {
3018             rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3019             return;
3020         }
3021
3022         /* open input stream */
3023         if (open_input_stream(rtp_c, "") < 0) {
3024             rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3025             return;
3026         }
3027     }
3028
3029     /* test if stream is OK (test needed because several SETUP needs
3030        to be done for a given file) */
3031     if (rtp_c->stream != stream) {
3032         rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3033         return;
3034     }
3035
3036     /* test if stream is already set up */
3037     if (rtp_c->rtp_ctx[stream_index]) {
3038         rtsp_reply_error(c, RTSP_STATUS_STATE);
3039         return;
3040     }
3041
3042     /* check transport */
3043     th = find_transport(h, rtp_c->rtp_protocol);
3044     if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3045                 th->client_port_min <= 0)) {
3046         rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3047         return;
3048     }
3049
3050     /* setup default options */
3051     setup.transport_option[0] = '\0';
3052     dest_addr = rtp_c->from_addr;
3053     dest_addr.sin_port = htons(th->client_port_min);
3054
3055     /* setup stream */
3056     if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3057         rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3058         return;
3059     }
3060
3061     /* now everything is OK, so we can send the connection parameters */
3062     rtsp_reply_header(c, RTSP_STATUS_OK);
3063     /* session ID */
3064     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3065
3066     switch(rtp_c->rtp_protocol) {
3067     case RTSP_LOWER_TRANSPORT_UDP:
3068         rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3069         rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3070         avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3071                     "client_port=%d-%d;server_port=%d-%d",
3072                     th->client_port_min, th->client_port_max,
3073                     rtp_port, rtcp_port);
3074         break;
3075     case RTSP_LOWER_TRANSPORT_TCP:
3076         avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3077                     stream_index * 2, stream_index * 2 + 1);
3078         break;
3079     default:
3080         break;
3081     }
3082     if (setup.transport_option[0] != '\0')
3083         avio_printf(c->pb, ";%s", setup.transport_option);
3084     avio_printf(c->pb, "\r\n");
3085
3086
3087     avio_printf(c->pb, "\r\n");
3088 }
3089
3090
3091 /* find an RTP connection by using the session ID. Check consistency
3092    with filename */
3093 static HTTPContext *find_rtp_session_with_url(const char *url,
3094                                               const char *session_id)
3095 {
3096     HTTPContext *rtp_c;
3097     char path1[1024];
3098     const char *path;
3099     char buf[1024];
3100     int s, len;
3101
3102     rtp_c = find_rtp_session(session_id);
3103     if (!rtp_c)
3104         return NULL;
3105
3106     /* find which URL is asked */
3107     av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3108     path = path1;
3109     if (*path == '/')
3110         path++;
3111     if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3112     for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3113       snprintf(buf, sizeof(buf), "%s/streamid=%d",
3114         rtp_c->stream->filename, s);
3115       if(!strncmp(path, buf, sizeof(buf))) {
3116     // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3117         return rtp_c;
3118       }
3119     }
3120     len = strlen(path);
3121     if (len > 0 && path[len - 1] == '/' &&
3122         !strncmp(path, rtp_c->stream->filename, len - 1))
3123         return rtp_c;
3124     return NULL;
3125 }
3126
3127 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3128 {
3129     HTTPContext *rtp_c;
3130
3131     rtp_c = find_rtp_session_with_url(url, h->session_id);
3132     if (!rtp_c) {
3133         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3134         return;
3135     }
3136
3137     if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3138         rtp_c->state != HTTPSTATE_WAIT_FEED &&
3139         rtp_c->state != HTTPSTATE_READY) {
3140         rtsp_reply_error(c, RTSP_STATUS_STATE);
3141         return;
3142     }
3143
3144     rtp_c->state = HTTPSTATE_SEND_DATA;
3145
3146     /* now everything is OK, so we can send the connection parameters */
3147     rtsp_reply_header(c, RTSP_STATUS_OK);
3148     /* session ID */
3149     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3150     avio_printf(c->pb, "\r\n");
3151 }
3152
3153 static void rtsp_cmd_interrupt(HTTPContext *c, const char *url,
3154                                RTSPMessageHeader *h, int pause_only)
3155 {
3156     HTTPContext *rtp_c;
3157
3158     rtp_c = find_rtp_session_with_url(url, h->session_id);
3159     if (!rtp_c) {
3160         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3161         return;
3162     }
3163
3164     if (pause_only) {
3165         if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3166             rtp_c->state != HTTPSTATE_WAIT_FEED) {
3167             rtsp_reply_error(c, RTSP_STATUS_STATE);
3168             return;
3169         }
3170         rtp_c->state = HTTPSTATE_READY;
3171         rtp_c->first_pts = AV_NOPTS_VALUE;
3172     }
3173
3174     /* now everything is OK, so we can send the connection parameters */
3175     rtsp_reply_header(c, RTSP_STATUS_OK);
3176     /* session ID */
3177     avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3178     avio_printf(c->pb, "\r\n");
3179
3180     if (!pause_only)
3181         close_connection(rtp_c);
3182 }
3183
3184 /********************************************************************/
3185 /* RTP handling */
3186
3187 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3188                                        FFServerStream *stream,
3189                                        const char *session_id,
3190                                        enum RTSPLowerTransport rtp_protocol)
3191 {
3192     HTTPContext *c = NULL;
3193     const char *proto_str;
3194
3195     /* XXX: should output a warning page when coming
3196        close to the connection limit */
3197     if (nb_connections >= config.nb_max_connections)
3198         goto fail;
3199
3200     /* add a new connection */
3201     c = av_mallocz(sizeof(HTTPContext));
3202     if (!c)
3203         goto fail;
3204
3205     c->fd = -1;
3206     c->poll_entry = NULL;
3207     c->from_addr = *from_addr;
3208     c->buffer_size = IOBUFFER_INIT_SIZE;
3209     c->buffer = av_malloc(c->buffer_size);
3210     if (!c->buffer)
3211         goto fail;
3212     nb_connections++;
3213     c->stream = stream;
3214     av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3215     c->state = HTTPSTATE_READY;
3216     c->is_packetized = 1;
3217     c->rtp_protocol = rtp_protocol;
3218
3219     /* protocol is shown in statistics */
3220     switch(c->rtp_protocol) {
3221     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3222         proto_str = "MCAST";
3223         break;
3224     case RTSP_LOWER_TRANSPORT_UDP:
3225         proto_str = "UDP";
3226         break;
3227     case RTSP_LOWER_TRANSPORT_TCP:
3228         proto_str = "TCP";
3229         break;
3230     default:
3231         proto_str = "???";
3232         break;
3233     }
3234     av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3235     av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3236
3237     current_bandwidth += stream->bandwidth;
3238
3239     c->next = first_http_ctx;
3240     first_http_ctx = c;
3241     return c;
3242
3243  fail:
3244     if (c) {
3245         av_freep(&c->buffer);
3246         av_free(c);
3247     }
3248     return NULL;
3249 }
3250
3251 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3252    command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3253    used. */
3254 static int rtp_new_av_stream(HTTPContext *c,
3255                              int stream_index, struct sockaddr_in *dest_addr,
3256                              HTTPContext *rtsp_c)
3257 {
3258     AVFormatContext *ctx;
3259     AVStream *st;
3260     char *ipaddr;
3261     URLContext *h = NULL;
3262     uint8_t *dummy_buf;
3263     int max_packet_size;
3264
3265     /* now we can open the relevant output stream */
3266     ctx = avformat_alloc_context();
3267     if (!ctx)
3268         return -1;
3269     ctx->oformat = av_guess_format("rtp", NULL, NULL);
3270
3271     st = av_mallocz(sizeof(AVStream));
3272     if (!st)
3273         goto fail;
3274     ctx->nb_streams = 1;
3275     ctx->streams = av_mallocz_array(ctx->nb_streams, sizeof(AVStream *));
3276     if (!ctx->streams)
3277       goto fail;
3278     ctx->streams[0] = st;
3279
3280     if (!c->stream->feed ||
3281         c->stream->feed == c->stream)
3282         memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3283     else
3284         memcpy(st,
3285                c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3286                sizeof(AVStream));
3287     st->priv_data = NULL;
3288
3289     /* build destination RTP address */
3290     ipaddr = inet_ntoa(dest_addr->sin_addr);
3291
3292     switch(c->rtp_protocol) {
3293     case RTSP_LOWER_TRANSPORT_UDP:
3294     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3295         /* RTP/UDP case */
3296
3297         /* XXX: also pass as parameter to function ? */
3298         if (c->stream->is_multicast) {
3299             int ttl;
3300             ttl = c->stream->multicast_ttl;
3301             if (!ttl)
3302                 ttl = 16;
3303             snprintf(ctx->filename, sizeof(ctx->filename),
3304                      "rtp://%s:%d?multicast=1&ttl=%d",
3305                      ipaddr, ntohs(dest_addr->sin_port), ttl);
3306         } else {
3307             snprintf(ctx->filename, sizeof(ctx->filename),
3308                      "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3309         }
3310
3311         if (ffurl_open(&h, ctx->filename, AVIO_FLAG_WRITE, NULL, NULL) < 0)
3312             goto fail;
3313         c->rtp_handles[stream_index] = h;
3314         max_packet_size = h->max_packet_size;
3315         break;
3316     case RTSP_LOWER_TRANSPORT_TCP:
3317         /* RTP/TCP case */
3318         c->rtsp_c = rtsp_c;
3319         max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3320         break;
3321     default:
3322         goto fail;
3323     }
3324
3325     http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3326              ipaddr, ntohs(dest_addr->sin_port),
3327              c->stream->filename, stream_index, c->protocol);
3328
3329     /* normally, no packets should be output here, but the packet size may
3330      * be checked */
3331     if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3332         /* XXX: close stream */
3333         goto fail;
3334     }
3335     if (avformat_write_header(ctx, NULL) < 0) {
3336     fail:
3337         if (h)
3338             ffurl_close(h);
3339         av_free(st);
3340         av_free(ctx);
3341         return -1;
3342     }
3343     avio_close_dyn_buf(ctx->pb, &dummy_buf);
3344     av_free(dummy_buf);
3345
3346     c->rtp_ctx[stream_index] = ctx;
3347     return 0;
3348 }
3349
3350 /********************************************************************/
3351 /* ffserver initialization */
3352
3353 static AVStream *add_av_stream1(FFServerStream *stream,
3354                                 AVCodecContext *codec, int copy)
3355 {
3356     AVStream *fst;
3357
3358     if(stream->nb_streams >= FF_ARRAY_ELEMS(stream->streams))
3359         return NULL;
3360
3361     fst = av_mallocz(sizeof(AVStream));
3362     if (!fst)
3363         return NULL;
3364     if (copy) {
3365         fst->codec = avcodec_alloc_context3(codec->codec);
3366         avcodec_copy_context(fst->codec, codec);
3367     } else {
3368         /* live streams must use the actual feed's codec since it may be
3369          * updated later to carry extradata needed by them.
3370          */
3371         fst->codec = codec;
3372     }
3373     fst->priv_data = av_mallocz(sizeof(FeedData));
3374     fst->index = stream->nb_streams;
3375     avpriv_set_pts_info(fst, 33, 1, 90000);
3376     fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3377     stream->streams[stream->nb_streams++] = fst;
3378     return fst;
3379 }
3380
3381 /* return the stream number in the feed */
3382 static int add_av_stream(FFServerStream *feed, AVStream *st)
3383 {
3384     AVStream *fst;
3385     AVCodecContext *av, *av1;
3386     int i;
3387
3388     av = st->codec;
3389     for(i=0;i<feed->nb_streams;i++) {
3390         av1 = feed->streams[i]->codec;
3391         if (av1->codec_id == av->codec_id &&
3392             av1->codec_type == av->codec_type &&
3393             av1->bit_rate == av->bit_rate) {
3394
3395             switch(av->codec_type) {
3396             case AVMEDIA_TYPE_AUDIO:
3397                 if (av1->channels == av->channels &&
3398                     av1->sample_rate == av->sample_rate)
3399                     return i;
3400                 break;
3401             case AVMEDIA_TYPE_VIDEO:
3402                 if (av1->width == av->width &&
3403                     av1->height == av->height &&
3404                     av1->time_base.den == av->time_base.den &&
3405                     av1->time_base.num == av->time_base.num &&
3406                     av1->gop_size == av->gop_size)
3407                     return i;
3408                 break;
3409             default:
3410                 abort();
3411             }
3412         }
3413     }
3414
3415     fst = add_av_stream1(feed, av, 0);
3416     if (!fst)
3417         return -1;
3418     if (av_stream_get_recommended_encoder_configuration(st))
3419         av_stream_set_recommended_encoder_configuration(fst,
3420             av_strdup(av_stream_get_recommended_encoder_configuration(st)));
3421     return feed->nb_streams - 1;
3422 }
3423
3424 static void remove_stream(FFServerStream *stream)
3425 {
3426     FFServerStream **ps;
3427     ps = &config.first_stream;
3428     while (*ps) {
3429         if (*ps == stream)
3430             *ps = (*ps)->next;
3431         else
3432             ps = &(*ps)->next;
3433     }
3434 }
3435
3436 /* specific MPEG4 handling : we extract the raw parameters */
3437 static void extract_mpeg4_header(AVFormatContext *infile)
3438 {
3439     int mpeg4_count, i, size;
3440     AVPacket pkt;
3441     AVStream *st;
3442     const uint8_t *p;
3443
3444     infile->flags |= AVFMT_FLAG_NOFILLIN | AVFMT_FLAG_NOPARSE;
3445
3446     mpeg4_count = 0;
3447     for(i=0;i<infile->nb_streams;i++) {
3448         st = infile->streams[i];
3449         if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3450             st->codec->extradata_size == 0) {
3451             mpeg4_count++;
3452         }
3453     }
3454     if (!mpeg4_count)
3455         return;
3456
3457     printf("MPEG4 without extra data: trying to find header in %s\n",
3458            infile->filename);
3459     while (mpeg4_count > 0) {
3460         if (av_read_frame(infile, &pkt) < 0)
3461             break;
3462         st = infile->streams[pkt.stream_index];
3463         if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3464             st->codec->extradata_size == 0) {
3465             av_freep(&st->codec->extradata);
3466             /* fill extradata with the header */
3467             /* XXX: we make hard suppositions here ! */
3468             p = pkt.data;
3469             while (p < pkt.data + pkt.size - 4) {
3470                 /* stop when vop header is found */
3471                 if (p[0] == 0x00 && p[1] == 0x00 &&
3472                     p[2] == 0x01 && p[3] == 0xb6) {
3473                     size = p - pkt.data;
3474                     //                    av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3475                     st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
3476                     st->codec->extradata_size = size;
3477                     memcpy(st->codec->extradata, pkt.data, size);
3478                     break;
3479                 }
3480                 p++;
3481             }
3482             mpeg4_count--;
3483         }
3484         av_free_packet(&pkt);
3485     }
3486 }
3487
3488 /* compute the needed AVStream for each file */
3489 static void build_file_streams(void)
3490 {
3491     FFServerStream *stream, *stream_next;
3492     int i, ret;
3493
3494     /* gather all streams */
3495     for(stream = config.first_stream; stream; stream = stream_next) {
3496         AVFormatContext *infile = NULL;
3497         stream_next = stream->next;
3498         if (stream->stream_type == STREAM_TYPE_LIVE &&
3499             !stream->feed) {
3500             /* the stream comes from a file */
3501             /* try to open the file */
3502             /* open stream */
3503             if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3504                 /* specific case : if transport stream output to RTP,
3505                    we use a raw transport stream reader */
3506                 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3507             }
3508
3509             if (!stream->feed_filename[0]) {
3510                 http_log("Unspecified feed file for stream '%s'\n",
3511                          stream->filename);
3512                 goto fail;
3513             }
3514
3515             http_log("Opening feed file '%s' for stream '%s'\n",
3516                      stream->feed_filename, stream->filename);
3517             ret = avformat_open_input(&infile, stream->feed_filename,
3518                                       stream->ifmt, &stream->in_opts);
3519             if (ret < 0) {
3520                 http_log("Could not open '%s': %s\n", stream->feed_filename,
3521                          av_err2str(ret));
3522                 /* remove stream (no need to spend more time on it) */
3523             fail:
3524                 remove_stream(stream);
3525             } else {
3526                 /* find all the AVStreams inside and reference them in
3527                    'stream' */
3528                 if (avformat_find_stream_info(infile, NULL) < 0) {
3529                     http_log("Could not find codec parameters from '%s'\n",
3530                              stream->feed_filename);
3531                     avformat_close_input(&infile);
3532                     goto fail;
3533                 }
3534                 extract_mpeg4_header(infile);
3535
3536                 for(i=0;i<infile->nb_streams;i++)
3537                     add_av_stream1(stream, infile->streams[i]->codec, 1);
3538
3539                 avformat_close_input(&infile);
3540             }
3541         }
3542     }
3543 }
3544
3545 /* compute the needed AVStream for each feed */
3546 static void build_feed_streams(void)
3547 {
3548     FFServerStream *stream, *feed;
3549     int i;
3550
3551     /* gather all streams */
3552     for(stream = config.first_stream; stream; stream = stream->next) {
3553         feed = stream->feed;
3554         if (feed) {
3555             if (stream->is_feed) {
3556                 for(i=0;i<stream->nb_streams;i++)
3557                     stream->feed_streams[i] = i;
3558             } else {
3559                 /* we handle a stream coming from a feed */
3560                 for(i=0;i<stream->nb_streams;i++)
3561                     stream->feed_streams[i] = add_av_stream(feed,
3562                                                             stream->streams[i]);
3563             }
3564         }
3565     }
3566
3567     /* create feed files if needed */
3568     for(feed = config.first_feed; feed; feed = feed->next_feed) {
3569         int fd;
3570
3571         if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3572             /* See if it matches */
3573             AVFormatContext *s = NULL;
3574             int matches = 0;
3575
3576             if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3577                 /* set buffer size */
3578                 ffio_set_buf_size(s->pb, FFM_PACKET_SIZE);
3579                 /* Now see if it matches */
3580                 if (s->nb_streams == feed->nb_streams) {
3581                     matches = 1;
3582                     for(i=0;i<s->nb_streams;i++) {
3583                         AVStream *sf, *ss;
3584                         sf = feed->streams[i];
3585                         ss = s->streams[i];
3586
3587                         if (sf->index != ss->index ||
3588                             sf->id != ss->id) {
3589                             http_log("Index & Id do not match for stream %d (%s)\n",
3590                                    i, feed->feed_filename);
3591                             matches = 0;
3592                         } else {
3593                             AVCodecContext *ccf, *ccs;
3594
3595                             ccf = sf->codec;
3596                             ccs = ss->codec;
3597 #define CHECK_CODEC(x)  (ccf->x != ccs->x)
3598
3599                             if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3600                                 http_log("Codecs do not match for stream %d\n", i);
3601                                 matches = 0;
3602                             } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3603                                 http_log("Codec bitrates do not match for stream %d\n", i);
3604                                 matches = 0;
3605                             } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3606                                 if (CHECK_CODEC(time_base.den) ||
3607                                     CHECK_CODEC(time_base.num) ||
3608                                     CHECK_CODEC(width) ||
3609                                     CHECK_CODEC(height)) {
3610                                     http_log("Codec width, height and framerate do not match for stream %d\n", i);
3611                                     matches = 0;
3612                                 }
3613                             } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3614                                 if (CHECK_CODEC(sample_rate) ||
3615                                     CHECK_CODEC(channels) ||
3616                                     CHECK_CODEC(frame_size)) {
3617                                     http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3618                                     matches = 0;
3619                                 }
3620                             } else {
3621                                 http_log("Unknown codec type\n");
3622                                 matches = 0;
3623                             }
3624                         }
3625                         if (!matches)
3626                             break;
3627                     }
3628                 } else
3629                     http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3630                         feed->feed_filename, s->nb_streams, feed->nb_streams);
3631
3632                 avformat_close_input(&s);
3633             } else
3634                 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3635                         feed->feed_filename);
3636
3637             if (!matches) {
3638                 if (feed->readonly) {
3639                     http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3640                         feed->feed_filename);
3641                     exit(1);
3642                 }
3643                 unlink(feed->feed_filename);
3644             }
3645         }
3646         if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3647             AVFormatContext *s = avformat_alloc_context();
3648
3649             if (feed->readonly) {
3650                 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3651                     feed->feed_filename);
3652                 exit(1);
3653             }
3654
3655             /* only write the header of the ffm file */
3656             if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3657                 http_log("Could not open output feed file '%s'\n",
3658                          feed->feed_filename);
3659                 exit(1);
3660             }
3661             s->oformat = feed->fmt;
3662             s->nb_streams = feed->nb_streams;
3663             s->streams = feed->streams;
3664             if (avformat_write_header(s, NULL) < 0) {
3665                 http_log("Container doesn't support the required parameters\n");
3666                 exit(1);
3667             }
3668             /* XXX: need better API */
3669             av_freep(&s->priv_data);
3670             avio_closep(&s->pb);
3671             s->streams = NULL;
3672             s->nb_streams = 0;
3673             avformat_free_context(s);
3674         }
3675         /* get feed size and write index */
3676         fd = open(feed->feed_filename, O_RDONLY);
3677         if (fd < 0) {
3678             http_log("Could not open output feed file '%s'\n",
3679                     feed->feed_filename);
3680             exit(1);
3681         }
3682
3683         feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3684         feed->feed_size = lseek(fd, 0, SEEK_END);
3685         /* ensure that we do not wrap before the end of file */
3686         if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3687             feed->feed_max_size = feed->feed_size;
3688
3689         close(fd);
3690     }
3691 }
3692
3693 /* compute the bandwidth used by each stream */
3694 static void compute_bandwidth(void)
3695 {
3696     unsigned bandwidth;
3697     int i;
3698     FFServerStream *stream;
3699
3700     for(stream = config.first_stream; stream; stream = stream->next) {
3701         bandwidth = 0;
3702         for(i=0;i<stream->nb_streams;i++) {
3703             AVStream *st = stream->streams[i];
3704             switch(st->codec->codec_type) {
3705             case AVMEDIA_TYPE_AUDIO:
3706             case AVMEDIA_TYPE_VIDEO:
3707                 bandwidth += st->codec->bit_rate;
3708                 break;
3709             default:
3710                 break;
3711             }
3712         }
3713         stream->bandwidth = (bandwidth + 999) / 1000;
3714     }
3715 }
3716
3717 static void handle_child_exit(int sig)
3718 {
3719     pid_t pid;
3720     int status;
3721
3722     while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
3723         FFServerStream *feed;
3724
3725         for (feed = config.first_feed; feed; feed = feed->next) {
3726             if (feed->pid == pid) {
3727                 int uptime = time(0) - feed->pid_start;
3728
3729                 feed->pid = 0;
3730                 fprintf(stderr,
3731                         "%s: Pid %d exited with status %d after %d seconds\n",
3732                         feed->filename, pid, status, uptime);
3733
3734                 if (uptime < 30)
3735                     /* Turn off any more restarts */
3736                     ffserver_free_child_args(&feed->child_argv);
3737             }
3738         }
3739     }
3740
3741     need_to_start_children = 1;
3742 }
3743
3744 static void opt_debug(void)
3745 {
3746     config.debug = 1;
3747     snprintf(config.logfilename, sizeof(config.logfilename), "-");
3748 }
3749
3750 void show_help_default(const char *opt, const char *arg)
3751 {
3752     printf("usage: ffserver [options]\n"
3753            "Hyper fast multi format Audio/Video streaming server\n");
3754     printf("\n");
3755     show_help_options(options, "Main options:", 0, 0, 0);
3756 }
3757
3758 static const OptionDef options[] = {
3759 #include "cmdutils_common_opts.h"
3760     { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
3761     { "d", 0, {(void*)opt_debug}, "enable debug mode" },
3762     { "f", HAS_ARG | OPT_STRING, {(void*)&config.filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
3763     { NULL },
3764 };
3765
3766 int main(int argc, char **argv)
3767 {
3768     struct sigaction sigact = { { 0 } };
3769     int ret = 0;
3770
3771     config.filename = av_strdup("/etc/ffserver.conf");
3772
3773     parse_loglevel(argc, argv, options);
3774     av_register_all();
3775     avformat_network_init();
3776
3777     show_banner(argc, argv, options);
3778
3779     my_program_name = argv[0];
3780
3781     parse_options(NULL, argc, argv, options, NULL);
3782
3783     unsetenv("http_proxy");             /* Kill the http_proxy */
3784
3785     av_lfg_init(&random_state, av_get_random_seed());
3786
3787     sigact.sa_handler = handle_child_exit;
3788     sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
3789     sigaction(SIGCHLD, &sigact, 0);
3790
3791     if ((ret = ffserver_parse_ffconfig(config.filename, &config)) < 0) {
3792         fprintf(stderr, "Error reading configuration file '%s': %s\n",
3793                 config.filename, av_err2str(ret));
3794         exit(1);
3795     }
3796     av_freep(&config.filename);
3797
3798     /* open log file if needed */
3799     if (config.logfilename[0] != '\0') {
3800         if (!strcmp(config.logfilename, "-"))
3801             logfile = stdout;
3802         else
3803             logfile = fopen(config.logfilename, "a");
3804         av_log_set_callback(http_av_log);
3805     }
3806
3807     build_file_streams();
3808
3809     build_feed_streams();
3810
3811     compute_bandwidth();
3812
3813     /* signal init */
3814     signal(SIGPIPE, SIG_IGN);
3815
3816     if (http_server() < 0) {
3817         http_log("Could not start server\n");
3818         exit(1);
3819     }
3820
3821     return 0;
3822 }