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