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"
57 # include <winsock2.h>
59 # include <sys/socket.h>
63 /* We need HUGE buffer otherwise TCP throughput is very limited */
64 #define HTTPD_CL_BUFSIZE 1000000
66 #define HTTPD_CL_BUFSIZE 10000
69 static void httpd_ClientDestroy(httpd_client_t
*cl
);
70 static void httpd_AppendData(httpd_stream_t
*stream
, uint8_t *p_data
, int i_data
);
72 /* each host run in his own thread */
80 /* address/port and socket for listening at connections */
89 /* all registered url (becarefull that 2 httpd_url_t could point at the same url)
90 * This will slow down the url research but make my live easier
91 * All url will have their cb trigger, but only the first one can answer
97 httpd_client_t
**client
;
100 vlc_tls_creds_t
*p_tls
;
117 httpd_callback_sys_t
*p_sys
;
118 } catch[HTTPD_MSG_MAX
];
124 HTTPD_CLIENT_RECEIVING
,
125 HTTPD_CLIENT_RECEIVE_DONE
,
127 HTTPD_CLIENT_SENDING
,
128 HTTPD_CLIENT_SEND_DONE
,
130 HTTPD_CLIENT_WAITING
,
134 HTTPD_CLIENT_TLS_HS_IN
,
135 HTTPD_CLIENT_TLS_HS_OUT
141 HTTPD_CLIENT_FILE
, /* default */
142 HTTPD_CLIENT_STREAM
, /* regulary get data from cb */
145 struct httpd_client_t
155 mtime_t i_activity_date
;
156 mtime_t i_activity_timeout
;
158 /* buffer for reading header */
164 * If waiting for a keyframe, this is the position (in bytes) of the
165 * last keyframe the stream saw before this client connected.
168 int64_t i_keyframe_wait_to_pass
;
171 httpd_message_t query
; /* client -> httpd */
172 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
;
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
,
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 void *httpd_HandlerDelete(httpd_handler_t
*handler
)
516 void *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(vlc_tls_GetFD(cl
->sock
), ip
, port
) ? NULL
: ip
;
1214 char* httpd_ServerIP(const httpd_client_t
*cl
, char *ip
, int *port
)
1216 return net_GetSockAddress(vlc_tls_GetFD(cl
->sock
), ip
, port
) ? NULL
: ip
;
1219 static void httpd_ClientDestroy(httpd_client_t
*cl
)
1221 vlc_tls_Close(cl
->sock
);
1222 httpd_MsgClean(&cl
->answer
);
1223 httpd_MsgClean(&cl
->query
);
1229 static httpd_client_t
*httpd_ClientNew(vlc_tls_t
*sock
, mtime_t now
)
1231 httpd_client_t
*cl
= malloc(sizeof(httpd_client_t
));
1233 if (!cl
) return NULL
;
1239 httpd_ClientInit(cl
, now
);
1244 ssize_t
httpd_NetRecv (httpd_client_t
*cl
, uint8_t *p
, size_t i_len
)
1246 vlc_tls_t
*sock
= cl
->sock
;
1247 struct iovec iov
= { .iov_base
= p
, .iov_len
= i_len
};
1248 return sock
->readv(sock
, &iov
, 1);
1252 ssize_t
httpd_NetSend (httpd_client_t
*cl
, const uint8_t *p
, size_t i_len
)
1254 vlc_tls_t
*sock
= cl
->sock
;
1255 const struct iovec iov
= { .iov_base
= (void *)p
, .iov_len
= i_len
};
1256 return sock
->writev(sock
, &iov
, 1);
1262 const char name
[16];
1268 { "OPTIONS", HTTPD_MSG_OPTIONS
, HTTPD_PROTO_RTSP
},
1269 { "DESCRIBE", HTTPD_MSG_DESCRIBE
, HTTPD_PROTO_RTSP
},
1270 { "SETUP", HTTPD_MSG_SETUP
, HTTPD_PROTO_RTSP
},
1271 { "PLAY", HTTPD_MSG_PLAY
, HTTPD_PROTO_RTSP
},
1272 { "PAUSE", HTTPD_MSG_PAUSE
, HTTPD_PROTO_RTSP
},
1273 { "GET_PARAMETER", HTTPD_MSG_GETPARAMETER
, HTTPD_PROTO_RTSP
},
1274 { "TEARDOWN", HTTPD_MSG_TEARDOWN
, HTTPD_PROTO_RTSP
},
1275 { "GET", HTTPD_MSG_GET
, HTTPD_PROTO_HTTP
},
1276 { "HEAD", HTTPD_MSG_HEAD
, HTTPD_PROTO_HTTP
},
1277 { "POST", HTTPD_MSG_POST
, HTTPD_PROTO_HTTP
},
1278 { "", HTTPD_MSG_NONE
, HTTPD_PROTO_NONE
}
1282 static void httpd_ClientRecv(httpd_client_t
*cl
)
1286 /* ignore leading whites */
1287 if (cl
->query
.i_proto
== HTTPD_PROTO_NONE
&& cl
->i_buffer
== 0) {
1290 i_len
= httpd_NetRecv(cl
, &c
, 1);
1292 if (i_len
> 0 && !strchr("\r\n\t ", c
)) {
1293 cl
->p_buffer
[0] = c
;
1296 } else if (cl
->query
.i_proto
== HTTPD_PROTO_NONE
) {
1297 /* enough to see if it's Interleaved RTP over RTSP or RTSP/HTTP */
1298 i_len
= httpd_NetRecv(cl
, &cl
->p_buffer
[cl
->i_buffer
],
1301 cl
->i_buffer
+= i_len
;
1303 /* The smallest legal request is 7 bytes ("GET /\r\n"),
1304 * this is the maximum we can ask at this point. */
1305 if (cl
->i_buffer
>= 7) {
1306 if (!memcmp(cl
->p_buffer
, "HTTP/1.", 7)) {
1307 cl
->query
.i_proto
= HTTPD_PROTO_HTTP
;
1308 cl
->query
.i_type
= HTTPD_MSG_ANSWER
;
1309 } else if (!memcmp(cl
->p_buffer
, "RTSP/1.", 7)) {
1310 cl
->query
.i_proto
= HTTPD_PROTO_RTSP
;
1311 cl
->query
.i_type
= HTTPD_MSG_ANSWER
;
1313 /* We need the full request line to determine the protocol. */
1314 cl
->query
.i_proto
= HTTPD_PROTO_HTTP0
;
1315 cl
->query
.i_type
= HTTPD_MSG_NONE
;
1318 } else if (cl
->query
.i_body
> 0) {
1319 /* we are reading the body of a request or a channel */
1320 assert (cl
->query
.p_body
!= NULL
);
1321 i_len
= httpd_NetRecv(cl
, &cl
->query
.p_body
[cl
->i_buffer
],
1322 cl
->query
.i_body
- cl
->i_buffer
);
1324 cl
->i_buffer
+= i_len
;
1326 if (cl
->i_buffer
>= cl
->query
.i_body
)
1327 cl
->i_state
= HTTPD_CLIENT_RECEIVE_DONE
;
1328 } else for (;;) { /* we are reading a header -> char by char */
1329 if (cl
->i_buffer
== cl
->i_buffer_size
) {
1330 uint8_t *newbuf
= realloc(cl
->p_buffer
, cl
->i_buffer_size
+ 1024);
1336 cl
->p_buffer
= newbuf
;
1337 cl
->i_buffer_size
+= 1024;
1340 i_len
= httpd_NetRecv (cl
, &cl
->p_buffer
[cl
->i_buffer
], 1);
1346 if ((cl
->query
.i_proto
== HTTPD_PROTO_HTTP0
)
1347 && (cl
->p_buffer
[cl
->i_buffer
- 1] == '\n'))
1349 /* Request line is now complete */
1350 const char *p
= memchr(cl
->p_buffer
, ' ', cl
->i_buffer
);
1353 assert(cl
->query
.i_type
== HTTPD_MSG_NONE
);
1355 if (!p
) { /* no URI: evil guy */
1356 i_len
= 0; /* drop connection */
1361 p
++; /* skips extra spaces */
1364 p
= memchr(p
, ' ', ((char *)cl
->p_buffer
) + cl
->i_buffer
- p
);
1365 if (!p
) { /* no explicit protocol: HTTP/0.9 */
1366 i_len
= 0; /* not supported currently -> drop */
1371 p
++; /* skips extra spaces ever again */
1374 len
= ((char *)cl
->p_buffer
) + cl
->i_buffer
- p
;
1375 if (len
< 7) /* foreign protocol */
1376 i_len
= 0; /* I don't understand -> drop */
1377 else if (!memcmp(p
, "HTTP/1.", 7)) {
1378 cl
->query
.i_proto
= HTTPD_PROTO_HTTP
;
1379 cl
->query
.i_version
= atoi(p
+ 7);
1380 } else if (!memcmp(p
, "RTSP/1.", 7)) {
1381 cl
->query
.i_proto
= HTTPD_PROTO_RTSP
;
1382 cl
->query
.i_version
= atoi(p
+ 7);
1383 } else if (!memcmp(p
, "HTTP/", 5)) {
1384 const uint8_t sorry
[] =
1385 "HTTP/1.1 505 Unknown HTTP version\r\n\r\n";
1386 httpd_NetSend(cl
, sorry
, sizeof(sorry
) - 1);
1387 i_len
= 0; /* drop */
1388 } else if (!memcmp(p
, "RTSP/", 5)) {
1389 const uint8_t sorry
[] =
1390 "RTSP/1.0 505 Unknown RTSP version\r\n\r\n";
1391 httpd_NetSend(cl
, sorry
, sizeof(sorry
) - 1);
1392 i_len
= 0; /* drop */
1393 } else /* yet another foreign protocol */
1400 if ((cl
->i_buffer
>= 2 && !memcmp(&cl
->p_buffer
[cl
->i_buffer
-2], "\n\n", 2))||
1401 (cl
->i_buffer
>= 4 && !memcmp(&cl
->p_buffer
[cl
->i_buffer
-4], "\r\n\r\n", 4)))
1405 /* we have finished the header so parse it and set i_body */
1406 cl
->p_buffer
[cl
->i_buffer
] = '\0';
1408 if (cl
->query
.i_type
== HTTPD_MSG_ANSWER
) {
1410 * assume strlen("HTTP/1.x") = 8
1412 cl
->query
.i_status
=
1413 strtol((char *)&cl
->p_buffer
[8],
1419 cl
->query
.i_type
= HTTPD_MSG_NONE
;
1421 for (unsigned i
= 0; msg_type
[i
].name
[0]; i
++)
1422 if (!strncmp((char *)cl
->p_buffer
, msg_type
[i
].name
,
1423 strlen(msg_type
[i
].name
))) {
1424 p
= (char *)&cl
->p_buffer
[strlen(msg_type
[i
].name
) + 1 ];
1425 cl
->query
.i_type
= msg_type
[i
].i_type
;
1426 if (cl
->query
.i_proto
!= msg_type
[i
].i_proto
) {
1428 cl
->query
.i_proto
= HTTPD_PROTO_NONE
;
1429 cl
->query
.i_type
= HTTPD_MSG_NONE
;
1435 if (strstr((char *)cl
->p_buffer
, "HTTP/1."))
1436 cl
->query
.i_proto
= HTTPD_PROTO_HTTP
;
1437 else if (strstr((char *)cl
->p_buffer
, "RTSP/1."))
1438 cl
->query
.i_proto
= HTTPD_PROTO_RTSP
;
1446 p2
= strchr(p
, ' ');
1450 if (!strncasecmp(p
, (cl
->query
.i_proto
== HTTPD_PROTO_HTTP
) ? "http:" : "rtsp:", 5)) {
1451 /* Skip hier-part of URL (if present) */
1453 if (!strncmp(p
, "//", 2)) { /* skip authority */
1454 /* see RFC3986 §3.2 */
1456 p
+= strcspn(p
, "/?#");
1459 else if (!strncasecmp(p
, (cl
->query
.i_proto
== HTTPD_PROTO_HTTP
) ? "https:" : "rtsps:", 6)) {
1460 /* Skip hier-part of URL (if present) */
1462 if (!strncmp(p
, "//", 2)) { /* skip authority */
1463 /* see RFC3986 §3.2 */
1465 p
+= strcspn(p
, "/?#");
1469 cl
->query
.psz_url
= strdup(p
);
1470 if ((p3
= strchr(cl
->query
.psz_url
, '?')) ) {
1472 cl
->query
.psz_args
= (uint8_t *)strdup(p3
);
1478 p
= strchr(p
, '\n');
1481 while (*p
== '\n' || *p
== '\r')
1486 char *eol
= p
= strchr(p
, '\n');
1489 while (eol
&& eol
>= line
&& (*eol
== '\n' || *eol
== '\r'))
1492 if ((colon
= strchr(line
, ':'))) {
1494 while (*colon
== ' ')
1496 httpd_MsgAdd(&cl
->query
, line
, "%s", colon
);
1498 if (!strcasecmp(line
, "Content-Length"))
1499 cl
->query
.i_body
= atol(colon
);
1504 while (*p
== '\n' || *p
== '\r')
1509 if (cl
->query
.i_body
> 0) {
1510 /* TODO Mhh, handle the case where the client only
1511 * sends a request and closes the connection to
1512 * mark the end of the body (probably only RTSP) */
1513 if (cl
->query
.i_body
>= 65536)
1514 cl
->query
.p_body
= malloc(cl
->query
.i_body
);
1516 cl
->query
.p_body
= NULL
;
1518 if (!cl
->query
.p_body
) {
1519 switch (cl
->query
.i_proto
) {
1520 case HTTPD_PROTO_HTTP
: {
1521 const uint8_t sorry
[] = "HTTP/1.1 413 Request Entity Too Large\r\n\r\n";
1522 httpd_NetSend(cl
, sorry
, sizeof(sorry
) - 1);
1525 case HTTPD_PROTO_RTSP
: {
1526 const uint8_t sorry
[] = "RTSP/1.0 413 Request Entity Too Large\r\n\r\n";
1527 httpd_NetSend(cl
, sorry
, sizeof(sorry
) - 1);
1531 vlc_assert_unreachable();
1533 i_len
= 0; /* drop */
1537 cl
->i_state
= HTTPD_CLIENT_RECEIVE_DONE
;
1541 /* check if the client is to be set to dead */
1543 if ((i_len
< 0 && WSAGetLastError() != WSAEWOULDBLOCK
) || (i_len
== 0))
1545 if ((i_len
< 0 && errno
!= EAGAIN
) || (i_len
== 0))
1548 if (cl
->query
.i_proto
!= HTTPD_PROTO_NONE
&& cl
->query
.i_type
!= HTTPD_MSG_NONE
) {
1549 /* connection closed -> end of data */
1550 if (cl
->query
.i_body
> 0)
1551 cl
->query
.i_body
= cl
->i_buffer
;
1552 cl
->i_state
= HTTPD_CLIENT_RECEIVE_DONE
;
1555 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1558 /* XXX: for QT I have to disable timeout. Try to find why */
1559 if (cl
->query
.i_proto
== HTTPD_PROTO_RTSP
)
1560 cl
->i_activity_timeout
= 0;
1563 static void httpd_ClientSend(httpd_client_t
*cl
)
1567 if (cl
->i_buffer
< 0) {
1568 /* We need to create the header */
1571 const char *psz_status
= httpd_ReasonFromCode(cl
->answer
.i_status
);
1573 i_size
= strlen("HTTP/1.") + 10 + 10 + strlen(psz_status
) + 5;
1574 for (size_t i
= 0; i
< cl
->answer
.i_headers
; i
++)
1575 i_size
+= strlen(cl
->answer
.p_headers
[i
].name
) + 2 +
1576 strlen(cl
->answer
.p_headers
[i
].value
) + 2;
1578 if (cl
->i_buffer_size
< i_size
) {
1579 cl
->i_buffer_size
= i_size
;
1581 cl
->p_buffer
= xmalloc(i_size
);
1583 p
= (char *)cl
->p_buffer
;
1585 p
+= sprintf(p
, "%s.%u %d %s\r\n",
1586 cl
->answer
.i_proto
== HTTPD_PROTO_HTTP
? "HTTP/1" : "RTSP/1",
1587 cl
->answer
.i_version
,
1588 cl
->answer
.i_status
, psz_status
);
1589 for (size_t i
= 0; i
< cl
->answer
.i_headers
; i
++)
1590 p
+= sprintf(p
, "%s: %s\r\n", cl
->answer
.p_headers
[i
].name
,
1591 cl
->answer
.p_headers
[i
].value
);
1592 p
+= sprintf(p
, "\r\n");
1595 cl
->i_buffer_size
= (uint8_t*)p
- cl
->p_buffer
;
1598 i_len
= httpd_NetSend(cl
, &cl
->p_buffer
[cl
->i_buffer
],
1599 cl
->i_buffer_size
- cl
->i_buffer
);
1601 cl
->i_buffer
+= i_len
;
1603 if (cl
->i_buffer
>= cl
->i_buffer_size
) {
1604 if (cl
->answer
.i_body
== 0 && cl
->answer
.i_body_offset
> 0) {
1605 /* catch more body data */
1606 int i_msg
= cl
->query
.i_type
;
1607 int64_t i_offset
= cl
->answer
.i_body_offset
;
1609 httpd_MsgClean(&cl
->answer
);
1610 cl
->answer
.i_body_offset
= i_offset
;
1612 cl
->url
->catch[i_msg
].cb(cl
->url
->catch[i_msg
].p_sys
, cl
,
1613 &cl
->answer
, &cl
->query
);
1616 if (cl
->answer
.i_body
> 0) {
1617 /* send the body data */
1619 cl
->p_buffer
= cl
->answer
.p_body
;
1620 cl
->i_buffer_size
= cl
->answer
.i_body
;
1623 cl
->answer
.i_body
= 0;
1624 cl
->answer
.p_body
= NULL
;
1625 } else /* send finished */
1626 cl
->i_state
= HTTPD_CLIENT_SEND_DONE
;
1630 if ((i_len
< 0 && WSAGetLastError() != WSAEWOULDBLOCK
) || (i_len
== 0))
1632 if ((i_len
< 0 && errno
!= EAGAIN
) || (i_len
== 0))
1636 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1641 static void httpd_ClientTlsHandshake(httpd_host_t
*host
, httpd_client_t
*cl
)
1643 switch (vlc_tls_SessionHandshake(host
->p_tls
, cl
->sock
))
1645 case -1: cl
->i_state
= HTTPD_CLIENT_DEAD
; break;
1646 case 0: cl
->i_state
= HTTPD_CLIENT_RECEIVING
; break;
1647 case 1: cl
->i_state
= HTTPD_CLIENT_TLS_HS_IN
; break;
1648 case 2: cl
->i_state
= HTTPD_CLIENT_TLS_HS_OUT
; break;
1652 static bool httpdAuthOk(const char *user
, const char *pass
, const char *b64
)
1654 if (!*user
&& !*pass
)
1660 if (strncasecmp(b64
, "BASIC", 5))
1667 char *given_user
= vlc_b64_decode(b64
);
1671 char *given_pass
= NULL
;
1672 given_pass
= strchr (given_user
, ':');
1676 *given_pass
++ = '\0';
1678 if (strcmp (given_user
, user
))
1681 if (strcmp (given_pass
, pass
))
1692 static void httpdLoop(httpd_host_t
*host
)
1694 struct pollfd ufd
[host
->nfd
+ host
->i_client
];
1696 for (nfd
= 0; nfd
< host
->nfd
; nfd
++) {
1697 ufd
[nfd
].fd
= host
->fds
[nfd
];
1698 ufd
[nfd
].events
= POLLIN
;
1699 ufd
[nfd
].revents
= 0;
1702 /* add all socket that should be read/write and close dead connection */
1703 while (host
->i_url
<= 0) {
1704 mutex_cleanup_push(&host
->lock
);
1705 vlc_cond_wait(&host
->wait
, &host
->lock
);
1709 mtime_t now
= mdate();
1710 bool b_low_delay
= false;
1712 int canc
= vlc_savecancel();
1713 for (int i_client
= 0; i_client
< host
->i_client
; i_client
++) {
1715 httpd_client_t
*cl
= host
->client
[i_client
];
1716 if (cl
->i_ref
< 0 || (cl
->i_ref
== 0 &&
1717 (cl
->i_state
== HTTPD_CLIENT_DEAD
||
1718 (cl
->i_activity_timeout
> 0 &&
1719 cl
->i_activity_date
+cl
->i_activity_timeout
< now
)))) {
1720 TAB_REMOVE(host
->i_client
, host
->client
, cl
);
1722 httpd_ClientDestroy(cl
);
1726 struct pollfd
*pufd
= ufd
+ nfd
;
1727 assert (pufd
< ufd
+ (sizeof (ufd
) / sizeof (ufd
[0])));
1729 pufd
->fd
= vlc_tls_GetFD(cl
->sock
);
1730 pufd
->events
= pufd
->revents
= 0;
1732 switch (cl
->i_state
) {
1733 case HTTPD_CLIENT_RECEIVING
:
1734 case HTTPD_CLIENT_TLS_HS_IN
:
1735 pufd
->events
= POLLIN
;
1738 case HTTPD_CLIENT_SENDING
:
1739 case HTTPD_CLIENT_TLS_HS_OUT
:
1740 pufd
->events
= POLLOUT
;
1743 case HTTPD_CLIENT_RECEIVE_DONE
: {
1744 httpd_message_t
*answer
= &cl
->answer
;
1745 httpd_message_t
*query
= &cl
->query
;
1747 httpd_MsgInit(answer
);
1749 /* Handle what we received */
1750 switch (query
->i_type
) {
1751 case HTTPD_MSG_ANSWER
:
1753 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1756 case HTTPD_MSG_OPTIONS
:
1757 answer
->i_type
= HTTPD_MSG_ANSWER
;
1758 answer
->i_proto
= query
->i_proto
;
1759 answer
->i_status
= 200;
1761 answer
->p_body
= NULL
;
1763 httpd_MsgAdd(answer
, "Server", "VLC/%s", VERSION
);
1764 httpd_MsgAdd(answer
, "Content-Length", "0");
1766 switch(query
->i_proto
) {
1767 case HTTPD_PROTO_HTTP
:
1768 answer
->i_version
= 1;
1769 httpd_MsgAdd(answer
, "Allow", "GET,HEAD,POST,OPTIONS");
1772 case HTTPD_PROTO_RTSP
:
1773 answer
->i_version
= 0;
1775 const char *p
= httpd_MsgGet(query
, "Cseq");
1777 httpd_MsgAdd(answer
, "Cseq", "%s", p
);
1778 p
= httpd_MsgGet(query
, "Timestamp");
1780 httpd_MsgAdd(answer
, "Timestamp", "%s", p
);
1782 p
= httpd_MsgGet(query
, "Require");
1784 answer
->i_status
= 551;
1785 httpd_MsgAdd(query
, "Unsupported", "%s", p
);
1788 httpd_MsgAdd(answer
, "Public", "DESCRIBE,SETUP,"
1789 "TEARDOWN,PLAY,PAUSE,GET_PARAMETER");
1793 cl
->i_buffer
= -1; /* Force the creation of the answer in
1794 * httpd_ClientSend */
1795 cl
->i_state
= HTTPD_CLIENT_SENDING
;
1798 case HTTPD_MSG_NONE
:
1799 if (query
->i_proto
== HTTPD_PROTO_NONE
) {
1801 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1804 answer
->i_proto
= query
->i_proto
;
1805 answer
->i_type
= HTTPD_MSG_ANSWER
;
1806 answer
->i_version
= 0;
1807 answer
->i_status
= 501;
1810 answer
->i_body
= httpd_HtmlError (&p
, 501, NULL
);
1811 answer
->p_body
= (uint8_t *)p
;
1812 httpd_MsgAdd(answer
, "Content-Length", "%d", answer
->i_body
);
1814 cl
->i_buffer
= -1; /* Force the creation of the answer in httpd_ClientSend */
1815 cl
->i_state
= HTTPD_CLIENT_SENDING
;
1820 int i_msg
= query
->i_type
;
1821 bool b_auth_failed
= false;
1823 /* Search the url and trigger callbacks */
1824 for (int i
= 0; i
< host
->i_url
; i
++) {
1825 httpd_url_t
*url
= host
->url
[i
];
1827 if (strcmp(url
->psz_url
, query
->psz_url
))
1829 if (!url
->catch[i_msg
].cb
)
1833 b_auth_failed
= !httpdAuthOk(url
->psz_user
,
1835 httpd_MsgGet(query
, "Authorization")); /* BASIC id */
1840 if (url
->catch[i_msg
].cb(url
->catch[i_msg
].p_sys
, cl
, answer
, query
))
1843 if (answer
->i_proto
== HTTPD_PROTO_NONE
)
1844 cl
->i_buffer
= cl
->i_buffer_size
; /* Raw answer from a CGI */
1848 /* only one url can answer */
1855 answer
->i_proto
= query
->i_proto
;
1856 answer
->i_type
= HTTPD_MSG_ANSWER
;
1857 answer
->i_version
= 0;
1859 if (b_auth_failed
) {
1860 httpd_MsgAdd(answer
, "WWW-Authenticate",
1861 "Basic realm=\"VLC stream\"");
1862 answer
->i_status
= 401;
1864 answer
->i_status
= 404; /* no url registered */
1867 answer
->i_body
= httpd_HtmlError (&p
, answer
->i_status
,
1869 answer
->p_body
= (uint8_t *)p
;
1871 cl
->i_buffer
= -1; /* Force the creation of the answer in httpd_ClientSend */
1872 httpd_MsgAdd(answer
, "Content-Length", "%d", answer
->i_body
);
1873 httpd_MsgAdd(answer
, "Content-Type", "%s", "text/html");
1876 cl
->i_state
= HTTPD_CLIENT_SENDING
;
1882 case HTTPD_CLIENT_SEND_DONE
:
1883 if (!cl
->b_stream_mode
|| cl
->answer
.i_body_offset
== 0) {
1884 const char *psz_connection
= httpd_MsgGet(&cl
->answer
, "Connection");
1885 const char *psz_query
= httpd_MsgGet(&cl
->query
, "Connection");
1886 bool b_connection
= false;
1887 bool b_keepalive
= false;
1888 bool b_query
= false;
1891 if (psz_connection
) {
1892 b_connection
= (strcasecmp(psz_connection
, "Close") == 0);
1893 b_keepalive
= (strcasecmp(psz_connection
, "Keep-Alive") == 0);
1897 b_query
= (strcasecmp(psz_query
, "Close") == 0);
1899 if (((cl
->query
.i_proto
== HTTPD_PROTO_HTTP
) &&
1900 ((cl
->query
.i_version
== 0 && b_keepalive
) ||
1901 (cl
->query
.i_version
== 1 && !b_connection
))) ||
1902 ((cl
->query
.i_proto
== HTTPD_PROTO_RTSP
) &&
1903 !b_query
&& !b_connection
)) {
1904 httpd_MsgClean(&cl
->query
);
1905 httpd_MsgInit(&cl
->query
);
1908 cl
->i_buffer_size
= 1000;
1910 cl
->p_buffer
= xmalloc(cl
->i_buffer_size
);
1911 cl
->i_state
= HTTPD_CLIENT_RECEIVING
;
1913 cl
->i_state
= HTTPD_CLIENT_DEAD
;
1914 httpd_MsgClean(&cl
->answer
);
1916 i_offset
= cl
->answer
.i_body_offset
;
1917 httpd_MsgClean(&cl
->answer
);
1919 cl
->answer
.i_body_offset
= i_offset
;
1921 cl
->p_buffer
= NULL
;
1923 cl
->i_buffer_size
= 0;
1925 cl
->i_state
= HTTPD_CLIENT_WAITING
;
1929 case HTTPD_CLIENT_WAITING
:
1930 i_offset
= cl
->answer
.i_body_offset
;
1931 int i_msg
= cl
->query
.i_type
;
1933 httpd_MsgInit(&cl
->answer
);
1934 cl
->answer
.i_body_offset
= i_offset
;
1936 cl
->url
->catch[i_msg
].cb(cl
->url
->catch[i_msg
].p_sys
, cl
,
1937 &cl
->answer
, &cl
->query
);
1938 if (cl
->answer
.i_type
!= HTTPD_MSG_NONE
) {
1939 /* we have new data, so re-enter send mode */
1941 cl
->p_buffer
= cl
->answer
.p_body
;
1942 cl
->i_buffer_size
= cl
->answer
.i_body
;
1943 cl
->answer
.p_body
= NULL
;
1944 cl
->answer
.i_body
= 0;
1945 cl
->i_state
= HTTPD_CLIENT_SENDING
;
1949 if (pufd
->events
!= 0)
1954 vlc_mutex_unlock(&host
->lock
);
1955 vlc_restorecancel(canc
);
1957 /* we will wait 20ms (not too big) if HTTPD_CLIENT_WAITING */
1958 int ret
= poll(ufd
, nfd
, b_low_delay
? 20 : -1);
1960 canc
= vlc_savecancel();
1961 vlc_mutex_lock(&host
->lock
);
1964 if (errno
!= EINTR
) {
1965 /* Kernel on low memory or a bug: pace */
1966 msg_Err(host
, "polling error: %s", vlc_strerror_c(errno
));
1970 vlc_restorecancel(canc
);
1974 /* Handle client sockets */
1978 for (int i_client
= 0; i_client
< host
->i_client
; i_client
++) {
1979 httpd_client_t
*cl
= host
->client
[i_client
];
1980 const struct pollfd
*pufd
= &ufd
[nfd
];
1982 assert(pufd
< &ufd
[sizeof(ufd
) / sizeof(ufd
[0])]);
1984 if (vlc_tls_GetFD(cl
->sock
) != pufd
->fd
)
1985 continue; // we were not waiting for this client
1987 if (pufd
->revents
== 0)
1988 continue; // no event received
1990 cl
->i_activity_date
= now
;
1992 switch (cl
->i_state
) {
1993 case HTTPD_CLIENT_RECEIVING
: httpd_ClientRecv(cl
); break;
1994 case HTTPD_CLIENT_SENDING
: httpd_ClientSend(cl
); break;
1995 case HTTPD_CLIENT_TLS_HS_IN
:
1996 case HTTPD_CLIENT_TLS_HS_OUT
:
1997 httpd_ClientTlsHandshake(host
, cl
);
2002 /* Handle server sockets (accept new connections) */
2003 for (nfd
= 0; nfd
< host
->nfd
; nfd
++) {
2005 int fd
= ufd
[nfd
].fd
;
2007 assert (fd
== host
->fds
[nfd
]);
2009 if (ufd
[nfd
].revents
== 0)
2013 fd
= vlc_accept (fd
, NULL
, NULL
, true);
2016 setsockopt (fd
, SOL_SOCKET
, SO_REUSEADDR
,
2017 &(int){ 1 }, sizeof(int));
2019 vlc_tls_t
*sk
= vlc_tls_SocketOpen(fd
);
2020 if (unlikely(sk
== NULL
))
2026 if (host
->p_tls
!= NULL
)
2028 const char *alpn
[] = { "http/1.1", NULL
};
2031 tls
= vlc_tls_ServerSessionCreate(host
->p_tls
, sk
, alpn
);
2034 vlc_tls_SessionDelete(sk
);
2040 cl
= httpd_ClientNew(sk
, now
);
2042 if (host
->p_tls
!= NULL
)
2043 cl
->i_state
= HTTPD_CLIENT_TLS_HS_OUT
;
2045 TAB_APPEND(host
->i_client
, host
->client
, cl
);
2048 vlc_restorecancel(canc
);
2051 static void* httpd_HostThread(void *data
)
2053 httpd_host_t
*host
= data
;
2055 vlc_mutex_lock(&host
->lock
);
2056 while (host
->i_ref
> 0)
2058 vlc_mutex_unlock(&host
->lock
);
2062 int httpd_StreamSetHTTPHeaders(httpd_stream_t
* p_stream
, httpd_header
* p_headers
, size_t i_headers
)
2065 return VLC_EGENERIC
;
2067 vlc_mutex_lock(&p_stream
->lock
);
2068 if (p_stream
->p_http_headers
) {
2069 for (size_t i
= 0; i
< p_stream
->i_http_headers
; i
++) {
2070 free(p_stream
->p_http_headers
[i
].name
);
2071 free(p_stream
->p_http_headers
[i
].value
);
2073 free(p_stream
->p_http_headers
);
2074 p_stream
->p_http_headers
= NULL
;
2075 p_stream
->i_http_headers
= 0;
2078 if (!p_headers
|| !i_headers
) {
2079 vlc_mutex_unlock(&p_stream
->lock
);
2083 p_stream
->p_http_headers
= malloc(sizeof(httpd_header
) * i_headers
);
2084 if (!p_stream
->p_http_headers
) {
2085 vlc_mutex_unlock(&p_stream
->lock
);
2090 for (size_t i
= 0; i
< i_headers
; i
++) {
2091 if (unlikely(!p_headers
[i
].name
|| !p_headers
[i
].value
))
2094 p_stream
->p_http_headers
[j
].name
= strdup(p_headers
[i
].name
);
2095 p_stream
->p_http_headers
[j
].value
= strdup(p_headers
[i
].value
);
2097 if (unlikely(!p_stream
->p_http_headers
[j
].name
||
2098 !p_stream
->p_http_headers
[j
].value
)) {
2099 free(p_stream
->p_http_headers
[j
].name
);
2100 free(p_stream
->p_http_headers
[j
].value
);
2105 p_stream
->i_http_headers
= j
;
2106 vlc_mutex_unlock(&p_stream
->lock
);