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