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