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