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