# include "config.h"
#endif
-#include <vlc/vlc.h>
+#include <vlc_common.h>
#include <vlc_httpd.h>
#ifdef ENABLE_HTTPD
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;
uint8_t **pp_body, *p_body;
const char *psz_connection;
int *pi_body, i_body;
/* msg_Warn not supported */
}
+ uint8_t *psz_args = query->psz_args;
file->pf_fill( file->p_sys, file, psz_args, pp_body, pi_body );
if( query->i_type == HTTPD_MSG_HEAD && p_body != NULL )
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;
char psz_remote_addr[NI_MAXNUMERICHOST];
if( answer == NULL || query == NULL )
if( httpd_ClientIP( cl, psz_remote_addr ) == NULL )
*psz_remote_addr = '\0';
+ uint8_t *psz_args = query->psz_args;
handler->pf_fill( handler->p_sys, handler, query->psz_url, psz_args,
query->i_type, query->p_body, query->i_body,
psz_remote_addr, NULL,
if( !strcmp( stream->psz_mime, "video/x-ms-asf-stream" ) )
{
- vlc_bool_t b_xplaystream = VLC_FALSE;
+ bool b_xplaystream = false;
int i;
httpd_MsgAdd( answer, "Content-type", "%s",
if( !strcasecmp( query->name[i], "Pragma" ) &&
strstr( query->value[i], "xPlayStrm=1" ) )
{
- b_xplaystream = VLC_TRUE;
+ b_xplaystream = true;
}
}
free( stream );
return NULL;
}
- vlc_mutex_init( host, &stream->lock );
+ vlc_mutex_init( &stream->lock );
if( psz_mime && *psz_mime )
{
stream->psz_mime = strdup( psz_mime );
psz_host = strdup( psz_hostname );
if( psz_host == NULL )
- {
- msg_Err( p_this, "memory error" );
return NULL;
- }
/* to be sure to avoid multiple creation */
var_Create( p_this->p_libvlc, "httpd_mutex", VLC_VAR_MUTEX );
- var_Create( p_this->p_libvlc, "httpd_object", VLC_VAR_ADDRESS );
var_Get( p_this->p_libvlc, "httpd_mutex", &lockval );
vlc_mutex_lock( lockval.p_address );
- var_Get( p_this->p_libvlc, "httpd_object", &ptrval );
+ httpd = libvlc_priv (p_this->p_libvlc)->p_httpd;
- if( ptrval.p_address != NULL )
- httpd = ptrval.p_address;
- else
+ if( httpd == NULL )
{
msg_Info( p_this, "creating httpd" );
httpd = (httpd_t *)vlc_custom_create( p_this, sizeof (*httpd),
httpd->host = NULL;
ptrval.p_address = httpd;
- var_Set( p_this->p_libvlc, "httpd_object", ptrval );
+ libvlc_priv (p_this->p_libvlc)->p_httpd = httpd;
vlc_object_yield( httpd );
vlc_object_attach( httpd, p_this->p_libvlc );
}
/* create the new host */
host = (httpd_host_t *)vlc_custom_create( p_this, sizeof (*host),
- VLC_OBJECT_HTTPD_HOST,
+ VLC_OBJECT_GENERIC,
psz_object_type );
if (host == NULL)
goto error;
vlc_object_unlock( host );
host->httpd = httpd;
- vlc_mutex_init( httpd, &host->lock );
+ vlc_mutex_init( &host->lock );
host->i_ref = 1;
host->fds = net_ListenTCP( p_this, psz_host, i_port );
/* create the thread */
if( vlc_thread_create( host, "httpd host thread", httpd_HostThread,
- VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) )
+ VLC_THREAD_PRIORITY_LOW, false ) )
{
msg_Err( p_this, "cannot spawn http host thread" );
goto error;
vlc_object_release( httpd );
if( httpd->i_host <= 0 )
{
- vlc_value_t ptrval;
-
msg_Dbg( httpd, "no host left, stopping httpd" );
- ptrval.p_address = NULL;
- var_Set( httpd->p_libvlc, "httpd_object", ptrval );
+ libvlc_priv (httpd->p_libvlc)->p_httpd = NULL;
vlc_object_detach( httpd );
vlc_object_release( httpd );
/* register a new url */
static httpd_url_t *httpd_UrlNewPrivate( httpd_host_t *host, const char *psz_url,
const char *psz_user, const char *psz_password,
- const vlc_acl_t *p_acl, vlc_bool_t b_check )
+ const vlc_acl_t *p_acl, bool b_check )
{
httpd_url_t *url;
int i;
url = malloc( sizeof( httpd_url_t ) );
url->host = host;
- vlc_mutex_init( host->httpd, &url->lock );
+ vlc_mutex_init( &url->lock );
url->psz_url = strdup( psz_url );
url->psz_user = strdup( psz_user ? psz_user : "" );
url->psz_password = strdup( psz_password ? psz_password : "" );
const vlc_acl_t *p_acl )
{
return httpd_UrlNewPrivate( host, psz_url, psz_user,
- psz_password, p_acl, VLC_FALSE );
+ psz_password, p_acl, false );
}
httpd_url_t *httpd_UrlNewUnique( httpd_host_t *host, const char *psz_url,
const vlc_acl_t *p_acl )
{
return httpd_UrlNewPrivate( host, psz_url, psz_user,
- psz_password, p_acl, VLC_TRUE );
+ psz_password, p_acl, true );
}
/* register callback on a url */
{
cl->i_state = HTTPD_CLIENT_RECEIVING;
cl->i_activity_date = now;
- cl->i_activity_timeout = I64C(10000000);
+ cl->i_activity_timeout = INT64_C(10000000);
cl->i_buffer_size = HTTPD_CL_BUFSIZE;
cl->i_buffer = 0;
cl->p_buffer = malloc( cl->i_buffer_size );
cl->i_mode = HTTPD_CLIENT_FILE;
- cl->b_read_waiting = VLC_FALSE;
+ cl->b_read_waiting = false;
httpd_MsgInit( &cl->query );
httpd_MsgInit( &cl->answer );
return cl;
}
-static int httpd_NetRecv( httpd_client_t *cl, uint8_t *p, int i_len )
+static
+ssize_t httpd_NetRecv (httpd_client_t *cl, uint8_t *p, size_t i_len)
{
tls_session_t *p_tls;
+ ssize_t val;
p_tls = cl->p_tls;
- if( p_tls != NULL)
- return tls_Recv( p_tls, p, i_len );
-
- return recv( cl->fd, p, i_len, 0 );
+ do
+ val = p_tls ? tls_Recv (p_tls, p, i_len)
+ : recv (cl->fd, p, i_len, 0);
+ while (val == -1 && errno == EINTR);
+ return val;
}
-static int httpd_NetSend( httpd_client_t *cl, const uint8_t *p, int i_len )
+static
+ssize_t httpd_NetSend (httpd_client_t *cl, const uint8_t *p, size_t i_len)
{
tls_session_t *p_tls;
+ ssize_t val;
p_tls = cl->p_tls;
- if( p_tls != NULL)
- return tls_Send( p_tls, p, i_len );
-
- return send( cl->fd, p, i_len, 0 );
+ do
+ val = p_tls ? tls_Send( p_tls, p, i_len )
+ : send (cl->fd, p, i_len, 0);
+ while (val == -1 && errno == EINTR);
+ return val;
}
#if defined( WIN32 ) || defined( UNDER_CE )
if( ( i_len < 0 && WSAGetLastError() != WSAEWOULDBLOCK ) || ( i_len == 0 ) )
#else
- if( ( i_len < 0 && errno != EAGAIN && errno != EINTR ) || ( i_len == 0 ) )
+ if( ( i_len < 0 && errno != EAGAIN ) || ( i_len == 0 ) )
#endif
{
if( cl->query.i_proto != HTTPD_PROTO_NONE && cl->query.i_type != HTTPD_MSG_NONE )
#if defined( WIN32 ) || defined( UNDER_CE )
if( ( i_len < 0 && WSAGetLastError() != WSAEWOULDBLOCK ) || ( i_len == 0 ) )
#else
- if( ( i_len < 0 && errno != EAGAIN && errno != EINTR ) || ( i_len == 0 ) )
+ if( ( i_len < 0 && errno != EAGAIN ) || ( i_len == 0 ) )
#endif
{
/* error */
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;
+ bool b_die;
+retry:
vlc_object_lock( host );
evfd = vlc_object_waitpipe( VLC_OBJECT( host ) );
b_die = !vlc_object_alive( host );
{
/* 0.2s (FIXME: use a condition variable) */
msleep( 200000 );
- continue;
+ goto retry;
}
/* prepare a new TLS session */
/* add all socket that should be read/write and close dead connection */
vlc_mutex_lock( &host->lock );
mtime_t now = mdate();
- vlc_bool_t b_low_delay = VLC_FALSE;
+ bool b_low_delay = false;
for(int i_client = 0; i_client < host->i_client; i_client++ )
{
}
else
{
- vlc_bool_t b_auth_failed = VLC_FALSE;
- vlc_bool_t b_hosts_failed = VLC_FALSE;
+ bool b_auth_failed = false;
+ bool b_hosts_failed = false;
/* Search the url and trigger callbacks */
for(int i = 0; i < host->i_url; i++ )
if( ( httpd_ClientIP( cl, ip ) == NULL )
|| ACL_Check( url->p_acl, ip ) )
{
- b_hosts_failed = VLC_TRUE;
+ b_hosts_failed = true;
break;
}
}
"Basic realm=\"%s\"",
url->psz_user );
/* We fail for all url */
- b_auth_failed = VLC_TRUE;
+ b_auth_failed = true;
free( user );
break;
}
{
const char *psz_connection = httpd_MsgGet( &cl->answer, "Connection" );
const char *psz_query = httpd_MsgGet( &cl->query, "Connection" );
- vlc_bool_t b_connection = VLC_FALSE;
- vlc_bool_t b_keepalive = VLC_FALSE;
- vlc_bool_t b_query = VLC_FALSE;
+ bool b_connection = false;
+ bool b_keepalive = false;
+ bool b_query = false;
cl->url = NULL;
if( psz_connection )
free( cl->p_buffer );
cl->p_buffer = malloc( cl->i_buffer_size );
cl->i_state = HTTPD_CLIENT_RECEIVING;
- cl->b_read_waiting = VLC_FALSE;
+ cl->b_read_waiting = false;
}
else
{
if (pufd->events != 0)
nfd++;
else
- b_low_delay = VLC_TRUE;
+ b_low_delay = true;
}
vlc_mutex_unlock( &host->lock );
vlc_object_lock( host );
if( ufd[nfd - 1].revents )
- b_die = vlc_object_wait( host );
+ {
+ b_die = !vlc_object_alive( host );
+ if( !b_die )
+ vlc_object_wait( host );
+ }
vlc_object_unlock( host );
/* Handle client sockets */
cl->i_state == HTTPD_CLIENT_SENDING &&
(pufd->revents & POLLIN) )
{
- cl->b_read_waiting = VLC_TRUE;
+ cl->b_read_waiting = true;
}
}
vlc_mutex_unlock( &host->lock );