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