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