?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
screen: disable compilation for non-Mac Darwin flavors
[vlc/vlc-acra.git] / src / network / httpd.c
blobf76c47ce0594a65225ec419d849f66f82a9e97c5
1 /*****************************************************************************
2 * httpd.c
3 *****************************************************************************
4 * Copyright (C) 2004-2006 VLC authors and VideoLAN
5 * Copyright © 2004-2007 Rémi Denis-Courmont
6 * $Id$
7 *
8 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
9 * Rémi Denis-Courmont <rem # videolan.org>
10 *
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.
15 *
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.
20 *
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 *****************************************************************************/
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #include <vlc_common.h>
31 #include <vlc_httpd.h>
32
33 #include <assert.h>
34
35 #include <vlc_network.h>
36 #include <vlc_tls.h>
37 #include <vlc_strings.h>
38 #include <vlc_rand.h>
39 #include <vlc_charset.h>
40 #include <vlc_url.h>
41 #include <vlc_mime.h>
42 #include "../libvlc.h"
43
44 #include <string.h>
45 #include <errno.h>
46
47 #ifdef HAVE_UNISTD_H
48 # include <unistd.h>
49 #endif
50
51 #ifdef HAVE_POLL
52 # include <poll.h>
53 #endif
54
55 #if defined( WIN32 )
56 # include <winsock2.h>
57 #else
58 # include <sys/socket.h>
59 #endif
60
61 #if defined( WIN32 )
62 /* We need HUGE buffer otherwise TCP throughput is very limited */
63 #define HTTPD_CL_BUFSIZE 1000000
64 #else
65 #define HTTPD_CL_BUFSIZE 10000
66 #endif
67
68 static void httpd_ClientClean( httpd_client_t *cl );
69
70 /* each host run in his own thread */
71 struct httpd_host_t
72 {
73 VLC_COMMON_MEMBERS
74
75 /* ref count */
76 unsigned i_ref;
77
78 /* address/port and socket for listening at connections */
79 int *fds;
80 unsigned nfd;
81 unsigned port;
82
83 vlc_thread_t thread;
84 vlc_mutex_t lock;
85 vlc_cond_t wait;
86
87 /* all registered url (becarefull that 2 httpd_url_t could point at the same url)
88 * This will slow down the url research but make my live easier
89 * All url will have their cb trigger, but only the first one can answer
90 * */
91 int i_url;
92 httpd_url_t **url;
93
94 int i_client;
95 httpd_client_t **client;
96
97 /* TLS data */
98 vlc_tls_creds_t *p_tls;
99 };
100
101
102 struct httpd_url_t
103 {
104 httpd_host_t *host;
105
106 vlc_mutex_t lock;
107
108 char *psz_url;
109 char *psz_user;
110 char *psz_password;
111
112 struct
113 {
114 httpd_callback_t cb;
115 httpd_callback_sys_t *p_sys;
116 } catch[HTTPD_MSG_MAX];
117 };
118
119 /* status */
120 enum
121 {
122 HTTPD_CLIENT_RECEIVING,
123 HTTPD_CLIENT_RECEIVE_DONE,
124
125 HTTPD_CLIENT_SENDING,
126 HTTPD_CLIENT_SEND_DONE,
127
128 HTTPD_CLIENT_WAITING,
129
130 HTTPD_CLIENT_DEAD,
131
132 HTTPD_CLIENT_TLS_HS_IN,
133 HTTPD_CLIENT_TLS_HS_OUT
134 };
135
136 /* mode */
137 enum
138 {
139 HTTPD_CLIENT_FILE, /* default */
140 HTTPD_CLIENT_STREAM, /* regulary get data from cb */
141 };
142
143 struct httpd_client_t
144 {
145 httpd_url_t *url;
146
147 int i_ref;
148
149 int fd;
150
151 bool b_stream_mode;
152 uint8_t i_state;
153
154 mtime_t i_activity_date;
155 mtime_t i_activity_timeout;
156
157 /* buffer for reading header */
158 int i_buffer_size;
159 int i_buffer;
160 uint8_t *p_buffer;
161
162 /* */
163 httpd_message_t query; /* client -> httpd */
164 httpd_message_t answer; /* httpd -> client */
165
166 /* TLS data */
167 vlc_tls_t *p_tls;
168 };
169
170
171 /*****************************************************************************
172 * Various functions
173 *****************************************************************************/
174 typedef struct
175 {
176 unsigned i_code;
177 const char psz_reason[36];
178 } http_status_info;
179
180 static const http_status_info http_reason[] =
181 {
182 /*{ 100, "Continue" },
183 { 101, "Switching Protocols" },*/
184 { 200, "OK" },
185 /*{ 201, "Created" },
186 { 202, "Accepted" },
187 { 203, "Non-authoritative information" },
188 { 204, "No content" },
189 { 205, "Reset content" },
190 { 206, "Partial content" },
191 { 250, "Low on storage space" },
192 { 300, "Multiple choices" },*/
193 { 301, "Moved permanently" },
194 /*{ 302, "Moved temporarily" },
195 { 303, "See other" },
196 { 304, "Not modified" },
197 { 305, "Use proxy" },
198 { 307, "Temporary redirect" },
199 { 400, "Bad request" },*/
200 { 401, "Unauthorized" },
201 /*{ 402, "Payment Required" },*/
202 { 403, "Forbidden" },
203 { 404, "Not found" },
204 { 405, "Method not allowed" },
205 /*{ 406, "Not acceptable" },
206 { 407, "Proxy authentication required" },
207 { 408, "Request time-out" },
208 { 409, "Conflict" },
209 { 410, "Gone" },
210 { 411, "Length required" },
211 { 412, "Precondition failed" },
212 { 413, "Request entity too large" },
213 { 414, "Request-URI too large" },
214 { 415, "Unsupported media Type" },
215 { 416, "Requested range not satisfiable" },
216 { 417, "Expectation failed" },
217 { 451, "Parameter not understood" },
218 { 452, "Conference not found" },
219 { 453, "Not enough bandwidth" },*/
220 { 454, "Session not found" },
221 { 455, "Method not valid in this State" },
222 { 456, "Header field not valid for resource" },
223 { 457, "Invalid range" },
224 /*{ 458, "Read-only parameter" },*/
225 { 459, "Aggregate operation not allowed" },
226 { 460, "Non-aggregate operation not allowed" },
227 { 461, "Unsupported transport" },
228 /*{ 462, "Destination unreachable" },*/
229 { 500, "Internal server error" },
230 { 501, "Not implemented" },
231 /*{ 502, "Bad gateway" },*/
232 { 503, "Service unavailable" },
233 /*{ 504, "Gateway time-out" },*/
234 { 505, "Protocol version not supported" },
235 { 551, "Option not supported" },
236 { 999, "" }
237 };
238
239 static const char psz_fallback_reason[5][16] =
240 { "Continue", "OK", "Found", "Client error", "Server error" };
241
242 static const char *httpd_ReasonFromCode( unsigned i_code )
243 {
244 const http_status_info *p;
245
246 assert( ( i_code >= 100 ) && ( i_code <= 599 ) );
247
248 for (p = http_reason; i_code > p->i_code; p++);
249
250 if( p->i_code == i_code )
251 return p->psz_reason;
252
253 return psz_fallback_reason[(i_code / 100) - 1];
254 }
255
256
257 static size_t httpd_HtmlError (char **body, int code, const char *url)
258 {
259 const char *errname = httpd_ReasonFromCode (code);
260 assert (errname != NULL);
261
262 int res = asprintf (body,
263 "<?xml version=\"1.0\" encoding=\"ascii\" ?>\n"
264 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\""
265 " \"http://www.w3.org/TR/xhtml10/DTD/xhtml10strict.dtd\">\n"
266 "<html lang=\"en\">\n"
267 "<head>\n"
268 "<title>%s</title>\n"
269 "</head>\n"
270 "<body>\n"
271 "<h1>%d %s%s%s%s</h1>\n"
272 "<hr />\n"
273 "<a href=\"http://www.videolan.org\">VideoLAN</a>\n"
274 "</body>\n"
275 "</html>\n", errname, code, errname,
276 (url ? " (" : ""), (url ? url : ""), (url ? ")" : ""));
277
278 if (res == -1)
279 {
280 *body = NULL;
281 return 0;
282 }
283
284 return (size_t)res;
285 }
286
287
288 /*****************************************************************************
289 * High Level Functions: httpd_file_t
290 *****************************************************************************/
291 struct httpd_file_t
292 {
293 httpd_url_t *url;
294
295 char *psz_url;
296 char *psz_mime;
297
298 httpd_file_callback_t pf_fill;
299 httpd_file_sys_t *p_sys;
300
301 };
302
303 static int
304 httpd_FileCallBack( httpd_callback_sys_t *p_sys, httpd_client_t *cl,
305 httpd_message_t *answer, const httpd_message_t *query )
306 {
307 httpd_file_t *file = (httpd_file_t*)p_sys;
308 uint8_t **pp_body, *p_body;
309 const char *psz_connection;
310 int *pi_body, i_body;
311
312 if( answer == NULL || query == NULL )
313 {
314 return VLC_SUCCESS;
315 }
316 answer->i_proto = HTTPD_PROTO_HTTP;
317 answer->i_version= 1;
318 answer->i_type = HTTPD_MSG_ANSWER;
319
320 answer->i_status = 200;
321
322 httpd_MsgAdd( answer, "Content-type", "%s", file->psz_mime );
323 httpd_MsgAdd( answer, "Cache-Control", "%s", "no-cache" );
324
325 if( query->i_type != HTTPD_MSG_HEAD )
326 {
327 pp_body = &answer->p_body;
328 pi_body = &answer->i_body;
329 }
330 else
331 {
332 /* The file still needs to be executed. */
333 p_body = NULL;
334 i_body = 0;
335 pp_body = &p_body;
336 pi_body = &i_body;
337 }
338
339 if( query->i_type == HTTPD_MSG_POST )
340 {
341 /* msg_Warn not supported */
342 }
343
344 uint8_t *psz_args = query->psz_args;
345 file->pf_fill( file->p_sys, file, psz_args, pp_body, pi_body );
346
347 if( query->i_type == HTTPD_MSG_HEAD && p_body != NULL )
348 {
349 free( p_body );
350 }
351
352 /* We respect client request */
353 psz_connection = httpd_MsgGet( &cl->query, "Connection" );
354 if( psz_connection != NULL )
355 {
356 httpd_MsgAdd( answer, "Connection", "%s", psz_connection );
357 }
358
359 httpd_MsgAdd( answer, "Content-Length", "%d", answer->i_body );
360
361 return VLC_SUCCESS;
362 }
363
364 httpd_file_t *httpd_FileNew( httpd_host_t *host,
365 const char *psz_url, const char *psz_mime,
366 const char *psz_user, const char *psz_password,
367 httpd_file_callback_t pf_fill,
368 httpd_file_sys_t *p_sys )
369 {
370 httpd_file_t *file = xmalloc( sizeof( httpd_file_t ) );
371
372 file->url = httpd_UrlNew( host, psz_url, psz_user, psz_password );
373 if( file->url == NULL )
374 {
375 free( file );
376 return NULL;
377 }
378
379 file->psz_url = strdup( psz_url );
380 if( psz_mime && *psz_mime )
381 {
382 file->psz_mime = strdup( psz_mime );
383 }
384 else
385 {
386 file->psz_mime = strdup( vlc_mime_Ext2Mime( psz_url ) );
387 }
388
389 file->pf_fill = pf_fill;
390 file->p_sys = p_sys;
391
392 httpd_UrlCatch( file->url, HTTPD_MSG_HEAD, httpd_FileCallBack,
393 (httpd_callback_sys_t*)file );
394 httpd_UrlCatch( file->url, HTTPD_MSG_GET, httpd_FileCallBack,
395 (httpd_callback_sys_t*)file );
396 httpd_UrlCatch( file->url, HTTPD_MSG_POST, httpd_FileCallBack,
397 (httpd_callback_sys_t*)file );
398
399 return file;
400 }
401
402 httpd_file_sys_t *httpd_FileDelete( httpd_file_t *file )
403 {
404 httpd_file_sys_t *p_sys = file->p_sys;
405
406 httpd_UrlDelete( file->url );
407
408 free( file->psz_url );
409 free( file->psz_mime );
410
411 free( file );
412
413 return p_sys;
414 }
415
416 /*****************************************************************************
417 * High Level Functions: httpd_handler_t (for CGIs)
418 *****************************************************************************/
419 struct httpd_handler_t
420 {
421 httpd_url_t *url;
422
423 httpd_handler_callback_t pf_fill;
424 httpd_handler_sys_t *p_sys;
425
426 };
427
428 static int
429 httpd_HandlerCallBack( httpd_callback_sys_t *p_sys, httpd_client_t *cl,
430 httpd_message_t *answer, const httpd_message_t *query )
431 {
432 httpd_handler_t *handler = (httpd_handler_t*)p_sys;
433 char psz_remote_addr[NI_MAXNUMERICHOST];
434
435 if( answer == NULL || query == NULL )
436 {
437 return VLC_SUCCESS;
438 }
439 answer->i_proto = HTTPD_PROTO_NONE;
440 answer->i_type = HTTPD_MSG_ANSWER;
441
442 /* We do it ourselves, thanks */
443 answer->i_status = 0;
444
445 if( httpd_ClientIP( cl, psz_remote_addr, NULL ) == NULL )
446 *psz_remote_addr = '\0';
447
448 uint8_t *psz_args = query->psz_args;
449 handler->pf_fill( handler->p_sys, handler, query->psz_url, psz_args,
450 query->i_type, query->p_body, query->i_body,
451 psz_remote_addr, NULL,
452 &answer->p_body, &answer->i_body );
453
454 if( query->i_type == HTTPD_MSG_HEAD )
455 {
456 char *p = (char *)answer->p_body;
457
458 /* Looks for end of header (i.e. one empty line) */
459 while ( (p = strchr( p, '\r' )) != NULL )
460 {
461 if( p[1] && p[1] == '\n' && p[2] && p[2] == '\r'
462 && p[3] && p[3] == '\n' )
463 {
464 break;
465 }
466 }
467
468 if( p != NULL )
469 {
470 p[4] = '\0';
471 answer->i_body = strlen((char*)answer->p_body) + 1;
472 answer->p_body = xrealloc( answer->p_body, answer->i_body );
473 }
474 }
475
476 if( strncmp( (char *)answer->p_body, "HTTP/1.", 7 ) )
477 {
478 int i_status, i_headers;
479 char *psz_headers, *psz_new;
480 const char *psz_status;
481
482 if( !strncmp( (char *)answer->p_body, "Status: ", 8 ) )
483 {
484 /* Apache-style */
485 i_status = strtol( (char *)&answer->p_body[8], &psz_headers, 0 );
486 if( *psz_headers == '\r' || *psz_headers == '\n' ) psz_headers++;
487 if( *psz_headers == '\n' ) psz_headers++;
488 i_headers = answer->i_body - (psz_headers - (char *)answer->p_body);
489 }
490 else
491 {
492 i_status = 200;
493 psz_headers = (char *)answer->p_body;
494 i_headers = answer->i_body;
495 }
496
497 psz_status = httpd_ReasonFromCode( i_status );
498 answer->i_body = sizeof("HTTP/1.0 xxx \r\n")
499 + strlen(psz_status) + i_headers - 1;
500 psz_new = (char *)xmalloc( answer->i_body + 1);
501 sprintf( psz_new, "HTTP/1.0 %03d %s\r\n", i_status, psz_status );
502 memcpy( &psz_new[strlen(psz_new)], psz_headers, i_headers );
503 free( answer->p_body );
504 answer->p_body = (uint8_t *)psz_new;
505 }
506
507 return VLC_SUCCESS;
508 }
509
510 httpd_handler_t *httpd_HandlerNew( httpd_host_t *host, const char *psz_url,
511 const char *psz_user,
512 const char *psz_password,
513 httpd_handler_callback_t pf_fill,
514 httpd_handler_sys_t *p_sys )
515 {
516 httpd_handler_t *handler = xmalloc( sizeof( httpd_handler_t ) );
517
518 handler->url = httpd_UrlNew( host, psz_url, psz_user, psz_password );
519 if( handler->url == NULL )
520 {
521 free( handler );
522 return NULL;
523 }
524
525 handler->pf_fill = pf_fill;
526 handler->p_sys = p_sys;
527
528 httpd_UrlCatch( handler->url, HTTPD_MSG_HEAD, httpd_HandlerCallBack,
529 (httpd_callback_sys_t*)handler );
530 httpd_UrlCatch( handler->url, HTTPD_MSG_GET, httpd_HandlerCallBack,
531 (httpd_callback_sys_t*)handler );
532 httpd_UrlCatch( handler->url, HTTPD_MSG_POST, httpd_HandlerCallBack,
533 (httpd_callback_sys_t*)handler );
534
535 return handler;
536 }
537
538 httpd_handler_sys_t *httpd_HandlerDelete( httpd_handler_t *handler )
539 {
540 httpd_handler_sys_t *p_sys = handler->p_sys;
541 httpd_UrlDelete( handler->url );
542 free( handler );
543 return p_sys;
544 }
545
546 /*****************************************************************************
547 * High Level Functions: httpd_redirect_t
548 *****************************************************************************/
549 struct httpd_redirect_t
550 {
551 httpd_url_t *url;
552 char *psz_dst;
553 };
554
555 static int httpd_RedirectCallBack( httpd_callback_sys_t *p_sys,
556 httpd_client_t *cl, httpd_message_t *answer,
557 const httpd_message_t *query )
558 {
559 httpd_redirect_t *rdir = (httpd_redirect_t*)p_sys;
560 char *p_body;
561 (void)cl;
562
563 if( answer == NULL || query == NULL )
564 {
565 return VLC_SUCCESS;
566 }
567 answer->i_proto = HTTPD_PROTO_HTTP;
568 answer->i_version= 1;
569 answer->i_type = HTTPD_MSG_ANSWER;
570 answer->i_status = 301;
571
572 answer->i_body = httpd_HtmlError (&p_body, 301, rdir->psz_dst);
573 answer->p_body = (unsigned char *)p_body;
574
575 /* XXX check if it's ok or we need to set an absolute url */
576 httpd_MsgAdd( answer, "Location", "%s", rdir->psz_dst );
577
578 httpd_MsgAdd( answer, "Content-Length", "%d", answer->i_body );
579
580 return VLC_SUCCESS;
581 }
582
583 httpd_redirect_t *httpd_RedirectNew( httpd_host_t *host, const char *psz_url_dst,
584 const char *psz_url_src )
585 {
586 httpd_redirect_t *rdir = xmalloc( sizeof( httpd_redirect_t ) );
587
588 rdir->url = httpd_UrlNew( host, psz_url_src, NULL, NULL );
589 if( rdir->url == NULL )
590 {
591 free( rdir );
592 return NULL;
593 }
594 rdir->psz_dst = strdup( psz_url_dst );
595
596 /* Redirect apply for all HTTP request and RTSP DESCRIBE resquest */
597 httpd_UrlCatch( rdir->url, HTTPD_MSG_HEAD, httpd_RedirectCallBack,
598 (httpd_callback_sys_t*)rdir );
599 httpd_UrlCatch( rdir->url, HTTPD_MSG_GET, httpd_RedirectCallBack,
600 (httpd_callback_sys_t*)rdir );
601 httpd_UrlCatch( rdir->url, HTTPD_MSG_POST, httpd_RedirectCallBack,
602 (httpd_callback_sys_t*)rdir );
603 httpd_UrlCatch( rdir->url, HTTPD_MSG_DESCRIBE, httpd_RedirectCallBack,
604 (httpd_callback_sys_t*)rdir );
605
606 return rdir;
607 }
608 void httpd_RedirectDelete( httpd_redirect_t *rdir )
609 {
610 httpd_UrlDelete( rdir->url );
611 free( rdir->psz_dst );
612 free( rdir );
613 }
614
615 /*****************************************************************************
616 * High Level Funtions: httpd_stream_t
617 *****************************************************************************/
618 struct httpd_stream_t
619 {
620 vlc_mutex_t lock;
621 httpd_url_t *url;
622
623 char *psz_mime;
624
625 /* Header to send as first packet */
626 uint8_t *p_header;
627 int i_header;
628
629 /* circular buffer */
630 int i_buffer_size; /* buffer size, can't be reallocated smaller */
631 uint8_t *p_buffer; /* buffer */
632 int64_t i_buffer_pos; /* absolute position from begining */
633 int64_t i_buffer_last_pos; /* a new connection will start with that */
634 };
635
636 static int httpd_StreamCallBack( httpd_callback_sys_t *p_sys,
637 httpd_client_t *cl, httpd_message_t *answer,
638 const httpd_message_t *query )
639 {
640 httpd_stream_t *stream = (httpd_stream_t*)p_sys;
641
642 if( answer == NULL || query == NULL || cl == NULL )
643 {
644 return VLC_SUCCESS;
645 }
646
647 if( answer->i_body_offset > 0 )
648 {
649 int64_t i_write;
650 int i_pos;
651
652 #if 0
653 fprintf( stderr, "httpd_StreamCallBack i_body_offset=%lld\n",
654 answer->i_body_offset );
655 #endif
656
657 if( answer->i_body_offset >= stream->i_buffer_pos )
658 {
659 /* fprintf( stderr, "httpd_StreamCallBack: no data\n" ); */
660 return VLC_EGENERIC; /* wait, no data available */
661 }
662 if( answer->i_body_offset + stream->i_buffer_size <
663 stream->i_buffer_pos )
664 {
665 /* this client isn't fast enough */
666 #if 0
667 fprintf( stderr, "fixing i_body_offset (old=%lld new=%lld)\n",
668 answer->i_body_offset, stream->i_buffer_last_pos );
669 #endif
670 answer->i_body_offset = stream->i_buffer_last_pos;
671 }
672
673 i_pos = answer->i_body_offset % stream->i_buffer_size;
674 i_write = stream->i_buffer_pos - answer->i_body_offset;
675 if( i_write > HTTPD_CL_BUFSIZE )
676 {
677 i_write = HTTPD_CL_BUFSIZE;
678 }
679 else if( i_write <= 0 )
680 {
681 return VLC_EGENERIC; /* wait, no data available */
682 }
683
684 /* Don't go past the end of the circular buffer */
685 i_write = __MIN( i_write, stream->i_buffer_size - i_pos );
686
687 /* using HTTPD_MSG_ANSWER -> data available */
688 answer->i_proto = HTTPD_PROTO_HTTP;
689 answer->i_version= 0;
690 answer->i_type = HTTPD_MSG_ANSWER;
691
692 answer->i_body = i_write;
693 answer->p_body = xmalloc( i_write );
694 memcpy( answer->p_body, &stream->p_buffer[i_pos], i_write );
695
696 answer->i_body_offset += i_write;
697
698 return VLC_SUCCESS;
699 }
700 else
701 {
702 answer->i_proto = HTTPD_PROTO_HTTP;
703 answer->i_version= 0;
704 answer->i_type = HTTPD_MSG_ANSWER;
705
706 answer->i_status = 200;
707
708 if( query->i_type != HTTPD_MSG_HEAD )
709 {
710 cl->b_stream_mode = true;
711 vlc_mutex_lock( &stream->lock );
712 /* Send the header */
713 if( stream->i_header > 0 )
714 {
715 answer->i_body = stream->i_header;
716 answer->p_body = xmalloc( stream->i_header );
717 memcpy( answer->p_body, stream->p_header, stream->i_header );
718 }
719 answer->i_body_offset = stream->i_buffer_last_pos;
720 vlc_mutex_unlock( &stream->lock );
721 }
722 else
723 {
724 httpd_MsgAdd( answer, "Content-Length", "%d", 0 );
725 answer->i_body_offset = 0;
726 }
727
728 if( !strcmp( stream->psz_mime, "video/x-ms-asf-stream" ) )
729 {
730 bool b_xplaystream = false;
731 int i;
732
733 httpd_MsgAdd( answer, "Content-type", "%s",
734 "application/octet-stream" );
735 httpd_MsgAdd( answer, "Server", "Cougar 4.1.0.3921" );
736 httpd_MsgAdd( answer, "Pragma", "no-cache" );
737 httpd_MsgAdd( answer, "Pragma", "client-id=%lu",
738 vlc_mrand48()&0x7fff );
739 httpd_MsgAdd( answer, "Pragma", "features=\"broadcast\"" );
740
741 /* Check if there is a xPlayStrm=1 */
742 for( i = 0; i < query->i_name; i++ )
743 {
744 if( !strcasecmp( query->name[i], "Pragma" ) &&
745 strstr( query->value[i], "xPlayStrm=1" ) )
746 {
747 b_xplaystream = true;
748 }
749 }
750
751 if( !b_xplaystream )
752 {
753 answer->i_body_offset = 0;
754 }
755 }
756 else
757 {
758 httpd_MsgAdd( answer, "Content-type", "%s", stream->psz_mime );
759 }
760 httpd_MsgAdd( answer, "Cache-Control", "%s", "no-cache" );
761 return VLC_SUCCESS;
762 }
763 }
764
765 httpd_stream_t *httpd_StreamNew( httpd_host_t *host,
766 const char *psz_url, const char *psz_mime,
767 const char *psz_user, const char *psz_password )
768 {
769 httpd_stream_t *stream = xmalloc( sizeof( httpd_stream_t ) );
770
771 stream->url = httpd_UrlNew( host, psz_url, psz_user, psz_password );
772 if( stream->url == NULL )
773 {
774 free( stream );
775 return NULL;
776 }
777 vlc_mutex_init( &stream->lock );
778 if( psz_mime && *psz_mime )
779 {
780 stream->psz_mime = strdup( psz_mime );
781 }
782 else
783 {
784 stream->psz_mime = strdup( vlc_mime_Ext2Mime( psz_url ) );
785 }
786 stream->i_header = 0;
787 stream->p_header = NULL;
788 stream->i_buffer_size = 5000000; /* 5 Mo per stream */
789 stream->p_buffer = xmalloc( stream->i_buffer_size );
790 /* We set to 1 to make life simpler
791 * (this way i_body_offset can never be 0) */
792 stream->i_buffer_pos = 1;
793 stream->i_buffer_last_pos = 1;
794
795 httpd_UrlCatch( stream->url, HTTPD_MSG_HEAD, httpd_StreamCallBack,
796 (httpd_callback_sys_t*)stream );
797 httpd_UrlCatch( stream->url, HTTPD_MSG_GET, httpd_StreamCallBack,
798 (httpd_callback_sys_t*)stream );
799 httpd_UrlCatch( stream->url, HTTPD_MSG_POST, httpd_StreamCallBack,
800 (httpd_callback_sys_t*)stream );
801
802 return stream;
803 }
804
805 int httpd_StreamHeader( httpd_stream_t *stream, uint8_t *p_data, int i_data )
806 {
807 vlc_mutex_lock( &stream->lock );
808 free( stream->p_header );
809 stream->p_header = NULL;
810
811 stream->i_header = i_data;
812 if( i_data > 0 )
813 {
814 stream->p_header = xmalloc( i_data );
815 memcpy( stream->p_header, p_data, i_data );
816 }
817 vlc_mutex_unlock( &stream->lock );
818
819 return VLC_SUCCESS;
820 }
821
822 int httpd_StreamSend( httpd_stream_t *stream, uint8_t *p_data, int i_data )
823 {
824 int i_count;
825 int i_pos;
826
827 if( i_data < 0 || p_data == NULL )
828 {
829 return VLC_SUCCESS;
830 }
831 vlc_mutex_lock( &stream->lock );
832
833 /* save this pointer (to be used by new connection) */
834 stream->i_buffer_last_pos = stream->i_buffer_pos;
835
836 i_pos = stream->i_buffer_pos % stream->i_buffer_size;
837 i_count = i_data;
838 while( i_count > 0)
839 {
840 int i_copy;
841
842 i_copy = __MIN( i_count, stream->i_buffer_size - i_pos );
843
844 /* Ok, we can't go past the end of our buffer */
845 memcpy( &stream->p_buffer[i_pos], p_data, i_copy );
846
847 i_pos = ( i_pos + i_copy ) % stream->i_buffer_size;
848 i_count -= i_copy;
849 p_data += i_copy;
850 }
851
852 stream->i_buffer_pos += i_data;
853
854 vlc_mutex_unlock( &stream->lock );
855 return VLC_SUCCESS;
856 }
857
858 void httpd_StreamDelete( httpd_stream_t *stream )
859 {
860 httpd_UrlDelete( stream->url );
861 vlc_mutex_destroy( &stream->lock );
862 free( stream->psz_mime );
863 free( stream->p_header );
864 free( stream->p_buffer );
865 free( stream );
866 }
867
868 /*****************************************************************************
869 * Low level
870 *****************************************************************************/
871 static void* httpd_HostThread( void * );
872 static httpd_host_t *httpd_HostCreate( vlc_object_t *, const char *,
873 const char *, vlc_tls_creds_t * );
874
875 /* create a new host */
876 httpd_host_t *vlc_http_HostNew( vlc_object_t *p_this )
877 {
878 return httpd_HostCreate( p_this, "http-host", "http-port", NULL );
879 }
880
881 httpd_host_t *vlc_https_HostNew( vlc_object_t *obj )
882 {
883 char *cert = var_InheritString( obj, "http-cert" );
884 if( cert == NULL )
885 {
886 msg_Err( obj, "HTTP/TLS certificate not specified!" );
887 return NULL;
888 }
889
890 char *key = var_InheritString( obj, "http-key" );
891 vlc_tls_creds_t *tls = vlc_tls_ServerCreate( obj, cert, key );
892
893 if( tls == NULL )
894 {
895 msg_Err( obj, "HTTP/TLS certificate error (%s and %s)",
896 cert, (key != NULL) ? key : cert );
897 free( key );
898 free( cert );
899 return NULL;
900 }
901 free( key );
902 free( cert );
903
904 char *ca = var_InheritString( obj, "http-ca" );
905 if( ca != NULL )
906 {
907 if( vlc_tls_ServerAddCA( tls, ca ) )
908 {
909 msg_Err( obj, "HTTP/TLS CA error (%s)", ca );
910 free( ca );
911 goto error;
912 }
913 free( ca );
914 }
915
916 char *crl = var_InheritString( obj, "http-crl" );
917 if( crl != NULL )
918 {
919 if( vlc_tls_ServerAddCRL( tls, crl ) )
920 {
921 msg_Err( obj, "TLS CRL error (%s)", crl );
922 free( crl );
923 goto error;
924 }
925 free( crl );
926 }
927
928 return httpd_HostCreate( obj, "http-host", "https-port", tls );
929
930 error:
931 vlc_tls_Delete( tls );
932 return NULL;
933 }
934
935 httpd_host_t *vlc_rtsp_HostNew( vlc_object_t *p_this )
936 {
937 return httpd_HostCreate( p_this, "rtsp-host", "rtsp-port", NULL );
938 }
939
940 static struct httpd
941 {
942 vlc_mutex_t mutex;
943
944 httpd_host_t **host;
945 int i_host;
946 } httpd = { VLC_STATIC_MUTEX, NULL, 0 };
947
948 static httpd_host_t *httpd_HostCreate( vlc_object_t *p_this,
949 const char *hostvar,
950 const char *portvar,
951 vlc_tls_creds_t *p_tls )
952 {
953 httpd_host_t *host;
954 char *hostname = var_InheritString( p_this, hostvar );
955 unsigned port = var_InheritInteger( p_this, portvar );
956
957 vlc_url_t url;
958 vlc_UrlParse( &url, hostname, 0 );
959 free( hostname );
960 if( url.i_port != 0 )
961 {
962 msg_Err( p_this, "Ignoring port %d (using %d)", url.i_port, port );
963 msg_Info( p_this, "Specify port %d separately with the "
964 "%s option instead.", url.i_port, portvar );
965 }
966
967 /* to be sure to avoid multiple creation */
968 vlc_mutex_lock( &httpd.mutex );
969
970 /* verify if it already exist */
971 for( int i = 0; i < httpd.i_host; i++ )
972 {
973 host = httpd.host[i];
974
975 /* cannot mix TLS and non-TLS hosts */
976 if( host->port != port
977 || (host->p_tls != NULL) != (p_tls != NULL) )
978 continue;
979
980 /* Increase existing matching host reference count.
981 * The reference count is written under both the global httpd and the
982 * host lock. It is read with either or both locks held. The global
983 * lock is always acquired first. */
984 vlc_mutex_lock( &host->lock );
985 host->i_ref++;
986 vlc_mutex_unlock( &host->lock );
987
988 vlc_mutex_unlock( &httpd.mutex );
989 vlc_UrlClean( &url );
990 vlc_tls_Delete( p_tls );
991 return host;
992 }
993
994 /* create the new host */
995 host = (httpd_host_t *)vlc_custom_create( p_this, sizeof (*host),
996 "http host" );
997 if (host == NULL)
998 goto error;
999
1000 vlc_mutex_init( &host->lock );
1001 vlc_cond_init( &host->wait );
1002 host->i_ref = 1;
1003
1004 host->fds = net_ListenTCP( p_this, url.psz_host, port );
1005 if( host->fds == NULL )
1006 {
1007 msg_Err( p_this, "cannot create socket(s) for HTTP host" );
1008 goto error;
1009 }
1010 for (host->nfd = 0; host->fds[host->nfd] != -1; host->nfd++);
1011
1012 if( vlc_object_waitpipe( VLC_OBJECT( host ) ) == -1 )
1013 {
1014 msg_Err( host, "signaling pipe error: %m" );
1015 goto error;
1016 }
1017
1018 host->port = port;
1019 host->i_url = 0;
1020 host->url = NULL;
1021 host->i_client = 0;
1022 host->client = NULL;
1023 host->p_tls = p_tls;
1024
1025 /* create the thread */
1026 if( vlc_clone( &host->thread, httpd_HostThread, host,
1027 VLC_THREAD_PRIORITY_LOW ) )
1028 {
1029 msg_Err( p_this, "cannot spawn http host thread" );
1030 goto error;
1031 }
1032
1033 /* now add it to httpd */
1034 TAB_APPEND( httpd.i_host, httpd.host, host );
1035 vlc_mutex_unlock( &httpd.mutex );
1036
1037 vlc_UrlClean( &url );
1038
1039 return host;
1040
1041 error:
1042 vlc_mutex_unlock( &httpd.mutex );
1043
1044 if( host != NULL )
1045 {
1046 net_ListenClose( host->fds );
1047 vlc_cond_destroy( &host->wait );
1048 vlc_mutex_destroy( &host->lock );
1049 vlc_object_release( host );
1050 }
1051
1052 vlc_UrlClean( &url );
1053 vlc_tls_Delete( p_tls );
1054 return NULL;
1055 }
1056
1057 /* delete a host */
1058 void httpd_HostDelete( httpd_host_t *host )
1059 {
1060 int i;
1061 bool delete = false;
1062
1063 vlc_mutex_lock( &httpd.mutex );
1064
1065 vlc_mutex_lock( &host->lock );
1066 host->i_ref--;
1067 if( host->i_ref == 0 )
1068 delete = true;
1069 vlc_mutex_unlock( &host->lock );
1070 if( !delete )
1071 {
1072 /* still used */
1073 vlc_mutex_unlock( &httpd.mutex );
1074 msg_Dbg( host, "httpd_HostDelete: host still in use" );
1075 return;
1076 }
1077 TAB_REMOVE( httpd.i_host, httpd.host, host );
1078
1079 vlc_cancel( host->thread );
1080 vlc_join( host->thread, NULL );
1081
1082 msg_Dbg( host, "HTTP host removed" );
1083
1084 for( i = 0; i < host->i_url; i++ )
1085 {
1086 msg_Err( host, "url still registered: %s", host->url[i]->psz_url );
1087 }
1088 for( i = 0; i < host->i_client; i++ )
1089 {
1090 httpd_client_t *cl = host->client[i];
1091 msg_Warn( host, "client still connected" );
1092 httpd_ClientClean( cl );
1093 TAB_REMOVE( host->i_client, host->client, cl );
1094 free( cl );
1095 i--;
1096 /* TODO */
1097 }
1098
1099 vlc_tls_Delete( host->p_tls );
1100 net_ListenClose( host->fds );
1101 vlc_cond_destroy( &host->wait );
1102 vlc_mutex_destroy( &host->lock );
1103 vlc_object_release( host );
1104 vlc_mutex_unlock( &httpd.mutex );
1105 }
1106
1107 /* register a new url */
1108 httpd_url_t *httpd_UrlNew( httpd_host_t *host, const char *psz_url,
1109 const char *psz_user, const char *psz_password )
1110 {
1111 httpd_url_t *url;
1112
1113 assert( psz_url != NULL );
1114
1115 vlc_mutex_lock( &host->lock );
1116 for( int i = 0; i < host->i_url; i++ )
1117 {
1118 if( !strcmp( psz_url, host->url[i]->psz_url ) )
1119 {
1120 msg_Warn( host,
1121 "cannot add '%s' (url already defined)", psz_url );
1122 vlc_mutex_unlock( &host->lock );
1123 return NULL;
1124 }
1125 }
1126
1127 url = xmalloc( sizeof( httpd_url_t ) );
1128 url->host = host;
1129
1130 vlc_mutex_init( &url->lock );
1131 url->psz_url = strdup( psz_url );
1132 url->psz_user = strdup( psz_user ? psz_user : "" );
1133 url->psz_password = strdup( psz_password ? psz_password : "" );
1134 for( int i = 0; i < HTTPD_MSG_MAX; i++ )
1135 {
1136 url->catch[i].cb = NULL;
1137 url->catch[i].p_sys = NULL;
1138 }
1139
1140 TAB_APPEND( host->i_url, host->url, url );
1141 vlc_cond_signal( &host->wait );
1142 vlc_mutex_unlock( &host->lock );
1143
1144 return url;
1145 }
1146
1147 /* register callback on a url */
1148 int httpd_UrlCatch( httpd_url_t *url, int i_msg, httpd_callback_t cb,
1149 httpd_callback_sys_t *p_sys )
1150 {
1151 vlc_mutex_lock( &url->lock );
1152 url->catch[i_msg].cb = cb;
1153 url->catch[i_msg].p_sys= p_sys;
1154 vlc_mutex_unlock( &url->lock );
1155
1156 return VLC_SUCCESS;
1157 }
1158
1159 /* delete a url */
1160 void httpd_UrlDelete( httpd_url_t *url )
1161 {
1162 httpd_host_t *host = url->host;
1163 int i;
1164
1165 vlc_mutex_lock( &host->lock );
1166 TAB_REMOVE( host->i_url, host->url, url );
1167
1168 vlc_mutex_destroy( &url->lock );
1169 free( url->psz_url );
1170 free( url->psz_user );
1171 free( url->psz_password );
1172
1173 for( i = 0; i < host->i_client; i++ )
1174 {
1175 httpd_client_t *client = host->client[i];
1176
1177 if( client->url == url )
1178 {
1179 /* TODO complete it */
1180 msg_Warn( host, "force closing connections" );
1181 httpd_ClientClean( client );
1182 TAB_REMOVE( host->i_client, host->client, client );
1183 free( client );
1184 i--;
1185 }
1186 }
1187 free( url );
1188 vlc_mutex_unlock( &host->lock );
1189 }
1190
1191 static void httpd_MsgInit( httpd_message_t *msg )
1192 {
1193 msg->cl = NULL;
1194 msg->i_type = HTTPD_MSG_NONE;
1195 msg->i_proto = HTTPD_PROTO_NONE;
1196 msg->i_version = -1; /* FIXME */
1197
1198 msg->i_status = 0;
1199
1200 msg->psz_url = NULL;
1201 msg->psz_args = NULL;
1202
1203 msg->i_name = 0;
1204 msg->name = NULL;
1205 msg->i_value = 0;
1206 msg->value = NULL;
1207
1208 msg->i_body_offset = 0;
1209 msg->i_body = 0;
1210 msg->p_body = NULL;
1211 }
1212
1213 static void httpd_MsgClean( httpd_message_t *msg )
1214 {
1215 int i;
1216
1217 free( msg->psz_url );
1218 free( msg->psz_args );
1219 for( i = 0; i < msg->i_name; i++ )
1220 {
1221 free( msg->name[i] );
1222 free( msg->value[i] );
1223 }
1224 free( msg->name );
1225 free( msg->value );
1226 free( msg->p_body );
1227 httpd_MsgInit( msg );
1228 }
1229
1230 const char *httpd_MsgGet( const httpd_message_t *msg, const char *name )
1231 {
1232 int i;
1233
1234 for( i = 0; i < msg->i_name; i++ )
1235 {
1236 if( !strcasecmp( msg->name[i], name ))
1237 {
1238 return msg->value[i];
1239 }
1240 }
1241 return NULL;
1242 }
1243
1244 void httpd_MsgAdd( httpd_message_t *msg, const char *name, const char *psz_value, ... )
1245 {
1246 va_list args;
1247 char *value = NULL;
1248
1249 va_start( args, psz_value );
1250 if( us_vasprintf( &value, psz_value, args ) == -1 )
1251 value = NULL;
1252 va_end( args );
1253
1254 if( value == NULL )
1255 return;
1256
1257 name = strdup( name );
1258 if( name == NULL )
1259 {
1260 free( value );
1261 return;
1262 }
1263
1264 TAB_APPEND( msg->i_name, msg->name, (char*)name );
1265 TAB_APPEND( msg->i_value, msg->value, value );
1266 }
1267
1268 static void httpd_ClientInit( httpd_client_t *cl, mtime_t now )
1269 {
1270 cl->i_state = HTTPD_CLIENT_RECEIVING;
1271 cl->i_activity_date = now;
1272 cl->i_activity_timeout = INT64_C(10000000);
1273 cl->i_buffer_size = HTTPD_CL_BUFSIZE;
1274 cl->i_buffer = 0;
1275 cl->p_buffer = xmalloc( cl->i_buffer_size );
1276 cl->b_stream_mode = false;
1277
1278 httpd_MsgInit( &cl->query );
1279 httpd_MsgInit( &cl->answer );
1280 }
1281
1282 char* httpd_ClientIP( const httpd_client_t *cl, char *ip, int *port )
1283 {
1284 return net_GetPeerAddress( cl->fd, ip, port ) ? NULL : ip;
1285 }
1286
1287 char* httpd_ServerIP( const httpd_client_t *cl, char *ip, int *port )
1288 {
1289 return net_GetSockAddress( cl->fd, ip, port ) ? NULL : ip;
1290 }
1291
1292 static void httpd_ClientClean( httpd_client_t *cl )
1293 {
1294 if( cl->fd >= 0 )
1295 {
1296 if( cl->p_tls != NULL )
1297 vlc_tls_SessionDelete( cl->p_tls );
1298 net_Close( cl->fd );
1299 cl->fd = -1;
1300 }
1301
1302 httpd_MsgClean( &cl->answer );
1303 httpd_MsgClean( &cl->query );
1304
1305 free( cl->p_buffer );
1306 cl->p_buffer = NULL;
1307 }
1308
1309 static httpd_client_t *httpd_ClientNew( int fd, vlc_tls_t *p_tls, mtime_t now )
1310 {
1311 httpd_client_t *cl = malloc( sizeof( httpd_client_t ) );
1312
1313 if( !cl ) return NULL;
1314
1315 cl->i_ref = 0;
1316 cl->fd = fd;
1317 cl->url = NULL;
1318 cl->p_tls = p_tls;
1319
1320 httpd_ClientInit( cl, now );
1321 if( p_tls != NULL )
1322 cl->i_state = HTTPD_CLIENT_TLS_HS_OUT;
1323
1324 return cl;
1325 }
1326
1327 static
1328 ssize_t httpd_NetRecv (httpd_client_t *cl, uint8_t *p, size_t i_len)
1329 {
1330 vlc_tls_t *p_tls;
1331 ssize_t val;
1332
1333 p_tls = cl->p_tls;
1334 do
1335 val = p_tls ? tls_Recv (p_tls, p, i_len)
1336 : recv (cl->fd, p, i_len, 0);
1337 while (val == -1 && errno == EINTR);
1338 return val;
1339 }
1340
1341 static
1342 ssize_t httpd_NetSend (httpd_client_t *cl, const uint8_t *p, size_t i_len)
1343 {
1344 vlc_tls_t *p_tls;
1345 ssize_t val;
1346
1347 p_tls = cl->p_tls;
1348 do
1349 val = p_tls ? tls_Send( p_tls, p, i_len )
1350 : send (cl->fd, p, i_len, 0);
1351 while (val == -1 && errno == EINTR);
1352 return val;
1353 }
1354
1355
1356 static const struct
1357 {
1358 const char name[16];
1359 int i_type;
1360 int i_proto;
1361 }
1362 msg_type[] =
1363 {
1364 { "OPTIONS", HTTPD_MSG_OPTIONS, HTTPD_PROTO_RTSP },
1365 { "DESCRIBE", HTTPD_MSG_DESCRIBE, HTTPD_PROTO_RTSP },
1366 { "SETUP", HTTPD_MSG_SETUP, HTTPD_PROTO_RTSP },
1367 { "PLAY", HTTPD_MSG_PLAY, HTTPD_PROTO_RTSP },
1368 { "PAUSE", HTTPD_MSG_PAUSE, HTTPD_PROTO_RTSP },
1369 { "GET_PARAMETER", HTTPD_MSG_GETPARAMETER, HTTPD_PROTO_RTSP },
1370 { "TEARDOWN", HTTPD_MSG_TEARDOWN, HTTPD_PROTO_RTSP },
1371 { "GET", HTTPD_MSG_GET, HTTPD_PROTO_HTTP },
1372 { "HEAD", HTTPD_MSG_HEAD, HTTPD_PROTO_HTTP },
1373 { "POST", HTTPD_MSG_POST, HTTPD_PROTO_HTTP },
1374 { "", HTTPD_MSG_NONE, HTTPD_PROTO_NONE }
1375 };
1376
1377
1378 static void httpd_ClientRecv( httpd_client_t *cl )
1379 {
1380 int i_len;
1381
1382 /* ignore leading whites */
1383 if( ( cl->query.i_proto == HTTPD_PROTO_NONE ) &&
1384 ( cl->i_buffer == 0 ) )
1385 {
1386 unsigned char c;
1387
1388 i_len = httpd_NetRecv( cl, &c, 1 );
1389
1390 if( ( i_len > 0 ) && ( strchr( "\r\n\t ", c ) == NULL ) )
1391 {
1392 cl->p_buffer[0] = c;
1393 cl->i_buffer++;
1394 }
1395 }
1396 else
1397 if( cl->query.i_proto == HTTPD_PROTO_NONE )
1398 {
1399 /* enough to see if it's Interleaved RTP over RTSP or RTSP/HTTP */
1400 i_len = httpd_NetRecv( cl, &cl->p_buffer[cl->i_buffer],
1401 7 - cl->i_buffer );
1402 if( i_len > 0 )
1403 {
1404 cl->i_buffer += i_len;
1405 }
1406
1407 /* The smallest legal request is 7 bytes ("GET /\r\n"),
1408 * this is the maximum we can ask at this point. */
1409 if( cl->i_buffer >= 7 )
1410 {
1411 if( !memcmp( cl->p_buffer, "HTTP/1.", 7 ) )
1412 {
1413 cl->query.i_proto = HTTPD_PROTO_HTTP;
1414 cl->query.i_type = HTTPD_MSG_ANSWER;
1415 }
1416 else if( !memcmp( cl->p_buffer, "RTSP/1.", 7 ) )
1417 {
1418 cl->query.i_proto = HTTPD_PROTO_RTSP;
1419 cl->query.i_type = HTTPD_MSG_ANSWER;
1420 }
1421 else
1422 {
1423 /* We need the full request line to determine the protocol. */
1424 cl->query.i_proto = HTTPD_PROTO_HTTP0;
1425 cl->query.i_type = HTTPD_MSG_NONE;
1426 }
1427 }
1428 }
1429 else if( cl->query.i_body > 0 )
1430 {
1431 /* we are reading the body of a request or a channel */
1432 i_len = httpd_NetRecv( cl, &cl->query.p_body[cl->i_buffer],
1433 cl->query.i_body - cl->i_buffer );
1434 if( i_len > 0 )
1435 {
1436 cl->i_buffer += i_len;
1437 }
1438 if( cl->i_buffer >= cl->query.i_body )
1439 {
1440 cl->i_state = HTTPD_CLIENT_RECEIVE_DONE;
1441 }
1442 }
1443 else
1444 {
1445 /* we are reading a header -> char by char */
1446 for( ;; )
1447 {
1448 if( cl->i_buffer == cl->i_buffer_size )
1449 {
1450 uint8_t *newbuf = realloc( cl->p_buffer, cl->i_buffer_size + 1024 );
1451 if( newbuf == NULL )
1452 {
1453 i_len = 0;
1454 break;
1455 }
1456
1457 cl->p_buffer = newbuf;
1458 cl->i_buffer_size += 1024;
1459 }
1460
1461 i_len = httpd_NetRecv (cl, &cl->p_buffer[cl->i_buffer], 1 );
1462 if( i_len <= 0 )
1463 {
1464 break;
1465 }
1466 cl->i_buffer++;
1467
1468 if( ( cl->query.i_proto == HTTPD_PROTO_HTTP0 )
1469 && ( cl->p_buffer[cl->i_buffer - 1] == '\n' ) )
1470 {
1471 /* Request line is now complete */
1472 const char *p = memchr( cl->p_buffer, ' ', cl->i_buffer );
1473 size_t len;
1474
1475 assert( cl->query.i_type == HTTPD_MSG_NONE );
1476
1477 if( p == NULL ) /* no URI: evil guy */
1478 {
1479 i_len = 0; /* drop connection */
1480 break;
1481 }
1482
1483 do
1484 p++; /* skips extra spaces */
1485 while( *p == ' ' );
1486
1487 p = memchr( p, ' ', ((char *)cl->p_buffer) + cl->i_buffer - p );
1488 if( p == NULL ) /* no explicit protocol: HTTP/0.9 */
1489 {
1490 i_len = 0; /* not supported currently -> drop */
1491 break;
1492 }
1493
1494 do
1495 p++; /* skips extra spaces ever again */
1496 while( *p == ' ' );
1497
1498 len = ((char *)cl->p_buffer) + cl->i_buffer - p;
1499 if( len < 7 ) /* foreign protocol */
1500 i_len = 0; /* I don't understand -> drop */
1501 else
1502 if( memcmp( p, "HTTP/1.", 7 ) == 0 )
1503 {
1504 cl->query.i_proto = HTTPD_PROTO_HTTP;
1505 cl->query.i_version = atoi( p + 7 );
1506 }
1507 else
1508 if( memcmp( p, "RTSP/1.", 7 ) == 0 )
1509 {
1510 cl->query.i_proto = HTTPD_PROTO_RTSP;
1511 cl->query.i_version = atoi( p + 7 );
1512 }
1513 else
1514 if( memcmp( p, "HTTP/", 5 ) == 0 )
1515 {
1516 const uint8_t sorry[] =
1517 "HTTP/1.1 505 Unknown HTTP version\r\n\r\n";
1518 httpd_NetSend( cl, sorry, sizeof( sorry ) - 1 );
1519 i_len = 0; /* drop */
1520 }
1521 else
1522 if( memcmp( p, "RTSP/", 5 ) == 0 )
1523 {
1524 const uint8_t sorry[] =
1525 "RTSP/1.0 505 Unknown RTSP version\r\n\r\n";
1526 httpd_NetSend( cl, sorry, sizeof( sorry ) - 1 );
1527 i_len = 0; /* drop */
1528 }
1529 else /* yet another foreign protocol */
1530 i_len = 0;
1531
1532 if( i_len == 0 )
1533 break;
1534 }
1535
1536 if( ( cl->i_buffer >= 2 && !memcmp( &cl->p_buffer[cl->i_buffer-2], "\n\n", 2 ) )||
1537 ( cl->i_buffer >= 4 && !memcmp( &cl->p_buffer[cl->i_buffer-4], "\r\n\r\n", 4 ) ) )
1538 {
1539 char *p;
1540
1541 /* we have finished the header so parse it and set i_body */
1542 cl->p_buffer[cl->i_buffer] = '\0';
1543
1544 if( cl->query.i_type == HTTPD_MSG_ANSWER )
1545 {
1546 /* FIXME:
1547 * assume strlen( "HTTP/1.x" ) = 8
1548 */
1549 cl->query.i_status =
1550 strtol( (char *)&cl->p_buffer[8],
1551 &p, 0 );
1552 while( *p == ' ' )
1553 p++;
1554 }
1555 else
1556 {
1557 unsigned i;
1558
1559 p = NULL;
1560 cl->query.i_type = HTTPD_MSG_NONE;
1561
1562 /*fprintf( stderr, "received new request=%s\n", cl->p_buffer);*/
1563
1564 for( i = 0; msg_type[i].name[0]; i++ )
1565 {
1566 if( !strncmp( (char *)cl->p_buffer, msg_type[i].name,
1567 strlen( msg_type[i].name ) ) )
1568 {
1569 p = (char *)&cl->p_buffer[strlen(msg_type[i].name) + 1 ];
1570 cl->query.i_type = msg_type[i].i_type;
1571 if( cl->query.i_proto != msg_type[i].i_proto )
1572 {
1573 p = NULL;
1574 cl->query.i_proto = HTTPD_PROTO_NONE;
1575 cl->query.i_type = HTTPD_MSG_NONE;
1576 }
1577 break;
1578 }
1579 }
1580 if( p == NULL )
1581 {
1582 if( strstr( (char *)cl->p_buffer, "HTTP/1." ) )
1583 {
1584 cl->query.i_proto = HTTPD_PROTO_HTTP;
1585 }
1586 else if( strstr( (char *)cl->p_buffer, "RTSP/1." ) )
1587 {
1588 cl->query.i_proto = HTTPD_PROTO_RTSP;
1589 }
1590 }
1591 else
1592 {
1593 char *p2;
1594 char *p3;
1595
1596 while( *p == ' ' )
1597 {
1598 p++;
1599 }
1600 p2 = strchr( p, ' ' );
1601 if( p2 )
1602 {
1603 *p2++ = '\0';
1604 }
1605 if( !strncasecmp( p, ( cl->query.i_proto
1606 == HTTPD_PROTO_HTTP ) ? "http:" : "rtsp:", 5 ) )
1607 { /* Skip hier-part of URL (if present) */
1608 p += 5;
1609 if( !strncmp( p, "//", 2 ) ) /* skip authority */
1610 { /* see RFC3986 §3.2 */
1611 p += 2;
1612 p += strcspn( p, "/?#" );
1613 }
1614 }
1615 else
1616 if( !strncasecmp( p, ( cl->query.i_proto
1617 == HTTPD_PROTO_HTTP ) ? "https:" : "rtsps:", 6 ) )
1618 { /* Skip hier-part of URL (if present) */
1619 p += 6;
1620 if( !strncmp( p, "//", 2 ) ) /* skip authority */
1621 { /* see RFC3986 §3.2 */
1622 p += 2;
1623 p += strcspn( p, "/?#" );
1624 }
1625 }
1626
1627 cl->query.psz_url = strdup( p );
1628 if( ( p3 = strchr( cl->query.psz_url, '?' ) ) )
1629 {
1630 *p3++ = '\0';
1631 cl->query.psz_args = (uint8_t *)strdup( p3 );
1632 }
1633 p = p2;
1634 }
1635 }
1636 if( p )
1637 {
1638 p = strchr( p, '\n' );
1639 }
1640 if( p )
1641 {
1642 while( *p == '\n' || *p == '\r' )
1643 {
1644 p++;
1645 }
1646 while( p && *p != '\0' )
1647 {
1648 char *line = p;
1649 char *eol = p = strchr( p, '\n' );
1650 char *colon;
1651
1652 while( eol && eol >= line && ( *eol == '\n' || *eol == '\r' ) )
1653 {
1654 *eol-- = '\0';
1655 }
1656
1657 if( ( colon = strchr( line, ':' ) ) )
1658 {
1659 char *name;
1660 char *value;
1661
1662 *colon++ = '\0';
1663 while( *colon == ' ' )
1664 {
1665 colon++;
1666 }
1667 name = strdup( line );
1668 value = strdup( colon );
1669
1670 TAB_APPEND( cl->query.i_name, cl->query.name, name );
1671 TAB_APPEND( cl->query.i_value,cl->query.value,value);
1672
1673 if( !strcasecmp( name, "Content-Length" ) )
1674 {
1675 cl->query.i_body = atol( value );
1676 }
1677 }
1678
1679 if( p )
1680 {
1681 p++;
1682 while( *p == '\n' || *p == '\r' )
1683 {
1684 p++;
1685 }
1686 }
1687 }
1688 }
1689 if( cl->query.i_body > 0 )
1690 {
1691 /* TODO Mhh, handle the case where the client only
1692 * sends a request and closes the connection to
1693 * mark the end of the body (probably only RTSP) */
1694 cl->query.p_body = malloc( cl->query.i_body );
1695 cl->i_buffer = 0;
1696 if ( cl->query.p_body == NULL )
1697 {
1698 switch (cl->query.i_proto)
1699 {
1700 case HTTPD_PROTO_HTTP:
1701 {
1702 const uint8_t sorry[] =
1703 "HTTP/1.1 413 Request Entity Too Large\r\n\r\n";
1704 httpd_NetSend( cl, sorry, sizeof( sorry ) - 1 );
1705 break;
1706 }
1707 case HTTPD_PROTO_RTSP:
1708 {
1709 const uint8_t sorry[] =
1710 "RTSP/1.0 413 Request Entity Too Large\r\n\r\n";
1711 httpd_NetSend( cl, sorry, sizeof( sorry ) - 1 );
1712 break;
1713 }
1714 default:
1715 assert( 0 );
1716 }
1717 i_len = 0; /* drop */
1718 }
1719 break;
1720 }
1721 else
1722 {
1723 cl->i_state = HTTPD_CLIENT_RECEIVE_DONE;
1724 }
1725 }
1726 }
1727 }
1728
1729 /* check if the client is to be set to dead */
1730 #if defined( WIN32 )
1731 if( ( i_len < 0 && WSAGetLastError() != WSAEWOULDBLOCK ) || ( i_len == 0 ) )
1732 #else
1733 if( ( i_len < 0 && errno != EAGAIN ) || ( i_len == 0 ) )
1734 #endif
1735 {
1736 if( cl->query.i_proto != HTTPD_PROTO_NONE && cl->query.i_type != HTTPD_MSG_NONE )
1737 {
1738 /* connection closed -> end of data */
1739 if( cl->query.i_body > 0 )
1740 {
1741 cl->query.i_body = cl->i_buffer;
1742 }
1743 cl->i_state = HTTPD_CLIENT_RECEIVE_DONE;
1744 }
1745 else
1746 {
1747 cl->i_state = HTTPD_CLIENT_DEAD;
1748 }
1749 }
1750
1751 /* XXX: for QT I have to disable timeout. Try to find why */
1752 if( cl->query.i_proto == HTTPD_PROTO_RTSP )
1753 cl->i_activity_timeout = 0;
1754
1755 #if 0 /* Debugging only */
1756 if( cl->i_state == HTTPD_CLIENT_RECEIVE_DONE )
1757 {
1758 int i;
1759
1760 fprintf( stderr, "received new request\n" );
1761 fprintf( stderr, " - proto=%s\n",
1762 cl->query.i_proto == HTTPD_PROTO_HTTP ? "HTTP" : "RTSP" );
1763 fprintf( stderr, " - version=%d\n", cl->query.i_version );
1764 fprintf( stderr, " - msg=%d\n", cl->query.i_type );
1765 if( cl->query.i_type == HTTPD_MSG_ANSWER )
1766 {
1767 fprintf( stderr, " - answer=%d '%s'\n", cl->query.i_status,
1768 cl->query.psz_status );
1769 }
1770 else if( cl->query.i_type != HTTPD_MSG_NONE )
1771 {
1772 fprintf( stderr, " - url=%s\n", cl->query.psz_url );
1773 }
1774 for( i = 0; i < cl->query.i_name; i++ )
1775 {
1776 fprintf( stderr, " - option name='%s' value='%s'\n",
1777 cl->query.name[i], cl->query.value[i] );
1778 }
1779 }
1780 #endif
1781 }
1782
1783 static void httpd_ClientSend( httpd_client_t *cl )
1784 {
1785 int i;
1786 int i_len;
1787
1788 if( cl->i_buffer < 0 )
1789 {
1790 /* We need to create the header */
1791 int i_size = 0;
1792 char *p;
1793 const char *psz_status = httpd_ReasonFromCode( cl->answer.i_status );
1794
1795 i_size = strlen( "HTTP/1.") + 10 + 10 + strlen( psz_status ) + 5;
1796 for( i = 0; i < cl->answer.i_name; i++ )
1797 {
1798 i_size += strlen( cl->answer.name[i] ) + 2 +
1799 strlen( cl->answer.value[i] ) + 2;
1800 }
1801
1802 if( cl->i_buffer_size < i_size )
1803 {
1804 cl->i_buffer_size = i_size;
1805 free( cl->p_buffer );
1806 cl->p_buffer = xmalloc( i_size );
1807 }
1808 p = (char *)cl->p_buffer;
1809
1810 p += sprintf( p, "%s.%u %d %s\r\n",
1811 cl->answer.i_proto == HTTPD_PROTO_HTTP ? "HTTP/1" : "RTSP/1",
1812 cl->answer.i_version,
1813 cl->answer.i_status, psz_status );
1814 for( i = 0; i < cl->answer.i_name; i++ )
1815 {
1816 p += sprintf( p, "%s: %s\r\n", cl->answer.name[i],
1817 cl->answer.value[i] );
1818 }
1819 p += sprintf( p, "\r\n" );
1820
1821 cl->i_buffer = 0;
1822 cl->i_buffer_size = (uint8_t*)p - cl->p_buffer;
1823
1824 /*fprintf( stderr, "sending answer\n" );
1825 fprintf( stderr, "%s", cl->p_buffer );*/
1826 }
1827
1828 i_len = httpd_NetSend( cl, &cl->p_buffer[cl->i_buffer],
1829 cl->i_buffer_size - cl->i_buffer );
1830 if( i_len >= 0 )
1831 {
1832 cl->i_buffer += i_len;
1833
1834 if( cl->i_buffer >= cl->i_buffer_size )
1835 {
1836 if( cl->answer.i_body == 0 && cl->answer.i_body_offset > 0 )
1837 {
1838 /* catch more body data */
1839 int i_msg = cl->query.i_type;
1840 int64_t i_offset = cl->answer.i_body_offset;
1841
1842 httpd_MsgClean( &cl->answer );
1843 cl->answer.i_body_offset = i_offset;
1844
1845 cl->url->catch[i_msg].cb( cl->url->catch[i_msg].p_sys, cl,
1846 &cl->answer, &cl->query );
1847 }
1848
1849 if( cl->answer.i_body > 0 )
1850 {
1851 /* send the body data */
1852 free( cl->p_buffer );
1853 cl->p_buffer = cl->answer.p_body;
1854 cl->i_buffer_size = cl->answer.i_body;
1855 cl->i_buffer = 0;
1856
1857 cl->answer.i_body = 0;
1858 cl->answer.p_body = NULL;
1859 }
1860 else
1861 {
1862 /* send finished */
1863 cl->i_state = HTTPD_CLIENT_SEND_DONE;
1864 }
1865 }
1866 }
1867 else
1868 {
1869 #if defined( WIN32 )
1870 if( ( i_len < 0 && WSAGetLastError() != WSAEWOULDBLOCK ) || ( i_len == 0 ) )
1871 #else
1872 if( ( i_len < 0 && errno != EAGAIN ) || ( i_len == 0 ) )
1873 #endif
1874 {
1875 /* error */
1876 cl->i_state = HTTPD_CLIENT_DEAD;
1877 }
1878 }
1879 }
1880
1881 static void httpd_ClientTlsHandshake( httpd_client_t *cl )
1882 {
1883 switch( vlc_tls_SessionHandshake( cl->p_tls, NULL, NULL ) )
1884 {
1885 case 0:
1886 cl->i_state = HTTPD_CLIENT_RECEIVING;
1887 break;
1888
1889 case -1:
1890 cl->i_state = HTTPD_CLIENT_DEAD;
1891 break;
1892
1893 case 1:
1894 cl->i_state = HTTPD_CLIENT_TLS_HS_IN;
1895 break;
1896
1897 case 2:
1898 cl->i_state = HTTPD_CLIENT_TLS_HS_OUT;
1899 break;
1900 }
1901 }
1902
1903 static void* httpd_HostThread( void *data )
1904 {
1905 httpd_host_t *host = data;
1906 int canc = vlc_savecancel();
1907
1908 vlc_mutex_lock( &host->lock );
1909 while( host->i_ref > 0 )
1910 {
1911 struct pollfd ufd[host->nfd + host->i_client];
1912 unsigned nfd;
1913 for( nfd = 0; nfd < host->nfd; nfd++ )
1914 {
1915 ufd[nfd].fd = host->fds[nfd];
1916 ufd[nfd].events = POLLIN;
1917 ufd[nfd].revents = 0;
1918 }
1919
1920 /* add all socket that should be read/write and close dead connection */
1921 while( host->i_url <= 0 )
1922 {
1923 mutex_cleanup_push( &host->lock );
1924 vlc_restorecancel( canc );
1925 vlc_cond_wait( &host->wait, &host->lock );
1926 canc = vlc_savecancel();
1927 vlc_cleanup_pop();
1928 }
1929
1930 mtime_t now = mdate();
1931 bool b_low_delay = false;
1932
1933 for(int i_client = 0; i_client < host->i_client; i_client++ )
1934 {
1935 httpd_client_t *cl = host->client[i_client];
1936 if( cl->i_ref < 0 || ( cl->i_ref == 0 &&
1937 ( cl->i_state == HTTPD_CLIENT_DEAD ||
1938 ( cl->i_activity_timeout > 0 &&
1939 cl->i_activity_date+cl->i_activity_timeout < now) ) ) )
1940 {
1941 httpd_ClientClean( cl );
1942 TAB_REMOVE( host->i_client, host->client, cl );
1943 free( cl );
1944 i_client--;
1945 continue;
1946 }
1947
1948 struct pollfd *pufd = ufd + nfd;
1949 assert (pufd < ufd + (sizeof (ufd) / sizeof (ufd[0])));
1950
1951 pufd->fd = cl->fd;
1952 pufd->events = pufd->revents = 0;
1953
1954 if( ( cl->i_state == HTTPD_CLIENT_RECEIVING )
1955 || ( cl->i_state == HTTPD_CLIENT_TLS_HS_IN ) )
1956 {
1957 pufd->events = POLLIN;
1958 }
1959 else if( ( cl->i_state == HTTPD_CLIENT_SENDING )
1960 || ( cl->i_state == HTTPD_CLIENT_TLS_HS_OUT ) )
1961 {
1962 pufd->events = POLLOUT;
1963 }
1964 else if( cl->i_state == HTTPD_CLIENT_RECEIVE_DONE )
1965 {
1966 httpd_message_t *answer = &cl->answer;
1967 httpd_message_t *query = &cl->query;
1968 int i_msg = query->i_type;
1969
1970 httpd_MsgInit( answer );
1971
1972 /* Handle what we received */
1973 if( i_msg == HTTPD_MSG_ANSWER )
1974 {
1975 cl->url = NULL;
1976 cl->i_state = HTTPD_CLIENT_DEAD;
1977 }
1978 else if( i_msg == HTTPD_MSG_OPTIONS )
1979 {
1980
1981 answer->i_type = HTTPD_MSG_ANSWER;
1982 answer->i_proto = query->i_proto;
1983 answer->i_status = 200;
1984 answer->i_body = 0;
1985 answer->p_body = NULL;
1986
1987 httpd_MsgAdd( answer, "Server", "VLC/%s", VERSION );
1988 httpd_MsgAdd( answer, "Content-Length", "0" );
1989
1990 switch( query->i_proto )
1991 {
1992 case HTTPD_PROTO_HTTP:
1993 answer->i_version = 1;
1994 httpd_MsgAdd( answer, "Allow",
1995 "GET,HEAD,POST,OPTIONS" );
1996 break;
1997
1998 case HTTPD_PROTO_RTSP:
1999 {
2000 const char *p;
2001 answer->i_version = 0;
2002
2003 p = httpd_MsgGet( query, "Cseq" );
2004 if( p != NULL )
2005 httpd_MsgAdd( answer, "Cseq", "%s", p );
2006 p = httpd_MsgGet( query, "Timestamp" );
2007 if( p != NULL )
2008 httpd_MsgAdd( answer, "Timestamp", "%s", p );
2009
2010 p = httpd_MsgGet( query, "Require" );
2011 if( p != NULL )
2012 {
2013 answer->i_status = 551;
2014 httpd_MsgAdd( query, "Unsupported", "%s", p );
2015 }
2016
2017 httpd_MsgAdd( answer, "Public", "DESCRIBE,SETUP,"
2018 "TEARDOWN,PLAY,PAUSE,GET_PARAMETER" );
2019 break;
2020 }
2021 }
2022
2023 cl->i_buffer = -1; /* Force the creation of the answer in
2024 * httpd_ClientSend */
2025 cl->i_state = HTTPD_CLIENT_SENDING;
2026 }
2027 else if( i_msg == HTTPD_MSG_NONE )
2028 {
2029 if( query->i_proto == HTTPD_PROTO_NONE )
2030 {
2031 cl->url = NULL;
2032 cl->i_state = HTTPD_CLIENT_DEAD;
2033 }
2034 else
2035 {
2036 char *p;
2037
2038 /* unimplemented */
2039 answer->i_proto = query->i_proto ;
2040 answer->i_type = HTTPD_MSG_ANSWER;
2041 answer->i_version= 0;
2042 answer->i_status = 501;
2043
2044 answer->i_body = httpd_HtmlError (&p, 501, NULL);
2045 answer->p_body = (uint8_t *)p;
2046 httpd_MsgAdd( answer, "Content-Length", "%d", answer->i_body );
2047
2048 cl->i_buffer = -1; /* Force the creation of the answer in httpd_ClientSend */
2049 cl->i_state = HTTPD_CLIENT_SENDING;
2050 }
2051 }
2052 else
2053 {
2054 bool b_auth_failed = false;
2055
2056 /* Search the url and trigger callbacks */
2057 for(int i = 0; i < host->i_url; i++ )
2058 {
2059 httpd_url_t *url = host->url[i];
2060
2061 if( !strcmp( url->psz_url, query->psz_url ) )
2062 {
2063 if( url->catch[i_msg].cb )
2064 {
2065 if( answer && ( *url->psz_user || *url->psz_password ) )
2066 {
2067 /* create the headers */
2068 const char *b64 = httpd_MsgGet( query, "Authorization" ); /* BASIC id */
2069 char *user = NULL, *pass = NULL;
2070
2071 if( b64 != NULL
2072 && !strncasecmp( b64, "BASIC", 5 ) )
2073 {
2074 b64 += 5;
2075 while( *b64 == ' ' )
2076 b64++;
2077
2078 user = vlc_b64_decode( b64 );
2079 if (user != NULL)
2080 {
2081 pass = strchr (user, ':');
2082 if (pass != NULL)
2083 *pass++ = '\0';
2084 }
2085 }
2086
2087 if ((user == NULL) || (pass == NULL)
2088 || strcmp (user, url->psz_user)
2089 || strcmp (pass, url->psz_password))
2090 {
2091 httpd_MsgAdd( answer,
2092 "WWW-Authenticate",
2093 "Basic realm=\"VLC stream\"" );
2094 /* We fail for all url */
2095 b_auth_failed = true;
2096 free( user );
2097 break;
2098 }
2099
2100 free( user );
2101 }
2102
2103 if( !url->catch[i_msg].cb( url->catch[i_msg].p_sys, cl, answer, query ) )
2104 {
2105 if( answer->i_proto == HTTPD_PROTO_NONE )
2106 {
2107 /* Raw answer from a CGI */
2108 cl->i_buffer = cl->i_buffer_size;
2109 }
2110 else
2111 cl->i_buffer = -1;
2112
2113 /* only one url can answer */
2114 answer = NULL;
2115 if( cl->url == NULL )
2116 {
2117 cl->url = url;
2118 }
2119 }
2120 }
2121 }
2122 }
2123
2124 if( answer )
2125 {
2126 char *p;
2127
2128 answer->i_proto = query->i_proto;
2129 answer->i_type = HTTPD_MSG_ANSWER;
2130 answer->i_version= 0;
2131
2132 if( b_auth_failed )
2133 {
2134 answer->i_status = 401;
2135 }
2136 else
2137 {
2138 /* no url registered */
2139 answer->i_status = 404;
2140 }
2141
2142 answer->i_body = httpd_HtmlError (&p,
2143 answer->i_status,
2144 query->psz_url);
2145 answer->p_body = (uint8_t *)p;
2146
2147 cl->i_buffer = -1; /* Force the creation of the answer in httpd_ClientSend */
2148 httpd_MsgAdd( answer, "Content-Length", "%d", answer->i_body );
2149 httpd_MsgAdd( answer, "Content-Type", "%s", "text/html" );
2150 }
2151
2152 cl->i_state = HTTPD_CLIENT_SENDING;
2153 }
2154 }
2155 else if( cl->i_state == HTTPD_CLIENT_SEND_DONE )
2156 {
2157 if( !cl->b_stream_mode || cl->answer.i_body_offset == 0 )
2158 {
2159 const char *psz_connection = httpd_MsgGet( &cl->answer, "Connection" );
2160 const char *psz_query = httpd_MsgGet( &cl->query, "Connection" );
2161 bool b_connection = false;
2162 bool b_keepalive = false;
2163 bool b_query = false;
2164
2165 cl->url = NULL;
2166 if( psz_connection )
2167 {
2168 b_connection = ( strcasecmp( psz_connection, "Close" ) == 0 );
2169 b_keepalive = ( strcasecmp( psz_connection, "Keep-Alive" ) == 0 );
2170 }
2171
2172 if( psz_query )
2173 {
2174 b_query = ( strcasecmp( psz_query, "Close" ) == 0 );
2175 }
2176
2177 if( ( ( cl->query.i_proto == HTTPD_PROTO_HTTP ) &&
2178 ( ( cl->query.i_version == 0 && b_keepalive ) ||
2179 ( cl->query.i_version == 1 && !b_connection ) ) ) ||
2180 ( ( cl->query.i_proto == HTTPD_PROTO_RTSP ) &&
2181 !b_query && !b_connection ) )
2182 {
2183 httpd_MsgClean( &cl->query );
2184 httpd_MsgInit( &cl->query );
2185
2186 cl->i_buffer = 0;
2187 cl->i_buffer_size = 1000;
2188 free( cl->p_buffer );
2189 cl->p_buffer = xmalloc( cl->i_buffer_size );
2190 cl->i_state = HTTPD_CLIENT_RECEIVING;
2191 }
2192 else
2193 {
2194 cl->i_state = HTTPD_CLIENT_DEAD;
2195 }
2196 httpd_MsgClean( &cl->answer );
2197 }
2198 else
2199 {
2200 int64_t i_offset = cl->answer.i_body_offset;
2201 httpd_MsgClean( &cl->answer );
2202
2203 cl->answer.i_body_offset = i_offset;
2204 free( cl->p_buffer );
2205 cl->p_buffer = NULL;
2206 cl->i_buffer = 0;
2207 cl->i_buffer_size = 0;
2208
2209 cl->i_state = HTTPD_CLIENT_WAITING;
2210 }
2211 }
2212 else if( cl->i_state == HTTPD_CLIENT_WAITING )
2213 {
2214 int64_t i_offset = cl->answer.i_body_offset;
2215 int i_msg = cl->query.i_type;
2216
2217 httpd_MsgInit( &cl->answer );
2218 cl->answer.i_body_offset = i_offset;
2219
2220 cl->url->catch[i_msg].cb( cl->url->catch[i_msg].p_sys, cl,
2221 &cl->answer, &cl->query );
2222 if( cl->answer.i_type != HTTPD_MSG_NONE )
2223 {
2224 /* we have new data, so re-enter send mode */
2225 cl->i_buffer = 0;
2226 cl->p_buffer = cl->answer.p_body;
2227 cl->i_buffer_size = cl->answer.i_body;
2228 cl->answer.p_body = NULL;
2229 cl->answer.i_body = 0;
2230 cl->i_state = HTTPD_CLIENT_SENDING;
2231 }
2232 }
2233
2234 if (pufd->events != 0)
2235 nfd++;
2236 else
2237 b_low_delay = true;
2238 }
2239 vlc_mutex_unlock( &host->lock );
2240 vlc_restorecancel( canc );
2241
2242 /* we will wait 20ms (not too big) if HTTPD_CLIENT_WAITING */
2243 int ret = poll( ufd, nfd, b_low_delay ? 20 : -1 );
2244
2245 canc = vlc_savecancel();
2246 vlc_mutex_lock( &host->lock );
2247 switch( ret )
2248 {
2249 case -1:
2250 if (errno != EINTR)
2251 {
2252 /* Kernel on low memory or a bug: pace */
2253 msg_Err( host, "polling error: %m" );
2254 msleep( 100000 );
2255 }
2256 case 0:
2257 continue;
2258 }
2259
2260 /* Handle client sockets */
2261 now = mdate();
2262 nfd = host->nfd;
2263
2264 for( int i_client = 0; i_client < host->i_client; i_client++ )
2265 {
2266 httpd_client_t *cl = host->client[i_client];
2267 const struct pollfd *pufd = &ufd[nfd];
2268
2269 assert( pufd < &ufd[sizeof(ufd) / sizeof(ufd[0])] );
2270
2271 if( cl->fd != pufd->fd )
2272 continue; // we were not waiting for this client
2273 ++nfd;
2274 if( pufd->revents == 0 )
2275 continue; // no event received
2276
2277 cl->i_activity_date = now;
2278
2279 if( cl->i_state == HTTPD_CLIENT_RECEIVING )
2280 {
2281 httpd_ClientRecv( cl );
2282 }
2283 else if( cl->i_state == HTTPD_CLIENT_SENDING )
2284 {
2285 httpd_ClientSend( cl );
2286 }
2287 else if( cl->i_state == HTTPD_CLIENT_TLS_HS_IN
2288 || cl->i_state == HTTPD_CLIENT_TLS_HS_OUT )
2289 {
2290 httpd_ClientTlsHandshake( cl );
2291 }
2292 }
2293
2294 /* Handle server sockets (accept new connections) */
2295 for( nfd = 0; nfd < host->nfd; nfd++ )
2296 {
2297 httpd_client_t *cl;
2298 int fd = ufd[nfd].fd;
2299
2300 assert (fd == host->fds[nfd]);
2301
2302 if( ufd[nfd].revents == 0 )
2303 continue;
2304
2305 /* */
2306 fd = vlc_accept (fd, NULL, NULL, true);
2307 if (fd == -1)
2308 continue;
2309 setsockopt (fd, SOL_SOCKET, SO_REUSEADDR,
2310 &(int){ 1 }, sizeof(int));
2311
2312 vlc_tls_t *p_tls;
2313
2314 if( host->p_tls != NULL )
2315 p_tls = vlc_tls_SessionCreate( host->p_tls, fd, NULL );
2316 else
2317 p_tls = NULL;
2318
2319 cl = httpd_ClientNew( fd, p_tls, now );
2320
2321 TAB_APPEND( host->i_client, host->client, cl );
2322 }
2323 }
2324 vlc_mutex_unlock( &host->lock );
2325 return NULL;
2326 }
Support playback for iNet-X and IENA over udp