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