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