projects / libav.git / blob
? search:


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