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