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