* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
#include <vlc/vlc.h>
#ifdef ENABLE_HTTPD
typedef struct
{
- int i_code;
- const char *psz_reason;
+ unsigned i_code;
+ const char psz_reason[36];
} http_status_info;
static const http_status_info http_reason[] =
{
/*{ 100, "Continue" },
{ 101, "Switching Protocols" },*/
- { 200, "OK" }/*,
- { 201, "Created" },
+ { 200, "OK" },
+ /*{ 201, "Created" },
{ 202, "Accepted" },
- { 203, "Non-Authoritative Information" },
- { 204, "No Content" },
- { 205, "Reset Content" },
- { 206, "Partial Content" },
- { 250, "Low on Storage Space" },
- { 300, "Multiple Choices" }*/,
- { 301, "Moved permanently" }/*,
- { 302, "Moved Temporarily" }, - aka "Found"
- { 303, "See Other" },
- { 304, "Not Modified" },
- { 305, "Use Proxy" },
- { 307, "Temporary Redirect" },
- { 400, "Bad Request" }*/,
- { 401, "Unauthorized" }/*,
- { 402, "Payment Required" }*/,
+ { 203, "Non-authoritative information" },
+ { 204, "No content" },
+ { 205, "Reset content" },
+ { 206, "Partial content" },
+ { 250, "Low on storage space" },
+ { 300, "Multiple choices" },*/
+ { 301, "Moved permanently" },
+ /*{ 302, "Moved temporarily" },
+ { 303, "See other" },
+ { 304, "Not modified" },
+ { 305, "Use proxy" },
+ { 307, "Temporary redirect" },
+ { 400, "Bad request" },*/
+ { 401, "Unauthorized" },
+ /*{ 402, "Payment Required" },*/
{ 403, "Forbidden" },
- { 404, "Not found" }/*,
- { 405, "Method Not Allowed" },
- { 406, "Not Acceptable" },
- { 407, "Proxy Authentication Required" },
- { 408, "Request Time-out" },
+ { 404, "Not found" },
+ { 405, "Method not allowed" },
+ /*{ 406, "Not acceptable" },
+ { 407, "Proxy authentication required" },
+ { 408, "Request time-out" },
{ 409, "Conflict" },
{ 410, "Gone" },
- { 411, "Length Required" },
- { 412, "Precondition Failed" },
- { 413, "Request Entity Too Large" },
- { 414, "Request-URI Too Large" },
- { 415, "Unsupported Media Type" },
+ { 411, "Length required" },
+ { 412, "Precondition failed" },
+ { 413, "Request entity too large" },
+ { 414, "Request-URI too large" },
+ { 415, "Unsupported media Type" },
{ 416, "Requested range not satisfiable" },
- { 417, "Expectation Failed" },
- { 451, "Parameter Not Understood" },
- { 452, "Conference Not Found" },
- { 453, "Not Enough Bandwidth" }*/,
- { 454, "Session not found" }/*,
- { 455, "Method Not Valid in This State" },
- { 456, "Header Field Not Valid for Resource" },
- { 457, "Invalid Range" },
- { 458, "Parameter Is Read-Only" },
+ { 417, "Expectation failed" },
+ { 451, "Parameter not understood" },
+ { 452, "Conference not found" },
+ { 453, "Not enough bandwidth" },*/
+ { 454, "Session not found" },
+ /*{ 455, "Method not valid in this State" },*/
+ { 456, "Header field not valid for resource" },
+ /*{ 457, "Invalid range" },
+ { 458, "Read-only parameter" },*/
{ 459, "Aggregate operation not allowed" },
- { 460, "Only aggregate operation allowed" }*/,
- { 461, "Unsupported transport" }/*,
- { 462, "Destination unreachable" }*/,
+ { 460, "Non-aggregate operation not allowed" },
+ { 461, "Unsupported transport" },
+ /*{ 462, "Destination unreachable" },*/
{ 500, "Internal server error" },
- { 501, "Not implemented" }/*,
- { 502, "Bad gateway" }*/,
- { 503, "Service unavailable" }/*,
- { 504, "Gateway time-out" },
- { 505, "Protocol version not supported" }*/,
- { 0, NULL }
+ { 501, "Not implemented" },
+ /*{ 502, "Bad gateway" },*/
+ { 503, "Service unavailable" },
+ /*{ 504, "Gateway time-out" },*/
+ { 505, "Protocol version not supported" },
+ { 551, "Option not supported" },
+ { 999, "" }
};
-static const char *psz_fallback_reason[] =
-{ "Continue", "OK", "Found", "Client Error", "Server Error" };
+static const char psz_fallback_reason[5][16] =
+{ "Continue", "OK", "Found", "Client error", "Server error" };
-static const char *httpd_ReasonFromCode( int i_code )
+static const char *httpd_ReasonFromCode( unsigned i_code )
{
const http_status_info *p;
- for (p = http_reason; p->i_code < i_code; p++);
+ assert( ( i_code >= 100 ) && ( i_code <= 599 ) );
+
+ for (p = http_reason; i_code > p->i_code; p++);
if( p->i_code == i_code )
return p->psz_reason;
- assert( ( i_code >= 100 ) && ( i_code <= 599 ) );
return psz_fallback_reason[(i_code / 100) - 1];
}
};
-static int httpd_FileCallBack( httpd_callback_sys_t *p_sys, httpd_client_t *cl, httpd_message_t *answer, httpd_message_t *query )
+static int
+httpd_FileCallBack( httpd_callback_sys_t *p_sys, httpd_client_t *cl,
+ httpd_message_t *answer, const httpd_message_t *query )
{
httpd_file_t *file = (httpd_file_t*)p_sys;
uint8_t *psz_args = query->psz_args;
return VLC_SUCCESS;
}
answer->i_proto = HTTPD_PROTO_HTTP;
- answer->i_version= query->i_version;
+ answer->i_version= 1;
answer->i_type = HTTPD_MSG_ANSWER;
answer->i_status = 200;
psz_connection = httpd_MsgGet( &cl->query, "Connection" );
if( psz_connection != NULL )
{
- httpd_MsgAdd( answer, "Connection", psz_connection );
+ httpd_MsgAdd( answer, "Connection", "%s", psz_connection );
}
httpd_MsgAdd( answer, "Content-Length", "%d", answer->i_body );
return file;
}
-void httpd_FileDelete( httpd_file_t *file )
+httpd_file_sys_t *httpd_FileDelete( httpd_file_t *file )
{
+ httpd_file_sys_t *p_sys = file->p_sys;
+
httpd_UrlDelete( file->url );
free( file->psz_url );
free( file->psz_mime );
free( file );
+
+ return p_sys;
}
/*****************************************************************************
};
-static int httpd_HandlerCallBack( httpd_callback_sys_t *p_sys, httpd_client_t *cl, httpd_message_t *answer, httpd_message_t *query )
+static int
+httpd_HandlerCallBack( httpd_callback_sys_t *p_sys, httpd_client_t *cl,
+ httpd_message_t *answer, const httpd_message_t *query )
{
httpd_handler_t *handler = (httpd_handler_t*)p_sys;
uint8_t *psz_args = query->psz_args;
if( query->i_type == HTTPD_MSG_HEAD )
{
char *p = (char *)answer->p_body;
+
+ /* Looks for end of header (i.e. one empty line) */
while ( (p = strchr( p, '\r' )) != NULL )
{
if( p[1] && p[1] == '\n' && p[2] && p[2] == '\r'
break;
}
}
+
if( p != NULL )
{
p[4] = '\0';
return handler;
}
-void httpd_HandlerDelete( httpd_handler_t *handler )
+httpd_handler_sys_t *httpd_HandlerDelete( httpd_handler_t *handler )
{
+ httpd_handler_sys_t *p_sys = handler->p_sys;
httpd_UrlDelete( handler->url );
free( handler );
+ return p_sys;
}
/*****************************************************************************
static int httpd_RedirectCallBack( httpd_callback_sys_t *p_sys,
httpd_client_t *cl, httpd_message_t *answer,
- httpd_message_t *query )
+ const httpd_message_t *query )
{
httpd_redirect_t *rdir = (httpd_redirect_t*)p_sys;
char *p_body;
{
return VLC_SUCCESS;
}
- answer->i_proto = query->i_proto;
- answer->i_version= query->i_version;
+ answer->i_proto = HTTPD_PROTO_HTTP;
+ answer->i_version= 1;
answer->i_type = HTTPD_MSG_ANSWER;
answer->i_status = 301;
static int httpd_StreamCallBack( httpd_callback_sys_t *p_sys,
httpd_client_t *cl, httpd_message_t *answer,
- httpd_message_t *query )
+ const httpd_message_t *query )
{
httpd_stream_t *stream = (httpd_stream_t*)p_sys;
if (host == NULL)
goto error;
+ vlc_object_lock( host );
+ if( vlc_object_waitpipe( VLC_OBJECT( host ) ) == -1 )
+ {
+ msg_Err( host, "signaling pipe error: %m" );
+ vlc_object_unlock( host );
+ goto error;
+ }
+ vlc_object_unlock( host );
+
host->httpd = httpd;
vlc_mutex_init( httpd, &host->lock );
host->i_ref = 1;
httpd_url_t *url;
int i;
+ assert( psz_url != NULL );
+
vlc_mutex_lock( &host->lock );
if( b_check )
{
msg->cl = NULL;
msg->i_type = HTTPD_MSG_NONE;
msg->i_proto = HTTPD_PROTO_NONE;
- msg->i_version = -1;
+ msg->i_version = -1; /* FIXME */
msg->i_status = 0;
httpd_MsgInit( msg );
}
-const char *httpd_MsgGet( httpd_message_t *msg, const char *name )
+const char *httpd_MsgGet( const httpd_message_t *msg, const char *name )
{
int i;
return send( cl->fd, p, i_len, 0 );
}
+
+static const struct
+{
+ const char name[16];
+ int i_type;
+ int i_proto;
+}
+msg_type[] =
+{
+ { "OPTIONS", HTTPD_MSG_OPTIONS, HTTPD_PROTO_RTSP },
+ { "DESCRIBE", HTTPD_MSG_DESCRIBE, HTTPD_PROTO_RTSP },
+ { "SETUP", HTTPD_MSG_SETUP, HTTPD_PROTO_RTSP },
+ { "PLAY", HTTPD_MSG_PLAY, HTTPD_PROTO_RTSP },
+ { "PAUSE", HTTPD_MSG_PAUSE, HTTPD_PROTO_RTSP },
+ { "GET_PARAMETER", HTTPD_MSG_GETPARAMETER, HTTPD_PROTO_RTSP },
+ { "TEARDOWN", HTTPD_MSG_TEARDOWN, HTTPD_PROTO_RTSP },
+ { "GET", HTTPD_MSG_GET, HTTPD_PROTO_HTTP },
+ { "HEAD", HTTPD_MSG_HEAD, HTTPD_PROTO_HTTP },
+ { "POST", HTTPD_MSG_POST, HTTPD_PROTO_HTTP },
+ { "", HTTPD_MSG_NONE, HTTPD_PROTO_NONE }
+};
+
+
static void httpd_ClientRecv( httpd_client_t *cl )
{
int i_len;
+ /* ignore leading whites */
+ if( ( cl->query.i_proto == HTTPD_PROTO_NONE ) &&
+ ( cl->i_buffer == 0 ) )
+ {
+ unsigned char c;
+
+ i_len = httpd_NetRecv( cl, &c, 1 );
+
+ if( ( i_len > 0 ) && ( strchr( "\r\n\t ", c ) == NULL ) )
+ {
+ cl->p_buffer[0] = c;
+ cl->i_buffer++;
+ }
+ }
+ else
if( cl->query.i_proto == HTTPD_PROTO_NONE )
{
- /* enough to see if it's rtp over rtsp or RTSP/HTTP */
+ /* enough to see if it's Interleaved RTP over RTSP or RTSP/HTTP */
i_len = httpd_NetRecv( cl, &cl->p_buffer[cl->i_buffer],
- 4 - cl->i_buffer );
+ 7 - cl->i_buffer );
if( i_len > 0 )
{
cl->i_buffer += i_len;
}
- if( cl->i_buffer >= 4 )
+ if( ( cl->i_buffer >= 4 ) && ( cl->p_buffer[0] == '$' ) )
{
- /*fprintf( stderr, "peek=%4.4s\n", cl->p_buffer );*/
- /* detect type */
- if( cl->p_buffer[0] == '$' )
- {
- /* RTSP (rtp over rtsp) */
- cl->query.i_proto = HTTPD_PROTO_RTSP;
- cl->query.i_type = HTTPD_MSG_CHANNEL;
- cl->query.i_channel = cl->p_buffer[1];
- cl->query.i_body = (cl->p_buffer[2] << 8)|cl->p_buffer[3];
- cl->query.p_body = malloc( cl->query.i_body );
-
- cl->i_buffer = 0;
- }
- else if( !memcmp( cl->p_buffer, "HTTP", 4 ) )
+ /* Interleaved RTP over RTSP */
+ cl->query.i_proto = HTTPD_PROTO_RTSP;
+ cl->query.i_type = HTTPD_MSG_CHANNEL;
+ cl->query.i_channel = cl->p_buffer[1];
+ cl->query.i_body = (cl->p_buffer[2] << 8)|cl->p_buffer[3];
+ cl->query.p_body = malloc( cl->query.i_body );
+ cl->i_buffer -= 4;
+ memcpy( cl->query.p_body, cl->p_buffer + 4, cl->i_buffer );
+ }
+ else
+ /* The smallest legal request is 7 bytes ("GET /\r\n"),
+ * this is the maximum we can ask at this point. */
+ if( cl->i_buffer >= 7 )
+ {
+ if( !memcmp( cl->p_buffer, "HTTP/1.", 7 ) )
{
cl->query.i_proto = HTTPD_PROTO_HTTP;
cl->query.i_type = HTTPD_MSG_ANSWER;
}
- else if( !memcmp( cl->p_buffer, "RTSP", 4 ) )
+ else if( !memcmp( cl->p_buffer, "RTSP/1.", 7 ) )
{
cl->query.i_proto = HTTPD_PROTO_RTSP;
cl->query.i_type = HTTPD_MSG_ANSWER;
}
- else if( !memcmp( cl->p_buffer, "GET ", 4 ) ||
- !memcmp( cl->p_buffer, "HEAD", 4 ) ||
- !memcmp( cl->p_buffer, "POST", 4 ) )
- {
- cl->query.i_proto = HTTPD_PROTO_HTTP;
- cl->query.i_type = HTTPD_MSG_NONE;
- }
else
{
- cl->query.i_proto = HTTPD_PROTO_RTSP;
+ /* We need the full request line to determine the protocol. */
+ cl->query.i_proto = HTTPD_PROTO_HTTP0;
cl->query.i_type = HTTPD_MSG_NONE;
}
}
/* we are reading a header -> char by char */
for( ;; )
{
+ if( cl->i_buffer == cl->i_buffer_size )
+ {
+ uint8_t *newbuf = realloc( cl->p_buffer, cl->i_buffer_size + 1024 );
+ if( newbuf == NULL )
+ {
+ i_len = 0;
+ break;
+ }
+
+ cl->p_buffer = newbuf;
+ cl->i_buffer_size += 1024;
+ }
+
i_len = httpd_NetRecv (cl, &cl->p_buffer[cl->i_buffer], 1 );
if( i_len <= 0 )
{
}
cl->i_buffer++;
- if( cl->i_buffer + 1 >= cl->i_buffer_size )
+ if( ( cl->query.i_proto == HTTPD_PROTO_HTTP0 )
+ && ( cl->p_buffer[cl->i_buffer - 1] == '\n' ) )
{
- cl->i_buffer_size += 1024;
- cl->p_buffer = realloc( cl->p_buffer, cl->i_buffer_size );
+ /* Request line is now complete */
+ const char *p = memchr( cl->p_buffer, ' ', cl->i_buffer );
+ size_t len;
+
+ assert( cl->query.i_type == HTTPD_MSG_NONE );
+
+ if( p == NULL ) /* no URI: evil guy */
+ {
+ i_len = 0; /* drop connection */
+ break;
+ }
+
+ do
+ p++; /* skips extra spaces */
+ while( *p == ' ' );
+
+ p = memchr( p, ' ', ((char *)cl->p_buffer) + cl->i_buffer - p );
+ if( p == NULL ) /* no explicit protocol: HTTP/0.9 */
+ {
+ i_len = 0; /* not supported currently -> drop */
+ break;
+ }
+
+ do
+ p++; /* skips extra spaces ever again */
+ while( *p == ' ' );
+
+ len = ((char *)cl->p_buffer) + cl->i_buffer - p;
+ if( len < 7 ) /* foreign protocol */
+ i_len = 0; /* I don't understand -> drop */
+ else
+ if( memcmp( p, "HTTP/1.", 7 ) == 0 )
+ {
+ cl->query.i_proto = HTTPD_PROTO_HTTP;
+ cl->query.i_version = atoi( p + 7 );
+ }
+ else
+ if( memcmp( p, "RTSP/1.", 7 ) == 0 )
+ {
+ cl->query.i_proto = HTTPD_PROTO_RTSP;
+ cl->query.i_version = atoi( p + 7 );
+ }
+ else
+ if( memcmp( p, "HTTP/", 5 ) == 0 )
+ {
+ const uint8_t sorry[] =
+ "HTTP/1.1 505 Unknown HTTP version\r\n\r\n";
+ httpd_NetSend( cl, sorry, sizeof( sorry ) - 1 );
+ i_len = 0; /* drop */
+ }
+ else
+ if( memcmp( p, "RTSP/", 5 ) == 0 )
+ {
+ const uint8_t sorry[] =
+ "RTSP/1.0 505 Unknown RTSP version\r\n\r\n";
+ httpd_NetSend( cl, sorry, sizeof( sorry ) - 1 );
+ i_len = 0; /* drop */
+ }
+ else /* yet another foreign protocol */
+ i_len = 0;
+
+ if( i_len == 0 )
+ break;
}
+
if( ( cl->i_buffer >= 2 && !memcmp( &cl->p_buffer[cl->i_buffer-2], "\n\n", 2 ) )||
( cl->i_buffer >= 4 && !memcmp( &cl->p_buffer[cl->i_buffer-4], "\r\n\r\n", 4 ) ) )
{
}
else
{
- static const struct
- {
- const char name[16];
- int i_type;
- int i_proto;
- }
- msg_type[] =
- {
- { "OPTIONS", HTTPD_MSG_OPTIONS, HTTPD_PROTO_RTSP },
- { "DESCRIBE", HTTPD_MSG_DESCRIBE, HTTPD_PROTO_RTSP },
- { "SETUP", HTTPD_MSG_SETUP, HTTPD_PROTO_RTSP },
- { "PLAY", HTTPD_MSG_PLAY, HTTPD_PROTO_RTSP },
- { "PAUSE", HTTPD_MSG_PAUSE, HTTPD_PROTO_RTSP },
- { "GET_PARAMETER", HTTPD_MSG_GETPARAMETER, HTTPD_PROTO_RTSP },
- { "TEARDOWN", HTTPD_MSG_TEARDOWN, HTTPD_PROTO_RTSP },
-
- { "GET", HTTPD_MSG_GET, HTTPD_PROTO_HTTP },
- { "HEAD", HTTPD_MSG_HEAD, HTTPD_PROTO_HTTP },
- { "POST", HTTPD_MSG_POST, HTTPD_PROTO_HTTP },
-
- { "", HTTPD_MSG_NONE, HTTPD_PROTO_NONE }
- };
unsigned i;
p = NULL;
if( !strncmp( (char *)cl->p_buffer, msg_type[i].name,
strlen( msg_type[i].name ) ) )
{
- p = (char *)&cl->p_buffer[strlen((char *)msg_type[i].name) + 1 ];
+ p = (char *)&cl->p_buffer[strlen(msg_type[i].name) + 1 ];
cl->query.i_type = msg_type[i].i_type;
if( cl->query.i_proto != msg_type[i].i_proto )
{
*p3++ = '\0';
cl->query.psz_args = (uint8_t *)strdup( p3 );
}
- if( p2 )
- {
- while( *p2 == ' ' )
- {
- p2++;
- }
- if( !strncasecmp( p2, "HTTP/1.", 7 ) )
- {
- cl->query.i_proto = HTTPD_PROTO_HTTP;
- cl->query.i_version = atoi( p2+7 );
- }
- else if( !strncasecmp( p2, "RTSP/1.", 7 ) )
- {
- cl->query.i_proto = HTTPD_PROTO_RTSP;
- cl->query.i_version = atoi( p2+7 );
- }
- }
p = p2;
}
}
}
if( cl->query.i_body > 0 )
{
- /* TODO Mhh, handle the case client will only send a request and close the connection
+ /* TODO Mhh, handle the case client will only send a
+ * request and close the connection
* to mark and of body (probably only RTSP) */
cl->query.p_body = malloc( cl->query.i_body );
cl->i_buffer = 0;
}
p = (char *)cl->p_buffer;
- p += sprintf( p, "%s/1.%d %d %s\r\n",
- cl->answer.i_proto == HTTPD_PROTO_HTTP ? "HTTP" : "RTSP",
+ p += sprintf( p, "%s.%u %d %s\r\n",
+ cl->answer.i_proto == HTTPD_PROTO_HTTP ? "HTTP/1" : "RTSP/1",
cl->answer.i_version,
cl->answer.i_status, psz_status );
for( i = 0; i < cl->answer.i_name; i++ )
tls_session_t *p_tls = NULL;
counter_t *p_total_counter = stats_CounterCreate( host, VLC_VAR_INTEGER, STATS_COUNTER );
counter_t *p_active_counter = stats_CounterCreate( host, VLC_VAR_INTEGER, STATS_COUNTER );
+ int evfd;
+ vlc_bool_t b_die;
+
+ vlc_object_lock( host );
+ evfd = vlc_object_waitpipe( VLC_OBJECT( host ) );
+ b_die = !vlc_object_alive( host );
+ vlc_object_unlock( host );
- while( !host->b_die )
+ while( !b_die )
{
if( host->i_url <= 0 )
{
- /* 0.2s */
+ /* 0.2s (FIXME: use a condition variable) */
msleep( 200000 );
continue;
}
if( ( p_tls == NULL ) && ( host->p_tls != NULL ) )
p_tls = tls_ServerSessionPrepare( host->p_tls );
- struct pollfd ufd[host->nfd + host->i_client];
+ struct pollfd ufd[host->nfd + host->i_client + 1];
unsigned nfd;
for( nfd = 0; nfd < host->nfd; nfd++ )
{
}
else if( i_msg == HTTPD_MSG_OPTIONS )
{
- const char *psz_cseq;
- int i_cseq;
- /* unimplemented */
- answer->i_proto = query->i_proto ;
answer->i_type = HTTPD_MSG_ANSWER;
- answer->i_version= 0;
+ answer->i_proto = query->i_proto;
answer->i_status = 200;
-
answer->i_body = 0;
answer->p_body = NULL;
- psz_cseq = httpd_MsgGet( query, "Cseq" );
- if( psz_cseq )
- i_cseq = atoi( psz_cseq );
- else
- i_cseq = 0;
- httpd_MsgAdd( answer, "Cseq", "%d", i_cseq );
- httpd_MsgAdd( answer, "Server", "VLC Server" );
- httpd_MsgAdd( answer, "Public", "DESCRIBE, SETUP, "
- "TEARDOWN, PLAY, PAUSE" );
- httpd_MsgAdd( answer, "Content-Length", "%d",
- answer->i_body );
+ httpd_MsgAdd( answer, "Server", "%s", PACKAGE_STRING );
+ httpd_MsgAdd( answer, "Content-Length", "0" );
+
+ switch( query->i_proto )
+ {
+ case HTTPD_PROTO_HTTP:
+ answer->i_version = 1;
+ httpd_MsgAdd( answer, "Allow",
+ "GET,HEAD,POST,OPTIONS" );
+ break;
+
+ case HTTPD_PROTO_RTSP:
+ {
+ const char *p;
+ answer->i_version = 0;
+
+ p = httpd_MsgGet( query, "Cseq" );
+ if( p != NULL )
+ httpd_MsgAdd( answer, "Cseq", "%s", p );
+ p = httpd_MsgGet( query, "Timestamp" );
+ if( p != NULL )
+ httpd_MsgAdd( answer, "Timestamp", "%s", p );
+
+ p = httpd_MsgGet( query, "Require" );
+ if( p != NULL )
+ {
+ answer->i_status = 551;
+ httpd_MsgAdd( query, "Unsupported", "%s", p );
+ }
+
+ httpd_MsgAdd( answer, "Public", "DESCRIBE,SETUP,"
+ "TEARDOWN,PLAY,PAUSE,GET_PARAMETER" );
+ break;
+ }
+ }
cl->i_buffer = -1; /* Force the creation of the answer in
* httpd_ClientSend */
cl->answer.i_body = 0;
cl->i_state = HTTPD_CLIENT_SENDING;
}
- else
- {
- /* we shouldn't wait too long */
- b_low_delay = VLC_TRUE;
- }
}
/* Special for BIDIR mode we also check reading */
if (pufd->events != 0)
nfd++;
+ else
+ b_low_delay = VLC_TRUE;
}
vlc_mutex_unlock( &host->lock );
- /* we will wait 100ms or 20ms (not too big 'cause HTTPD_CLIENT_WAITING) */
- switch( poll( ufd, nfd, b_low_delay ? 20 : 100) )
+ ufd[nfd].fd = evfd;
+ ufd[nfd].events = POLLIN;
+ ufd[nfd].revents = 0;
+ nfd++;
+
+ /* we will wait 20ms (not too big) if HTTPD_CLIENT_WAITING */
+ switch( poll( ufd, nfd, b_low_delay ? 20 : -1) )
{
case -1:
if (errno != EINTR)
{
- /* This is most likely a bug */
- msg_Err( host, "polling error: %s", strerror (errno));
- msleep( 1000 );
+ /* Kernel on low memory or a bug: pace */
+ msg_Err( host, "polling error: %m" );
+ msleep( 100000 );
}
case 0:
continue;
}
+ vlc_object_lock( host );
+ if( ufd[nfd - 1].revents )
+ b_die = vlc_object_wait( host );
+ vlc_object_unlock( host );
+
/* Handle client sockets */
vlc_mutex_lock( &host->lock );
now = mdate();
{
httpd_client_t *cl;
int i_state = -1;
+ int fd = ufd[nfd].fd;
- assert (ufd[nfd].fd == host->fds[nfd]);
+ assert (fd == host->fds[nfd]);
if( ufd[nfd].revents == 0 )
continue;
/* */
- int kludge[] = { ufd[nfd].fd, -1 };
- int fd = net_Accept( host, kludge, 0 );
- if( fd < 0 )
+ fd = accept (fd, NULL, NULL);
+ if (fd == -1)
continue;
+ net_SetupSocket (fd);
if( p_tls != NULL )
{
switch( tls_ServerSessionHandshake( p_tls, fd ) )