1 /*****************************************************************************
3 *****************************************************************************
4 * Copyright (C) 2004-2006 VLC authors and VideoLAN
5 * Copyright © 2004-2007 Rémi Denis-Courmont
8 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
9 * Rémi Denis-Courmont <rem # videolan.org>
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License as published by
13 * the Free Software Foundation; either version 2.1 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public License
22 * along with this program; if not, write to the Free Software Foundation,
23 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 *****************************************************************************/
30 #include <vlc_common.h>
31 #include <vlc_httpd.h>
35 #include <vlc_network.h>
37 #include <vlc_strings.h>
39 #include <vlc_charset.h>
42 #include <vlc_block.h>
43 #include "../libvlc.h"
54 # include <winsock2.h>
56 # include <sys/socket.h>
60 /* We need HUGE buffer otherwise TCP throughput is very limited */
61 #define HTTPD_CL_BUFSIZE 1000000
63 #define HTTPD_CL_BUFSIZE 10000
66 static void httpd_ClientDestroy(httpd_client_t
*cl
);
67 static void httpd_AppendData(httpd_stream_t
*stream
, uint8_t *p_data
, int i_data
);
69 /* each host run in his own thread */
77 /* address/port and socket for listening at connections */
86 /* all registered url (becarefull that 2 httpd_url_t could point at the same url)
87 * This will slow down the url research but make my live easier
88 * All url will have their cb trigger, but only the first one can answer
94 httpd_client_t
**client
;
97 vlc_tls_creds_t
*p_tls
;
114 httpd_callback_sys_t
*p_sys
;
115 } catch[HTTPD_MSG_MAX
];
121 HTTPD_CLIENT_RECEIVING
,
122 HTTPD_CLIENT_RECEIVE_DONE
,
124 HTTPD_CLIENT_SENDING
,
125 HTTPD_CLIENT_SEND_DONE
,
127 HTTPD_CLIENT_WAITING
,
131 HTTPD_CLIENT_TLS_HS_IN
,
132 HTTPD_CLIENT_TLS_HS_OUT
138 HTTPD_CLIENT_FILE
, /* default */
139 HTTPD_CLIENT_STREAM
, /* regulary get data from cb */
142 struct httpd_client_t
153 mtime_t i_activity_date
;
154 mtime_t i_activity_timeout
;
156 /* buffer for reading header */
162 * If waiting for a keyframe, this is the position (in bytes) of the
163 * last keyframe the stream saw before this client connected.
166 int64_t i_keyframe_wait_to_pass
;
169 httpd_message_t query
; /* client -> httpd */
170 httpd_message_t answer
; /* httpd -> client */
177 /*****************************************************************************
179 *****************************************************************************/
180 static const char *httpd_ReasonFromCode(unsigned i_code
)
185 const char psz_reason
[36];
188 static const http_status_info http_reason
[] =
190 /*{ 100, "Continue" },
191 { 101, "Switching Protocols" },*/
193 /*{ 201, "Created" },
195 { 203, "Non-authoritative information" },
196 { 204, "No content" },
197 { 205, "Reset content" },
198 { 206, "Partial content" },
199 { 250, "Low on storage space" },
200 { 300, "Multiple choices" },*/
201 { 301, "Moved permanently" },
202 /*{ 302, "Moved temporarily" },
203 { 303, "See other" },
204 { 304, "Not modified" },
205 { 305, "Use proxy" },
206 { 307, "Temporary redirect" },
207 { 400, "Bad request" },*/
208 { 401, "Unauthorized" },
209 /*{ 402, "Payment Required" },*/
210 { 403, "Forbidden" },
211 { 404, "Not found" },
212 { 405, "Method not allowed" },
213 /*{ 406, "Not acceptable" },
214 { 407, "Proxy authentication required" },
215 { 408, "Request time-out" },
218 { 411, "Length required" },
219 { 412, "Precondition failed" },
220 { 413, "Request entity too large" },
221 { 414, "Request-URI too large" },
222 { 415, "Unsupported media Type" },
223 { 416, "Requested range not satisfiable" },
224 { 417, "Expectation failed" },
225 { 451, "Parameter not understood" },
226 { 452, "Conference not found" },
227 { 453, "Not enough bandwidth" },*/
228 { 454, "Session not found" },
229 { 455, "Method not valid in this State" },
230 { 456, "Header field not valid for resource" },
231 { 457, "Invalid range" },
232 /*{ 458, "Read-only parameter" },*/
233 { 459, "Aggregate operation not allowed" },
234 { 460, "Non-aggregate operation not allowed" },
235 { 461, "Unsupported transport" },
236 /*{ 462, "Destination unreachable" },*/
237 { 500, "Internal server error" },
238 { 501, "Not implemented" },
239 /*{ 502, "Bad gateway" },*/
240 { 503, "Service unavailable" },
241 /*{ 504, "Gateway time-out" },*/
242 { 505, "Protocol version not supported" },
243 { 551, "Option not supported" },
247 static const char psz_fallback_reason
[5][16] = {
248 "Continue", "OK", "Found", "Client error", "Server error"
251 assert((i_code
>= 100) && (i_code
<= 599));
253 const http_status_info
*p
= http_reason
;
254 while (i_code
< p
->i_code
)
257 if (p
->i_code
== i_code
)
258 return p
->psz_reason
;
260 return psz_fallback_reason
[(i_code
/ 100) - 1];
263 static size_t httpd_HtmlError (char **body
, int code
, const char *url
)
265 const char *errname
= httpd_ReasonFromCode (code
);
268 char *url_Encoded
= vlc_xml_encode (url
? url
: "");
270 int res
= asprintf (body
,
271 "<?xml version=\"1.0\" encoding=\"ascii\" ?>\n"
272 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\""
273 " \"http://www.w3.org/TR/xhtml10/DTD/xhtml10strict.dtd\">\n"
274 "<html lang=\"en\">\n"
276 "<title>%s</title>\n"
279 "<h1>%d %s%s%s%s</h1>\n"
281 "<a href=\"http://www.videolan.org\">VideoLAN</a>\n"
283 "</html>\n", errname
, code
, errname
,
284 (url_Encoded
? " (" : ""), (url_Encoded
? url_Encoded
: ""), (url_Encoded
? ")" : ""));
297 /*****************************************************************************
298 * High Level Functions: httpd_file_t
299 *****************************************************************************/
303 httpd_file_callback_t pf_fill
;
304 httpd_file_sys_t
*p_sys
;
309 httpd_FileCallBack(httpd_callback_sys_t
*p_sys
, httpd_client_t
*cl
,
310 httpd_message_t
*answer
, const httpd_message_t
*query
)
312 httpd_file_t
*file
= (httpd_file_t
*)p_sys
;
313 uint8_t **pp_body
, *p_body
; const char *psz_connection
;
314 int *pi_body
, i_body
;
316 if (!answer
|| !query
)
319 answer
->i_proto
= HTTPD_PROTO_HTTP
;
320 answer
->i_version
= 1;
321 answer
->i_type
= HTTPD_MSG_ANSWER
;
323 answer
->i_status
= 200;
325 httpd_MsgAdd(answer
, "Content-type", "%s", file
->mime
);
326 httpd_MsgAdd(answer
, "Cache-Control", "%s", "no-cache");
328 if (query
->i_type
!= HTTPD_MSG_HEAD
) {
329 pp_body
= &answer
->p_body
;
330 pi_body
= &answer
->i_body
;
332 /* The file still needs to be executed. */
339 if (query
->i_type
== HTTPD_MSG_POST
) {
340 /* msg_Warn not supported */
343 uint8_t *psz_args
= query
->psz_args
;
344 file
->pf_fill(file
->p_sys
, file
, psz_args
, pp_body
, pi_body
);
346 if (query
->i_type
== HTTPD_MSG_HEAD
)
349 /* We respect client request */
350 psz_connection
= httpd_MsgGet(&cl
->query
, "Connection");
352 httpd_MsgAdd(answer
, "Connection", "%s", psz_connection
);
354 httpd_MsgAdd(answer
, "Content-Length", "%d", answer
->i_body
);
359 httpd_file_t
*httpd_FileNew(httpd_host_t
*host
,
360 const char *psz_url
, const char *psz_mime
,
361 const char *psz_user
, const char *psz_password
,
362 httpd_file_callback_t pf_fill
,
363 httpd_file_sys_t
*p_sys
)
365 const char *mime
= psz_mime
;
366 if (mime
== NULL
|| mime
[0] == '\0')
367 mime
= vlc_mime_Ext2Mime(psz_url
);
369 size_t mimelen
= strlen(mime
);
370 httpd_file_t
*file
= malloc(sizeof(*file
) + mimelen
);
371 if (unlikely(file
== NULL
))
374 file
->url
= httpd_UrlNew(host
, psz_url
, psz_user
, psz_password
);
380 file
->pf_fill
= pf_fill
;
382 memcpy(file
->mime
, mime
, mimelen
+ 1);
384 httpd_UrlCatch(file
->url
, HTTPD_MSG_HEAD
, httpd_FileCallBack
,
385 (httpd_callback_sys_t
*)file
);
386 httpd_UrlCatch(file
->url
, HTTPD_MSG_GET
, httpd_FileCallBack
,
387 (httpd_callback_sys_t
*)file
);
388 httpd_UrlCatch(file
->url
, HTTPD_MSG_POST
, httpd_FileCallBack
,
389 (httpd_callback_sys_t
*)file
);
394 httpd_file_sys_t
*httpd_FileDelete(httpd_file_t
*file
)
396 httpd_file_sys_t
*p_sys
= file
->p_sys
;
398 httpd_UrlDelete(file
->url
);
403 /*****************************************************************************
404 * High Level Functions: httpd_handler_t (for CGIs)
405 *****************************************************************************/
406 struct httpd_handler_t
410 httpd_handler_callback_t pf_fill
;
411 httpd_handler_sys_t
*p_sys
;
416 httpd_HandlerCallBack(httpd_callback_sys_t
*p_sys
, httpd_client_t
*cl
,
417 httpd_message_t
*answer
, const httpd_message_t
*query
)
419 httpd_handler_t
*handler
= (httpd_handler_t
*)p_sys
;
420 char psz_remote_addr
[NI_MAXNUMERICHOST
];
422 if (!answer
|| !query
)
425 answer
->i_proto
= HTTPD_PROTO_NONE
;
426 answer
->i_type
= HTTPD_MSG_ANSWER
;
428 /* We do it ourselves, thanks */
429 answer
->i_status
= 0;
431 if (!httpd_ClientIP(cl
, psz_remote_addr
, NULL
))
432 *psz_remote_addr
= '\0';
434 uint8_t *psz_args
= query
->psz_args
;
435 handler
->pf_fill(handler
->p_sys
, handler
, query
->psz_url
, psz_args
,
436 query
->i_type
, query
->p_body
, query
->i_body
,
437 psz_remote_addr
, NULL
,
438 &answer
->p_body
, &answer
->i_body
);
440 if (query
->i_type
== HTTPD_MSG_HEAD
) {
441 char *p
= (char *)answer
->p_body
;
443 /* Looks for end of header (i.e. one empty line) */
444 while ((p
= strchr(p
, '\r')))
445 if (p
[1] == '\n' && p
[2] == '\r' && p
[3] == '\n')
450 answer
->i_body
= strlen((char*)answer
->p_body
) + 1;
451 answer
->p_body
= xrealloc(answer
->p_body
, answer
->i_body
);
455 if (strncmp((char *)answer
->p_body
, "HTTP/1.", 7)) {
456 int i_status
, i_headers
;
457 char *psz_headers
, *psz_new
;
458 const char *psz_status
;
460 if (!strncmp((char *)answer
->p_body
, "Status: ", 8)) {
462 i_status
= strtol((char *)&answer
->p_body
[8], &psz_headers
, 0);
463 if (*psz_headers
== '\r' || *psz_headers
== '\n') psz_headers
++;
464 if (*psz_headers
== '\n') psz_headers
++;
465 i_headers
= answer
->i_body
- (psz_headers
- (char *)answer
->p_body
);
468 psz_headers
= (char *)answer
->p_body
;
469 i_headers
= answer
->i_body
;
472 psz_status
= httpd_ReasonFromCode(i_status
);
473 answer
->i_body
= sizeof("HTTP/1.0 xxx \r\n")
474 + strlen(psz_status
) + i_headers
- 1;
475 psz_new
= (char *)xmalloc(answer
->i_body
+ 1);
476 sprintf(psz_new
, "HTTP/1.0 %03d %s\r\n", i_status
, psz_status
);
477 memcpy(&psz_new
[strlen(psz_new
)], psz_headers
, i_headers
);
478 free(answer
->p_body
);
479 answer
->p_body
= (uint8_t *)psz_new
;
485 httpd_handler_t
*httpd_HandlerNew(httpd_host_t
*host
, const char *psz_url
,
486 const char *psz_user
,
487 const char *psz_password
,
488 httpd_handler_callback_t pf_fill
,
489 httpd_handler_sys_t
*p_sys
)
491 httpd_handler_t
*handler
= malloc(sizeof(*handler
));
495 handler
->url
= httpd_UrlNew(host
, psz_url
, psz_user
, psz_password
);
501 handler
->pf_fill
= pf_fill
;
502 handler
->p_sys
= p_sys
;
504 httpd_UrlCatch(handler
->url
, HTTPD_MSG_HEAD
, httpd_HandlerCallBack
,
505 (httpd_callback_sys_t
*)handler
);
506 httpd_UrlCatch(handler
->url
, HTTPD_MSG_GET
, httpd_HandlerCallBack
,
507 (httpd_callback_sys_t
*)handler
);
508 httpd_UrlCatch(handler
->url
, HTTPD_MSG_POST
, httpd_HandlerCallBack
,
509 (httpd_callback_sys_t
*)handler
);
514 httpd_handler_sys_t
*httpd_HandlerDelete(httpd_handler_t
*handler
)
516 httpd_handler_sys_t
*p_sys
= handler
->p_sys
;
517 httpd_UrlDelete(handler
->url
);
522 /*****************************************************************************
523 * High Level Functions: httpd_redirect_t
524 *****************************************************************************/
525 struct httpd_redirect_t
531 static int httpd_RedirectCallBack(httpd_callback_sys_t
*p_sys
,
532 httpd_client_t
*cl
, httpd_message_t
*answer
,
533 const httpd_message_t
*query
)
535 httpd_redirect_t
*rdir
= (httpd_redirect_t
*)p_sys
;
539 if (!answer
|| !query
)
542 answer
->i_proto
= HTTPD_PROTO_HTTP
;
543 answer
->i_version
= 1;
544 answer
->i_type
= HTTPD_MSG_ANSWER
;
545 answer
->i_status
= 301;
547 answer
->i_body
= httpd_HtmlError (&p_body
, 301, rdir
->dst
);
548 answer
->p_body
= (unsigned char *)p_body
;
550 /* XXX check if it's ok or we need to set an absolute url */
551 httpd_MsgAdd(answer
, "Location", "%s", rdir
->dst
);
553 httpd_MsgAdd(answer
, "Content-Length", "%d", answer
->i_body
);
558 httpd_redirect_t
*httpd_RedirectNew(httpd_host_t
*host
, const char *psz_url_dst
,
559 const char *psz_url_src
)
561 size_t dstlen
= strlen(psz_url_dst
);
563 httpd_redirect_t
*rdir
= malloc(sizeof(*rdir
) + dstlen
);
564 if (unlikely(rdir
== NULL
))
567 rdir
->url
= httpd_UrlNew(host
, psz_url_src
, NULL
, NULL
);
572 memcpy(rdir
->dst
, psz_url_dst
, dstlen
+ 1);
574 /* Redirect apply for all HTTP request and RTSP DESCRIBE resquest */
575 httpd_UrlCatch(rdir
->url
, HTTPD_MSG_HEAD
, httpd_RedirectCallBack
,
576 (httpd_callback_sys_t
*)rdir
);
577 httpd_UrlCatch(rdir
->url
, HTTPD_MSG_GET
, httpd_RedirectCallBack
,
578 (httpd_callback_sys_t
*)rdir
);
579 httpd_UrlCatch(rdir
->url
, HTTPD_MSG_POST
, httpd_RedirectCallBack
,
580 (httpd_callback_sys_t
*)rdir
);
581 httpd_UrlCatch(rdir
->url
, HTTPD_MSG_DESCRIBE
, httpd_RedirectCallBack
,
582 (httpd_callback_sys_t
*)rdir
);
586 void httpd_RedirectDelete(httpd_redirect_t
*rdir
)
588 httpd_UrlDelete(rdir
->url
);
592 /*****************************************************************************
593 * High Level Funtions: httpd_stream_t
594 *****************************************************************************/
595 struct httpd_stream_t
602 /* Header to send as first packet */
606 /* Some muxes, in particular the avformat mux, can mark given blocks
607 * as keyframes, to ensure that the stream starts with one.
608 * (This is particularly important for WebM streaming to certain
609 * browsers.) Store if we've ever seen any such keyframe blocks,
610 * and if so, the byte position of the start of the last one. */
611 bool b_has_keyframes
;
612 int64_t i_last_keyframe_seen_pos
;
614 /* circular buffer */
615 int i_buffer_size
; /* buffer size, can't be reallocated smaller */
616 uint8_t *p_buffer
; /* buffer */
617 int64_t i_buffer_pos
; /* absolute position from beginning */
618 int64_t i_buffer_last_pos
; /* a new connection will start with that */
621 size_t i_http_headers
;
622 httpd_header
* p_http_headers
;
625 static int httpd_StreamCallBack(httpd_callback_sys_t
*p_sys
,
626 httpd_client_t
*cl
, httpd_message_t
*answer
,
627 const httpd_message_t
*query
)
629 httpd_stream_t
*stream
= (httpd_stream_t
*)p_sys
;
631 if (!answer
|| !query
|| !cl
)
634 if (answer
->i_body_offset
> 0) {
637 if (answer
->i_body_offset
>= stream
->i_buffer_pos
)
638 return VLC_EGENERIC
; /* wait, no data available */
640 if (cl
->i_keyframe_wait_to_pass
>= 0) {
641 if (stream
->i_last_keyframe_seen_pos
<= cl
->i_keyframe_wait_to_pass
)
642 /* still waiting for the next keyframe */
645 /* seek to the new keyframe */
646 answer
->i_body_offset
= stream
->i_last_keyframe_seen_pos
;
647 cl
->i_keyframe_wait_to_pass
= -1;
650 if (answer
->i_body_offset
+ stream
->i_buffer_size
< stream
->i_buffer_pos
)
651 answer
->i_body_offset
= stream
->i_buffer_last_pos
; /* this client isn't fast enough */
653 i_pos
= answer
->i_body_offset
% stream
->i_buffer_size
;
654 int64_t i_write
= stream
->i_buffer_pos
- answer
->i_body_offset
;
656 if (i_write
> HTTPD_CL_BUFSIZE
)
657 i_write
= HTTPD_CL_BUFSIZE
;
658 else if (i_write
<= 0)
659 return VLC_EGENERIC
; /* wait, no data available */
661 /* Don't go past the end of the circular buffer */
662 i_write
= __MIN(i_write
, stream
->i_buffer_size
- i_pos
);
664 /* using HTTPD_MSG_ANSWER -> data available */
665 answer
->i_proto
= HTTPD_PROTO_HTTP
;
666 answer
->i_version
= 0;
667 answer
->i_type
= HTTPD_MSG_ANSWER
;
669 answer
->i_body
= i_write
;
670 answer
->p_body
= xmalloc(i_write
);
671 memcpy(answer
->p_body
, &stream
->p_buffer
[i_pos
], i_write
);
673 answer
->i_body_offset
+= i_write
;
677 answer
->i_proto
= HTTPD_PROTO_HTTP
;
678 answer
->i_version
= 0;
679 answer
->i_type
= HTTPD_MSG_ANSWER
;
681 answer
->i_status
= 200;
683 bool b_has_content_type
= false;
684 bool b_has_cache_control
= false;
686 vlc_mutex_lock(&stream
->lock
);
687 for (size_t i
= 0; i
< stream
->i_http_headers
; i
++)
688 if (strncasecmp(stream
->p_http_headers
[i
].name
, "Content-Length", 14)) {
689 httpd_MsgAdd(answer
, stream
->p_http_headers
[i
].name
, "%s",
690 stream
->p_http_headers
[i
].value
);
692 if (!strncasecmp(stream
->p_http_headers
[i
].name
, "Content-Type", 12))
693 b_has_content_type
= true;
694 else if (!strncasecmp(stream
->p_http_headers
[i
].name
, "Cache-Control", 13))
695 b_has_cache_control
= true;
697 vlc_mutex_unlock(&stream
->lock
);
699 if (query
->i_type
!= HTTPD_MSG_HEAD
) {
700 cl
->b_stream_mode
= true;
701 vlc_mutex_lock(&stream
->lock
);
702 /* Send the header */
703 if (stream
->i_header
> 0) {
704 answer
->i_body
= stream
->i_header
;
705 answer
->p_body
= xmalloc(stream
->i_header
);
706 memcpy(answer
->p_body
, stream
->p_header
, stream
->i_header
);
708 answer
->i_body_offset
= stream
->i_buffer_last_pos
;
709 if (stream
->b_has_keyframes
)
710 cl
->i_keyframe_wait_to_pass
= stream
->i_last_keyframe_seen_pos
;
712 cl
->i_keyframe_wait_to_pass
= -1;
713 vlc_mutex_unlock(&stream
->lock
);
715 httpd_MsgAdd(answer
, "Content-Length", "0");
716 answer
->i_body_offset
= 0;
719 /* FIXME: move to http access_output */
720 if (!strcmp(stream
->psz_mime
, "video/x-ms-asf-stream")) {
721 bool b_xplaystream
= false;
723 httpd_MsgAdd(answer
, "Content-type", "application/octet-stream");
724 httpd_MsgAdd(answer
, "Server", "Cougar 4.1.0.3921");
725 httpd_MsgAdd(answer
, "Pragma", "no-cache");
726 httpd_MsgAdd(answer
, "Pragma", "client-id=%lu",
727 vlc_mrand48()&0x7fff);
728 httpd_MsgAdd(answer
, "Pragma", "features=\"broadcast\"");
730 /* Check if there is a xPlayStrm=1 */
731 for (size_t i
= 0; i
< query
->i_headers
; i
++)
732 if (!strcasecmp(query
->p_headers
[i
].name
, "Pragma") &&
733 strstr(query
->p_headers
[i
].value
, "xPlayStrm=1"))
734 b_xplaystream
= true;
737 answer
->i_body_offset
= 0;
738 } else if (!b_has_content_type
)
739 httpd_MsgAdd(answer
, "Content-type", "%s", stream
->psz_mime
);
741 if (!b_has_cache_control
)
742 httpd_MsgAdd(answer
, "Cache-Control", "no-cache");
747 httpd_stream_t
*httpd_StreamNew(httpd_host_t
*host
,
748 const char *psz_url
, const char *psz_mime
,
749 const char *psz_user
, const char *psz_password
)
751 httpd_stream_t
*stream
= malloc(sizeof(*stream
));
755 stream
->url
= httpd_UrlNew(host
, psz_url
, psz_user
, psz_password
);
761 vlc_mutex_init(&stream
->lock
);
762 if (psz_mime
== NULL
|| psz_mime
[0] == '\0')
763 psz_mime
= vlc_mime_Ext2Mime(psz_url
);
764 stream
->psz_mime
= xstrdup(psz_mime
);
766 stream
->i_header
= 0;
767 stream
->p_header
= NULL
;
768 stream
->i_buffer_size
= 5000000; /* 5 Mo per stream */
769 stream
->p_buffer
= xmalloc(stream
->i_buffer_size
);
770 /* We set to 1 to make life simpler
771 * (this way i_body_offset can never be 0) */
772 stream
->i_buffer_pos
= 1;
773 stream
->i_buffer_last_pos
= 1;
774 stream
->b_has_keyframes
= false;
775 stream
->i_last_keyframe_seen_pos
= 0;
776 stream
->i_http_headers
= 0;
777 stream
->p_http_headers
= NULL
;
779 httpd_UrlCatch(stream
->url
, HTTPD_MSG_HEAD
, httpd_StreamCallBack
,
780 (httpd_callback_sys_t
*)stream
);
781 httpd_UrlCatch(stream
->url
, HTTPD_MSG_GET
, httpd_StreamCallBack
,
782 (httpd_callback_sys_t
*)stream
);
783 httpd_UrlCatch(stream
->url
, HTTPD_MSG_POST
, httpd_StreamCallBack
,
784 (httpd_callback_sys_t
*)stream
);
789 int httpd_StreamHeader(httpd_stream_t
*stream
, uint8_t *p_data
, int i_data
)
791 vlc_mutex_lock(&stream
->lock
);
792 free(stream
->p_header
);
793 stream
->p_header
= NULL
;
795 stream
->i_header
= i_data
;
797 stream
->p_header
= xmalloc(i_data
);
798 memcpy(stream
->p_header
, p_data
, i_data
);
800 vlc_mutex_unlock(&stream
->lock
);
805 static void httpd_AppendData(httpd_stream_t
*stream
, uint8_t *p_data
, int i_data
)
807 int i_pos
= stream
->i_buffer_pos
% stream
->i_buffer_size
;
808 int i_count
= i_data
;
809 while (i_count
> 0) {
810 int i_copy
= __MIN(i_count
, stream
->i_buffer_size
- i_pos
);
812 /* Ok, we can't go past the end of our buffer */
813 memcpy(&stream
->p_buffer
[i_pos
], p_data
, i_copy
);
815 i_pos
= (i_pos
+ i_copy
) % stream
->i_buffer_size
;
820 stream
->i_buffer_pos
+= i_data
;
823 int httpd_StreamSend(httpd_stream_t
*stream
, const block_t
*p_block
)
825 if (!p_block
|| !p_block
->p_buffer
)
828 vlc_mutex_lock(&stream
->lock
);
830 /* save this pointer (to be used by new connection) */
831 stream
->i_buffer_last_pos
= stream
->i_buffer_pos
;
833 if (p_block
->i_flags
& BLOCK_FLAG_TYPE_I
) {
834 stream
->b_has_keyframes
= true;
835 stream
->i_last_keyframe_seen_pos
= stream
->i_buffer_pos
;
838 httpd_AppendData(stream
, p_block
->p_buffer
, p_block
->i_buffer
);
840 vlc_mutex_unlock(&stream
->lock
);
844 void httpd_StreamDelete(httpd_stream_t
*stream
)
846 httpd_UrlDelete(stream
->url
);
847 for (size_t i
= 0; i
< stream
->i_http_headers
; i
++) {
848 free(stream
->p_http_headers
[i
].name
);
849 free(stream
->p_http_headers
[i
].value
);
851 free(stream
->p_http_headers
);
852 vlc_mutex_destroy(&stream
->lock
);
853 free(stream
->psz_mime
);
854 free(stream
->p_header
);
855 free(stream
->p_buffer
);
859 /*****************************************************************************
861 *****************************************************************************/
862 static void* httpd_HostThread(void *);
863 static httpd_host_t
*httpd_HostCreate(vlc_object_t
*, const char *,
864 const char *, vlc_tls_creds_t
*);
866 /* create a new host */
867 httpd_host_t
*vlc_http_HostNew(vlc_object_t
*p_this
)
869 return httpd_HostCreate(p_this
, "http-host", "http-port", NULL
);
872 httpd_host_t
*vlc_https_HostNew(vlc_object_t
*obj
)
874 char *cert
= var_InheritString(obj
, "http-cert");
876 msg_Err(obj
, "HTTP/TLS certificate not specified!");
880 char *key
= var_InheritString(obj
, "http-key");
881 vlc_tls_creds_t
*tls
= vlc_tls_ServerCreate(obj
, cert
, key
);
884 msg_Err(obj
, "HTTP/TLS certificate error (%s and %s)",
885 cert
, key
? key
: cert
);
893 return httpd_HostCreate(obj
, "http-host", "https-port", tls
);
896 httpd_host_t
*vlc_rtsp_HostNew(vlc_object_t
*p_this
)
898 return httpd_HostCreate(p_this
, "rtsp-host", "rtsp-port", NULL
);
907 } httpd
= { VLC_STATIC_MUTEX
, NULL
, 0 };
909 static httpd_host_t
*httpd_HostCreate(vlc_object_t
*p_this
,
912 vlc_tls_creds_t
*p_tls
)
915 char *hostname
= var_InheritString(p_this
, hostvar
);
916 unsigned port
= var_InheritInteger(p_this
, portvar
);
919 vlc_UrlParse(&url
, hostname
);
921 if (url
.i_port
!= 0) {
922 msg_Err(p_this
, "Ignoring port %d (using %d)", url
.i_port
, port
);
923 msg_Info(p_this
, "Specify port %d separately with the "
924 "%s option instead.", url
.i_port
, portvar
);
927 /* to be sure to avoid multiple creation */
928 vlc_mutex_lock(&httpd
.mutex
);
930 /* verify if it already exist */
931 for (int i
= 0; i
< httpd
.i_host
; i
++) {
932 host
= httpd
.host
[i
];
934 /* cannot mix TLS and non-TLS hosts */
935 if (host
->port
!= port
936 || (host
->p_tls
!= NULL
) != (p_tls
!= NULL
))
939 /* Increase existing matching host reference count.
940 * The reference count is written under both the global httpd and the
941 * host lock. It is read with either or both locks held. The global
942 * lock is always acquired first. */
943 vlc_mutex_lock(&host
->lock
);
945 vlc_mutex_unlock(&host
->lock
);
947 vlc_mutex_unlock(&httpd
.mutex
);
949 vlc_tls_Delete(p_tls
);
953 /* create the new host */
954 host
= (httpd_host_t
*)vlc_custom_create(p_this
, sizeof (*host
),
959 vlc_mutex_init(&host
->lock
);
960 vlc_cond_init(&host
->wait
);
963 host
->fds
= net_ListenTCP(p_this
, url
.psz_host
, port
);
965 msg_Err(p_this
, "cannot create socket(s) for HTTP host");
968 for (host
->nfd
= 0; host
->fds
[host
->nfd
] != -1; host
->nfd
++);
977 /* create the thread */
978 if (vlc_clone(&host
->thread
, httpd_HostThread
, host
,
979 VLC_THREAD_PRIORITY_LOW
)) {
980 msg_Err(p_this
, "cannot spawn http host thread");
984 /* now add it to httpd */
985 TAB_APPEND(httpd
.i_host
, httpd
.host
, host
);
986 vlc_mutex_unlock(&httpd
.mutex
);
993 vlc_mutex_unlock(&httpd
.mutex
);
996 net_ListenClose(host
->fds
);
997 vlc_cond_destroy(&host
->wait
);
998 vlc_mutex_destroy(&host
->lock
);
999 vlc_object_release(host
);
1003 vlc_tls_Delete(p_tls
);
1008 void httpd_HostDelete(httpd_host_t
*host
)
1010 bool delete = false;
1012 vlc_mutex_lock(&httpd
.mutex
);
1014 vlc_mutex_lock(&host
->lock
);
1016 if (host
->i_ref
== 0)
1018 vlc_mutex_unlock(&host
->lock
);
1021 vlc_mutex_unlock(&httpd
.mutex
);
1022 msg_Dbg(host
, "httpd_HostDelete: host still in use");
1025 TAB_REMOVE(httpd
.i_host
, httpd
.host
, host
);
1027 vlc_cancel(host
->thread
);
1028 vlc_join(host
->thread
, NULL
);
1030 msg_Dbg(host
, "HTTP host removed");
1032 for (int i
= 0; i
< host
->i_url
; i
++)
1033 msg_Err(host
, "url still registered: %s", host
->url
[i
]->psz_url
);
1035 for (int i
= 0; i
< host
->i_client
; i
++) {
1036 msg_Warn(host
, "client still connected");
1037 httpd_ClientDestroy(host
->client
[i
]);
1039 TAB_CLEAN(host
->i_client
, host
->client
);
1041 vlc_tls_Delete(host
->p_tls
);
1042 net_ListenClose(host
->fds
);
1043 vlc_cond_destroy(&host
->wait
);
1044 vlc_mutex_destroy(&host
->lock
);
1045 vlc_object_release(host
);
1046 vlc_mutex_unlock(&httpd
.mutex
);
1049 /* register a new url */
1050 httpd_url_t
*httpd_UrlNew(httpd_host_t
*host
, const char *psz_url
,
1051 const char *psz_user
, const char *psz_password
)
1057 vlc_mutex_lock(&host
->lock
);
1058 for (int i
= 0; i
< host
->i_url
; i
++)
1059 if (!strcmp(psz_url
, host
->url
[i
]->psz_url
)) {
1060 msg_Warn(host
, "cannot add '%s' (url already defined)", psz_url
);
1061 vlc_mutex_unlock(&host
->lock
);
1065 url
= xmalloc(sizeof(httpd_url_t
));
1068 vlc_mutex_init(&url
->lock
);
1069 url
->psz_url
= xstrdup(psz_url
);
1070 url
->psz_user
= xstrdup(psz_user
? psz_user
: "");
1071 url
->psz_password
= xstrdup(psz_password
? psz_password
: "");
1072 for (int i
= 0; i
< HTTPD_MSG_MAX
; i
++) {
1073 url
->catch[i
].cb
= NULL
;
1074 url
->catch[i
].p_sys
= NULL
;
1077 TAB_APPEND(host
->i_url
, host
->url
, url
);
1078 vlc_cond_signal(&host
->wait
);
1079 vlc_mutex_unlock(&host
->lock
);
1084 /* register callback on a url */
1085 int httpd_UrlCatch(httpd_url_t
*url
, int i_msg
, httpd_callback_t cb
,
1086 httpd_callback_sys_t
*p_sys
)
1088 vlc_mutex_lock(&url
->lock
);
1089 url
->catch[i_msg
].cb
= cb
;
1090 url
->catch[i_msg
].p_sys
= p_sys
;
1091 vlc_mutex_unlock(&url
->lock
);
1097 void httpd_UrlDelete(httpd_url_t
*url
)
1099 httpd_host_t
*host
= url
->host
;
1101 vlc_mutex_lock(&host
->lock
);
1102 TAB_REMOVE(host
->i_url
, host
->url
, url
);
1104 vlc_mutex_destroy(&url
->lock
);
1106 free(url
->psz_user
);
1107 free(url
->psz_password
);
1109 for (int i
= 0; i
< host
->i_client
; i
++) {
1110 httpd_client_t
*client
= host
->client
[i
];
1112 if (client
->url
!= url
)
1115 /* TODO complete it */
1116 msg_Warn(host
, "force closing connections");
1117 TAB_REMOVE(host
->i_client
, host
->client
, client
);
1118 httpd_ClientDestroy(client
);
1122 vlc_mutex_unlock(&host
->lock
);
1125 static void httpd_MsgInit(httpd_message_t
*msg
)
1128 msg
->i_type
= HTTPD_MSG_NONE
;
1129 msg
->i_proto
= HTTPD_PROTO_NONE
;
1130 msg
->i_version
= -1; /* FIXME */
1134 msg
->psz_url
= NULL
;
1135 msg
->psz_args
= NULL
;
1138 msg
->p_headers
= NULL
;
1140 msg
->i_body_offset
= 0;
1145 static void httpd_MsgClean(httpd_message_t
*msg
)
1148 free(msg
->psz_args
);
1149 for (size_t i
= 0; i
< msg
->i_headers
; i
++) {
1150 free(msg
->p_headers
[i
].name
);
1151 free(msg
->p_headers
[i
].value
);
1153 free(msg
->p_headers
);
1158 const char *httpd_MsgGet(const httpd_message_t
*msg
, const char *name
)
1160 for (size_t i
= 0; i
< msg
->i_headers
; i
++)
1161 if (!strcasecmp(msg
->p_headers
[i
].name
, name
))
1162 return msg
->p_headers
[i
].value
;
1166 void httpd_MsgAdd(httpd_message_t
*msg
, const char *name
, const char *psz_value
, ...)
1168 httpd_header
*p_tmp
= realloc(msg
->p_headers
, sizeof(httpd_header
) * (msg
->i_headers
+ 1));
1172 msg
->p_headers
= p_tmp
;
1174 httpd_header
*h
= &msg
->p_headers
[msg
->i_headers
];
1175 h
->name
= strdup(name
);
1182 va_start(args
, psz_value
);
1183 int ret
= us_vasprintf(&h
->value
, psz_value
, args
);
1194 static void httpd_ClientInit(httpd_client_t
*cl
, mtime_t now
)
1196 cl
->i_state
= HTTPD_CLIENT_RECEIVING
;
1197 cl
->i_activity_date
= now
;
1198 cl
->i_activity_timeout
= INT64_C(10000000);
1199 cl
->i_buffer_size
= HTTPD_CL_BUFSIZE
;
1201 cl
->p_buffer
= xmalloc(cl
->i_buffer_size
);
1202 cl
->i_keyframe_wait_to_pass
= -1;
1203 cl
->b_stream_mode
= false;
1205 httpd_MsgInit(&cl
->query
);
1206 httpd_MsgInit(&cl
->answer
);
1209 char* httpd_ClientIP(const httpd_client_t
*cl
, char *ip
, int *port
)
1211 return net_GetPeerAddress(cl
->fd
, ip
, port
) ? NULL
: ip
;
1214 char* httpd_ServerIP(const httpd_client_t
*cl
, char *ip
, int *port
)
1216 return net_GetSockAddress(cl
->fd
, ip
, port
) ? NULL
: ip
;
1219 static void httpd_ClientDestroy(httpd_client_t
*cl
)
1221 if (cl
->p_tls
!= NULL
)
1222 vlc_tls_Close(cl
->p_tls
);
1226 httpd_MsgClean(&cl
->answer
);
1227 httpd_MsgClean(&cl
->query
);
1233 static httpd_client_t
*httpd_ClientNew(int fd
, vlc_tls_t
*p_tls
, mtime_t now
)
1235 httpd_client_t
*cl
= malloc(sizeof(httpd_client_t
));
1237 if (!cl
) return NULL
;
1244 httpd_ClientInit(cl
, now
);
1246 cl
->i_state
= HTTPD_CLIENT_TLS_HS_OUT
;
1252 ssize_t
httpd_NetRecv (httpd_client_t
*cl
, uint8_t *p
, size_t i_len
)
1259 val
= p_tls
? tls_Recv (p_tls
, p
, i_len
)
1260 : recv (cl
->fd
, p
, i_len
, 0);
1261 while (val
== -1 && errno
== EINTR
);
1266 ssize_t
httpd_NetSend (httpd_client_t
*cl
, const uint8_t *p
, size_t i_len
)
1273 val
= p_tls
? tls_Send(p_tls
, p
, i_len
)
1274 : send (cl
->fd
, p
, i_len
, MSG_NOSIGNAL
);
1275 while (val
== -1 && errno
== EINTR
);
1282 const char name
[16];
1288 { "OPTIONS", HTTPD_MSG_OPTIONS
, HTTPD_PROTO_RTSP
},
1289 { "DESCRIBE", HTTPD_MSG_DESCRIBE
, HTTPD_PROTO_RTSP
},
1290 { "SETUP", HTTPD_MSG_SETUP
, HTTPD_PROTO_RTSP
},
1291 { "PLAY", HTTPD_MSG_PLAY
, HTTPD_PROTO_RTSP
},
1292 { "PAUSE", HTTPD_MSG_PAUSE
, HTTPD_PROTO_RTSP
},
1293 { "GET_PARAMETER", HTTPD_MSG_GETPARAMETER
, HTTPD_PROTO_RTSP
},
1294 { "TEARDOWN", HTTPD_MSG_TEARDOWN
, HTTPD_PROTO_RTSP
},
1295 { "GET", HTTPD_MSG_GET
, HTTPD_PROTO_HTTP
},
1296 { "HEAD", HTTPD_MSG_HEAD
, HTTPD_PROTO_HTTP
},
1297 { "POST", HTTPD_MSG_POST
, HTTPD_PROTO_HTTP
},
1298 { "", HTTPD_MSG_NONE
, HTTPD_PROTO_NONE
}
1302 static void httpd_ClientRecv(httpd_client_t
*cl
)
1306 /* ignore leading whites */
1307 if (cl
->query
.i_proto
== HTTPD_PROTO_NONE
&& cl
->i_buffer
== 0) {
1310 i_len
= httpd_NetRecv(cl
, &c
, 1);
1312 if (i_len
> 0 && !strchr("\r\n\t ", c
)) {
1313 cl
->p_buffer
[0] = c
;
1316 } else if (cl
->query
.i_proto
== HTTPD_PROTO_NONE
) {
1317 /* enough to see if it's Interleaved RTP over RTSP or RTSP/HTTP */
1318 i_len
= httpd_NetRecv(cl
, &cl
->p_buffer
[cl
->i_buffer
],
1321 cl
->i_buffer
+= i_len
;
1323 /* The smallest legal request is 7 bytes ("GET /\r\n"),
1324 * this is the maximum we can ask at this point. */
1325 if (cl
->i_buffer
>= 7) {
1326 if (!memcmp(cl
->p_buffer
, "HTTP/1.", 7)) {
1327 cl
->query
.i_proto
= HTTPD_PROTO_HTTP
;
1328 cl
->query
.i_type
= HTTPD_MSG_ANSWER
;
1329 } else if (!memcmp(cl
->p_buffer
, "RTSP/1.", 7)) {
1330 cl
->query
.i_proto
= HTTPD_PROTO_RTSP
;
1331 cl
->query
.i_type
= HTTPD_MSG_ANSWER
;
1333 /* We need the full request line to determine the protocol. */
1334 cl
->query
.i_proto
= HTTPD_PROTO_HTTP0
;
1335 cl
->query
.i_type
= HTTPD_MSG_NONE
;
1338 } else if (cl
->query
.i_body
> 0) {
1339 /* we are reading the body of a request or a channel */
1340 assert (cl
->query
.p_body
!= NULL
);
1341 i_len
= httpd_NetRecv(cl
, &cl
->query
.p_body
[cl
->i_buffer
],
1342 cl
->query
.i_body
- cl
->i_buffer
);
1344 cl
->i_buffer
+= i_len
;
1346 if (cl
->i_buffer
>= cl
->query
.i_body
)
1347 cl
->i_state
= HTTPD_CLIENT_RECEIVE_DONE
;
1348 } else for (;;) { /* we are reading a header -> char by char */
1349 if (cl
->i_buffer
== cl
->i_buffer_size
) {
1350 uint8_t *newbuf
= realloc(cl
->p_buffer
, cl
->i_buffer_size
+ 1024);
1356 cl
->p_buffer
= newbuf
;
1357 cl
->i_buffer_size
+= 1024;
1360 i_len
= httpd_NetRecv (cl
, &cl
->p_buffer
[cl
->i_buffer
], 1);
1366 if ((cl
->query
.i_proto
== HTTPD_PROTO_HTTP0
)
1367 && (cl
->p_buffer
[cl
->i_buffer
- 1] == '\n'))
1369 /* Request line is now complete */
1370 const char *p
= memchr(cl
->p_buffer
, ' ', cl
->i_buffer
);
1373 assert(cl
->query
.i_type
== HTTPD_MSG_NONE
);
1375 if (!p
) { /* no URI: evil guy */
1376 i_len
= 0; /* drop connection */
1381 p
++; /* skips extra spaces */
1384 p
= memchr(p
, ' ', ((char *)cl
->p_buffer
) + cl
->i_buffer
- p
);
1385 if (!p
) { /* no explicit protocol: HTTP/0.9 */
1386 i_len
= 0; /* not supported currently -> drop */
1391 p
++; /* skips extra spaces ever again */
1394 len
= ((char *)cl
->p_buffer
) + cl
->i_buffer
- p
;
1395 if (len
< 7) /* foreign protocol */
1396 i_len
= 0; /* I don't understand -> drop */
1397 else if (!memcmp(p
, "HTTP/1.", 7)) {
1398 cl
->query
.i_proto
= HTTPD_PROTO_HTTP
;
1399 cl
->query
.i_version
= atoi(p
+ 7);
1400 } else if (!memcmp(p
, "RTSP/1.", 7)) {
1401 cl
->query
.i_proto
= HTTPD_PROTO_RTSP
;
1402 cl
->query
.i_version
= atoi(p
+ 7);
1403 } else if (!memcmp(p
, "HTTP/", 5)) {
1404 const uint8_t sorry
[] =
1405 "HTTP/1.1 505 Unknown HTTP version\r\n\r\n";
1406 httpd_NetSend(cl
, sorry
, sizeof(sorry
) - 1);
1407 i_len
= 0; /* drop */
1408 } else if (!memcmp(p
, "RTSP/", 5)) {
1409 const uint8_t sorry
[] =
1410 "RTSP/1.0 505 Unknown RTSP version\r\n\r\n";
1411 httpd_NetSend(cl
, sorry
, sizeof(sorry
) - 1);
1412 i_len
= 0; /* drop */
1413 } else /* yet another foreign protocol */
1420 if ((cl
->i_buffer
>= 2 && !memcmp(&cl
->p_buffer
[cl
->i_buffer
-2], "\n\n", 2))||
1421 (cl
->i_buffer
>= 4 && !memcmp(&cl
->p_buffer
[cl
->i_buffer
-4], "\r\n\r\n", 4)))
1425 /* we have finished the header so parse it and set i_body */
1426 cl
->p_buffer
[cl
->i_buffer
] = '\0';
1428 if (cl
->query
.i_type
== HTTPD_MSG_ANSWER
) {
1430 * assume strlen("HTTP/1.x") = 8
1432 cl
->query
.i_status
=
1433 strtol((char *)&cl
->p_buffer
[8],
1439 cl
->query
.i_type
= HTTPD_MSG_NONE
;
1441 for (unsigned i
= 0; msg_type
[i
].name
[0]; i
++)
1442 if (!strncmp((char *)cl
->p_buffer
, msg_type
[i
].name
,
1443 strlen(msg_type
[i
].name
))) {
1444 p
= (char *)&cl
->p_buffer
[strlen(msg_type
[i
].name
) + 1 ];
1445 cl
->query
.i_type
= msg_type
[i
].i_type
;
1446 if (cl
->query
.i_proto
!= msg_type
[i
].i_proto
) {
1448 cl
->query
.i_proto
= HTTPD_PROTO_NONE
;
1449 cl
->query
.i_type
= HTTPD_MSG_NONE
;
1455 if (strstr((char *)cl
->p_buffer
, "HTTP/1."))
1456 cl
->query
.i_proto
= HTTPD_PROTO_HTTP
;
1457 else if (strstr((char *)cl
->p_buffer
, "RTSP/1."))
1458 cl
->query
.i_proto
= HTTPD_PROTO_RTSP
;
1466 p2
= strchr(p
, ' ');
1470 if (!strncasecmp(p
, (cl
->query
.i_proto
== HTTPD_PROTO_HTTP
) ? "http:" : "rtsp:", 5)) {
1471 /* Skip hier-part of URL (if present) */
1473 if (!strncmp(p
, "//", 2)) { /* skip authority */
1474 /* see RFC3986 §3.2 */
1476 p
+= strcspn(p
, "/?#");
1479 else if (!strncasecmp(p
, (cl
->query
.i_proto
== HTTPD_PROTO_HTTP
) ? "https:" : "rtsps:", 6)) {
1480 /* Skip hier-part of URL (if present) */
1482 if (!strncmp(p
, "//", 2)) { /* skip authority */
1483 /* see RFC3986 §3.2 */
1485 p
+= strcspn(p
, "/?#");
1489 cl
->query
.psz_url
= strdup(p
);
1490 if ((p3
= strchr(cl
->query
.psz_url
, '?')) ) {
1492 cl
->query
.psz_args
= (uint8_t *)strdup(p3
);
1498 p
= strchr(p
, '\n');
1501 while (*p
== '\n' || *p
== '\r')
1506 char *eol
= p
= strchr(p
, '\n');
1509 while (eol
&& eol
>= line
&& (*eol
== '\n' || *eol
== '\r'))
1512 if ((colon
= strchr(line
, ':'))) {
1514 while (*colon
== ' ')
1516 httpd_MsgAdd(&cl
->query
, line
, "%s", colon
);
1518 if (!strcasecmp(line
, "Content-Length"))
1519 cl
->query
.i_body
= atol(colon
);
1524 while (*p
== '\n' || *p
== '\r')
1529 if (cl
->query
.i_body
> 0) {
1530 /* TODO Mhh, handle the case where the client only
1531 * sends a request and closes the connection to
1532 * mark the end of the body (probably only RTSP) */
1533 if (cl
->query
.i_body
>= 65536)
1534 cl
->query
.p_body
= malloc(cl
->query
.i_body
);
1536 cl
->query
.p_body
= NULL
;
1538 if (!cl
->query
.p_body
) {
1539 switch (cl
->query
.i_proto
) {
1540 case HTTPD_PROTO_HTTP
: {
1541 const uint8_t sorry
[] = "HTTP/1.1 413 Request Entity Too Large\r\n\r\n";
1542 httpd_NetSend(cl
, sorry
, sizeof(sorry
) - 1);
1545 case HTTPD_PROTO_RTSP
: {
1546 const uint8_t sorry
[] = "RTSP/1.0 413 Request Entity Too Large\r\n\r\n";
1547 httpd_NetSend(cl
, sorry
, sizeof(sorry
) - 1);
1551 vlc_assert_unreachable();
1553 i_len
= 0; /* drop */
1557 cl
->i_state
= HTTPD_CLIENT_RECEIVE_DONE
;
1561 /* check if the client is to be set to dead */
1563 if ((i_len
< 0 && WSAGetLastError() != WSAEWOULDBLOCK
) || (i_len
== 0))
1565 if ((i_len
< 0 && errno
!= EAGAIN
) || (i_len
== 0))
1568 if (cl
->query
.i_proto
!= HTTPD_PROTO_NONE
&& cl
->query
.i_type
!= HTTPD_MSG_NONE
) {
1569 /* connection closed -> end of data */
1570 if (cl
->query
.i_body
> 0)
1571 cl
->query
.i_body
= cl
->i_buffer
;
1572 cl
->i_state
= HTTPD_CLIENT_RECEIVE_DONE
;
1575 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1578 /* XXX: for QT I have to disable timeout. Try to find why */
1579 if (cl
->query
.i_proto
== HTTPD_PROTO_RTSP
)
1580 cl
->i_activity_timeout
= 0;
1583 static void httpd_ClientSend(httpd_client_t
*cl
)
1587 if (cl
->i_buffer
< 0) {
1588 /* We need to create the header */
1591 const char *psz_status
= httpd_ReasonFromCode(cl
->answer
.i_status
);
1593 i_size
= strlen("HTTP/1.") + 10 + 10 + strlen(psz_status
) + 5;
1594 for (size_t i
= 0; i
< cl
->answer
.i_headers
; i
++)
1595 i_size
+= strlen(cl
->answer
.p_headers
[i
].name
) + 2 +
1596 strlen(cl
->answer
.p_headers
[i
].value
) + 2;
1598 if (cl
->i_buffer_size
< i_size
) {
1599 cl
->i_buffer_size
= i_size
;
1601 cl
->p_buffer
= xmalloc(i_size
);
1603 p
= (char *)cl
->p_buffer
;
1605 p
+= sprintf(p
, "%s.%u %d %s\r\n",
1606 cl
->answer
.i_proto
== HTTPD_PROTO_HTTP
? "HTTP/1" : "RTSP/1",
1607 cl
->answer
.i_version
,
1608 cl
->answer
.i_status
, psz_status
);
1609 for (size_t i
= 0; i
< cl
->answer
.i_headers
; i
++)
1610 p
+= sprintf(p
, "%s: %s\r\n", cl
->answer
.p_headers
[i
].name
,
1611 cl
->answer
.p_headers
[i
].value
);
1612 p
+= sprintf(p
, "\r\n");
1615 cl
->i_buffer_size
= (uint8_t*)p
- cl
->p_buffer
;
1618 i_len
= httpd_NetSend(cl
, &cl
->p_buffer
[cl
->i_buffer
],
1619 cl
->i_buffer_size
- cl
->i_buffer
);
1621 cl
->i_buffer
+= i_len
;
1623 if (cl
->i_buffer
>= cl
->i_buffer_size
) {
1624 if (cl
->answer
.i_body
== 0 && cl
->answer
.i_body_offset
> 0) {
1625 /* catch more body data */
1626 int i_msg
= cl
->query
.i_type
;
1627 int64_t i_offset
= cl
->answer
.i_body_offset
;
1629 httpd_MsgClean(&cl
->answer
);
1630 cl
->answer
.i_body_offset
= i_offset
;
1632 cl
->url
->catch[i_msg
].cb(cl
->url
->catch[i_msg
].p_sys
, cl
,
1633 &cl
->answer
, &cl
->query
);
1636 if (cl
->answer
.i_body
> 0) {
1637 /* send the body data */
1639 cl
->p_buffer
= cl
->answer
.p_body
;
1640 cl
->i_buffer_size
= cl
->answer
.i_body
;
1643 cl
->answer
.i_body
= 0;
1644 cl
->answer
.p_body
= NULL
;
1645 } else /* send finished */
1646 cl
->i_state
= HTTPD_CLIENT_SEND_DONE
;
1650 if ((i_len
< 0 && WSAGetLastError() != WSAEWOULDBLOCK
) || (i_len
== 0))
1652 if ((i_len
< 0 && errno
!= EAGAIN
) || (i_len
== 0))
1656 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1661 static void httpd_ClientTlsHandshake(httpd_host_t
*host
, httpd_client_t
*cl
)
1663 switch (vlc_tls_SessionHandshake(host
->p_tls
, cl
->p_tls
))
1665 case -1: cl
->i_state
= HTTPD_CLIENT_DEAD
; break;
1666 case 0: cl
->i_state
= HTTPD_CLIENT_RECEIVING
; break;
1667 case 1: cl
->i_state
= HTTPD_CLIENT_TLS_HS_IN
; break;
1668 case 2: cl
->i_state
= HTTPD_CLIENT_TLS_HS_OUT
; break;
1672 static bool httpdAuthOk(const char *user
, const char *pass
, const char *b64
)
1674 if (!*user
&& !*pass
)
1680 if (strncasecmp(b64
, "BASIC", 5))
1687 char *given_user
= vlc_b64_decode(b64
);
1691 char *given_pass
= NULL
;
1692 given_pass
= strchr (given_user
, ':');
1696 *given_pass
++ = '\0';
1698 if (strcmp (given_user
, user
))
1701 if (strcmp (given_pass
, pass
))
1712 static void httpdLoop(httpd_host_t
*host
)
1714 struct pollfd ufd
[host
->nfd
+ host
->i_client
];
1716 for (nfd
= 0; nfd
< host
->nfd
; nfd
++) {
1717 ufd
[nfd
].fd
= host
->fds
[nfd
];
1718 ufd
[nfd
].events
= POLLIN
;
1719 ufd
[nfd
].revents
= 0;
1722 /* add all socket that should be read/write and close dead connection */
1723 while (host
->i_url
<= 0) {
1724 mutex_cleanup_push(&host
->lock
);
1725 vlc_cond_wait(&host
->wait
, &host
->lock
);
1729 mtime_t now
= mdate();
1730 bool b_low_delay
= false;
1732 int canc
= vlc_savecancel();
1733 for (int i_client
= 0; i_client
< host
->i_client
; i_client
++) {
1735 httpd_client_t
*cl
= host
->client
[i_client
];
1736 if (cl
->i_ref
< 0 || (cl
->i_ref
== 0 &&
1737 (cl
->i_state
== HTTPD_CLIENT_DEAD
||
1738 (cl
->i_activity_timeout
> 0 &&
1739 cl
->i_activity_date
+cl
->i_activity_timeout
< now
)))) {
1740 TAB_REMOVE(host
->i_client
, host
->client
, cl
);
1742 httpd_ClientDestroy(cl
);
1746 struct pollfd
*pufd
= ufd
+ nfd
;
1747 assert (pufd
< ufd
+ (sizeof (ufd
) / sizeof (ufd
[0])));
1750 pufd
->events
= pufd
->revents
= 0;
1752 switch (cl
->i_state
) {
1753 case HTTPD_CLIENT_RECEIVING
:
1754 case HTTPD_CLIENT_TLS_HS_IN
:
1755 pufd
->events
= POLLIN
;
1758 case HTTPD_CLIENT_SENDING
:
1759 case HTTPD_CLIENT_TLS_HS_OUT
:
1760 pufd
->events
= POLLOUT
;
1763 case HTTPD_CLIENT_RECEIVE_DONE
: {
1764 httpd_message_t
*answer
= &cl
->answer
;
1765 httpd_message_t
*query
= &cl
->query
;
1767 httpd_MsgInit(answer
);
1769 /* Handle what we received */
1770 switch (query
->i_type
) {
1771 case HTTPD_MSG_ANSWER
:
1773 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1776 case HTTPD_MSG_OPTIONS
:
1777 answer
->i_type
= HTTPD_MSG_ANSWER
;
1778 answer
->i_proto
= query
->i_proto
;
1779 answer
->i_status
= 200;
1781 answer
->p_body
= NULL
;
1783 httpd_MsgAdd(answer
, "Server", "VLC/%s", VERSION
);
1784 httpd_MsgAdd(answer
, "Content-Length", "0");
1786 switch(query
->i_proto
) {
1787 case HTTPD_PROTO_HTTP
:
1788 answer
->i_version
= 1;
1789 httpd_MsgAdd(answer
, "Allow", "GET,HEAD,POST,OPTIONS");
1792 case HTTPD_PROTO_RTSP
:
1793 answer
->i_version
= 0;
1795 const char *p
= httpd_MsgGet(query
, "Cseq");
1797 httpd_MsgAdd(answer
, "Cseq", "%s", p
);
1798 p
= httpd_MsgGet(query
, "Timestamp");
1800 httpd_MsgAdd(answer
, "Timestamp", "%s", p
);
1802 p
= httpd_MsgGet(query
, "Require");
1804 answer
->i_status
= 551;
1805 httpd_MsgAdd(query
, "Unsupported", "%s", p
);
1808 httpd_MsgAdd(answer
, "Public", "DESCRIBE,SETUP,"
1809 "TEARDOWN,PLAY,PAUSE,GET_PARAMETER");
1813 cl
->i_buffer
= -1; /* Force the creation of the answer in
1814 * httpd_ClientSend */
1815 cl
->i_state
= HTTPD_CLIENT_SENDING
;
1818 case HTTPD_MSG_NONE
:
1819 if (query
->i_proto
== HTTPD_PROTO_NONE
) {
1821 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1824 answer
->i_proto
= query
->i_proto
;
1825 answer
->i_type
= HTTPD_MSG_ANSWER
;
1826 answer
->i_version
= 0;
1827 answer
->i_status
= 501;
1830 answer
->i_body
= httpd_HtmlError (&p
, 501, NULL
);
1831 answer
->p_body
= (uint8_t *)p
;
1832 httpd_MsgAdd(answer
, "Content-Length", "%d", answer
->i_body
);
1834 cl
->i_buffer
= -1; /* Force the creation of the answer in httpd_ClientSend */
1835 cl
->i_state
= HTTPD_CLIENT_SENDING
;
1840 int i_msg
= query
->i_type
;
1841 bool b_auth_failed
= false;
1843 /* Search the url and trigger callbacks */
1844 for (int i
= 0; i
< host
->i_url
; i
++) {
1845 httpd_url_t
*url
= host
->url
[i
];
1847 if (strcmp(url
->psz_url
, query
->psz_url
))
1849 if (!url
->catch[i_msg
].cb
)
1853 b_auth_failed
= !httpdAuthOk(url
->psz_user
,
1855 httpd_MsgGet(query
, "Authorization")); /* BASIC id */
1860 if (url
->catch[i_msg
].cb(url
->catch[i_msg
].p_sys
, cl
, answer
, query
))
1863 if (answer
->i_proto
== HTTPD_PROTO_NONE
)
1864 cl
->i_buffer
= cl
->i_buffer_size
; /* Raw answer from a CGI */
1868 /* only one url can answer */
1875 answer
->i_proto
= query
->i_proto
;
1876 answer
->i_type
= HTTPD_MSG_ANSWER
;
1877 answer
->i_version
= 0;
1879 if (b_auth_failed
) {
1880 httpd_MsgAdd(answer
, "WWW-Authenticate",
1881 "Basic realm=\"VLC stream\"");
1882 answer
->i_status
= 401;
1884 answer
->i_status
= 404; /* no url registered */
1887 answer
->i_body
= httpd_HtmlError (&p
, answer
->i_status
,
1889 answer
->p_body
= (uint8_t *)p
;
1891 cl
->i_buffer
= -1; /* Force the creation of the answer in httpd_ClientSend */
1892 httpd_MsgAdd(answer
, "Content-Length", "%d", answer
->i_body
);
1893 httpd_MsgAdd(answer
, "Content-Type", "%s", "text/html");
1896 cl
->i_state
= HTTPD_CLIENT_SENDING
;
1902 case HTTPD_CLIENT_SEND_DONE
:
1903 if (!cl
->b_stream_mode
|| cl
->answer
.i_body_offset
== 0) {
1904 const char *psz_connection
= httpd_MsgGet(&cl
->answer
, "Connection");
1905 const char *psz_query
= httpd_MsgGet(&cl
->query
, "Connection");
1906 bool b_connection
= false;
1907 bool b_keepalive
= false;
1908 bool b_query
= false;
1911 if (psz_connection
) {
1912 b_connection
= (strcasecmp(psz_connection
, "Close") == 0);
1913 b_keepalive
= (strcasecmp(psz_connection
, "Keep-Alive") == 0);
1917 b_query
= (strcasecmp(psz_query
, "Close") == 0);
1919 if (((cl
->query
.i_proto
== HTTPD_PROTO_HTTP
) &&
1920 ((cl
->query
.i_version
== 0 && b_keepalive
) ||
1921 (cl
->query
.i_version
== 1 && !b_connection
))) ||
1922 ((cl
->query
.i_proto
== HTTPD_PROTO_RTSP
) &&
1923 !b_query
&& !b_connection
)) {
1924 httpd_MsgClean(&cl
->query
);
1925 httpd_MsgInit(&cl
->query
);
1928 cl
->i_buffer_size
= 1000;
1930 cl
->p_buffer
= xmalloc(cl
->i_buffer_size
);
1931 cl
->i_state
= HTTPD_CLIENT_RECEIVING
;
1933 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1934 httpd_MsgClean(&cl
->answer
);
1936 i_offset
= cl
->answer
.i_body_offset
;
1937 httpd_MsgClean(&cl
->answer
);
1939 cl
->answer
.i_body_offset
= i_offset
;
1941 cl
->p_buffer
= NULL
;
1943 cl
->i_buffer_size
= 0;
1945 cl
->i_state
= HTTPD_CLIENT_WAITING
;
1949 case HTTPD_CLIENT_WAITING
:
1950 i_offset
= cl
->answer
.i_body_offset
;
1951 int i_msg
= cl
->query
.i_type
;
1953 httpd_MsgInit(&cl
->answer
);
1954 cl
->answer
.i_body_offset
= i_offset
;
1956 cl
->url
->catch[i_msg
].cb(cl
->url
->catch[i_msg
].p_sys
, cl
,
1957 &cl
->answer
, &cl
->query
);
1958 if (cl
->answer
.i_type
!= HTTPD_MSG_NONE
) {
1959 /* we have new data, so re-enter send mode */
1961 cl
->p_buffer
= cl
->answer
.p_body
;
1962 cl
->i_buffer_size
= cl
->answer
.i_body
;
1963 cl
->answer
.p_body
= NULL
;
1964 cl
->answer
.i_body
= 0;
1965 cl
->i_state
= HTTPD_CLIENT_SENDING
;
1969 if (pufd
->events
!= 0)
1974 vlc_mutex_unlock(&host
->lock
);
1975 vlc_restorecancel(canc
);
1977 /* we will wait 20ms (not too big) if HTTPD_CLIENT_WAITING */
1978 int ret
= poll(ufd
, nfd
, b_low_delay
? 20 : -1);
1980 canc
= vlc_savecancel();
1981 vlc_mutex_lock(&host
->lock
);
1984 if (errno
!= EINTR
) {
1985 /* Kernel on low memory or a bug: pace */
1986 msg_Err(host
, "polling error: %s", vlc_strerror_c(errno
));
1990 vlc_restorecancel(canc
);
1994 /* Handle client sockets */
1998 for (int i_client
= 0; i_client
< host
->i_client
; i_client
++) {
1999 httpd_client_t
*cl
= host
->client
[i_client
];
2000 const struct pollfd
*pufd
= &ufd
[nfd
];
2002 assert(pufd
< &ufd
[sizeof(ufd
) / sizeof(ufd
[0])]);
2004 if (cl
->fd
!= pufd
->fd
)
2005 continue; // we were not waiting for this client
2007 if (pufd
->revents
== 0)
2008 continue; // no event received
2010 cl
->i_activity_date
= now
;
2012 switch (cl
->i_state
) {
2013 case HTTPD_CLIENT_RECEIVING
: httpd_ClientRecv(cl
); break;
2014 case HTTPD_CLIENT_SENDING
: httpd_ClientSend(cl
); break;
2015 case HTTPD_CLIENT_TLS_HS_IN
:
2016 case HTTPD_CLIENT_TLS_HS_OUT
:
2017 httpd_ClientTlsHandshake(host
, cl
);
2022 /* Handle server sockets (accept new connections) */
2023 for (nfd
= 0; nfd
< host
->nfd
; nfd
++) {
2025 int fd
= ufd
[nfd
].fd
;
2027 assert (fd
== host
->fds
[nfd
]);
2029 if (ufd
[nfd
].revents
== 0)
2033 fd
= vlc_accept (fd
, NULL
, NULL
, true);
2036 setsockopt (fd
, SOL_SOCKET
, SO_REUSEADDR
,
2037 &(int){ 1 }, sizeof(int));
2041 if (host
->p_tls
!= NULL
)
2043 const char *alpn
[] = { "http/1.1", NULL
};
2045 p_tls
= vlc_tls_ServerSessionCreate(host
->p_tls
, fd
, alpn
);
2050 cl
= httpd_ClientNew(fd
, p_tls
, now
);
2052 TAB_APPEND(host
->i_client
, host
->client
, cl
);
2055 vlc_restorecancel(canc
);
2058 static void* httpd_HostThread(void *data
)
2060 httpd_host_t
*host
= data
;
2062 vlc_mutex_lock(&host
->lock
);
2063 while (host
->i_ref
> 0)
2065 vlc_mutex_unlock(&host
->lock
);
2069 int httpd_StreamSetHTTPHeaders(httpd_stream_t
* p_stream
, httpd_header
* p_headers
, size_t i_headers
)
2072 return VLC_EGENERIC
;
2074 vlc_mutex_lock(&p_stream
->lock
);
2075 if (p_stream
->p_http_headers
) {
2076 for (size_t i
= 0; i
< p_stream
->i_http_headers
; i
++) {
2077 free(p_stream
->p_http_headers
[i
].name
);
2078 free(p_stream
->p_http_headers
[i
].value
);
2080 free(p_stream
->p_http_headers
);
2081 p_stream
->p_http_headers
= NULL
;
2082 p_stream
->i_http_headers
= 0;
2085 if (!p_headers
|| !i_headers
) {
2086 vlc_mutex_unlock(&p_stream
->lock
);
2090 p_stream
->p_http_headers
= malloc(sizeof(httpd_header
) * i_headers
);
2091 if (!p_stream
->p_http_headers
) {
2092 vlc_mutex_unlock(&p_stream
->lock
);
2097 for (size_t i
= 0; i
< i_headers
; i
++) {
2098 if (unlikely(!p_headers
[i
].name
|| !p_headers
[i
].value
))
2101 p_stream
->p_http_headers
[j
].name
= strdup(p_headers
[i
].name
);
2102 p_stream
->p_http_headers
[j
].value
= strdup(p_headers
[i
].value
);
2104 if (unlikely(!p_stream
->p_http_headers
[j
].name
||
2105 !p_stream
->p_http_headers
[j
].value
)) {
2106 free(p_stream
->p_http_headers
[j
].name
);
2107 free(p_stream
->p_http_headers
[j
].value
);
2112 p_stream
->i_http_headers
= j
;
2113 vlc_mutex_unlock(&p_stream
->lock
);