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