static client_t *accept_client (void)
{
client_t *client = NULL;
sock_t sock, serversock = wait_for_serversock ();
char addr [200];
if (serversock == SOCK_ERROR)
return NULL;
sock = sock_accept (serversock, addr, 200);
if (sock == SOCK_ERROR)
{
if (sock_recoverable (sock_error()))
return NULL;
WARN2 ("accept() failed with error %d: %s", sock_error(), strerror(sock_error()));
thread_sleep (500000);
return NULL;
}
do
{
int i, num;
refbuf_t *r;
if (sock_set_blocking (sock, 0) || sock_set_nodelay (sock))
{
WARN0 ("failed to set tcp options on client connection, dropping");
break;
}
client = calloc (1, sizeof (client_t));
if (client == NULL || connection_init (&client->connection, sock, addr) < 0)
break;
client->shared_data = r = refbuf_new (PER_CLIENT_REFBUF_SIZE);
r->len = 0; // for building up the request coming in
global_lock ();
client_register (client);
for (i=0; i < global.server_sockets; i++)
{
if (global.serversock[i] == serversock)
{
client->server_conn = global.server_conn[i];
client->server_conn->refcount++;
if (client->server_conn->ssl && ssl_ok)
connection_uses_ssl (&client->connection);
if (client->server_conn->shoutcast_compat)
client->ops = &shoutcast_source_ops;
else
client->ops = &http_request_ops;
break;
}
}
num = global.clients;
global_unlock ();
stats_event_args (NULL, "clients", "%d", num);
client->flags |= CLIENT_ACTIVE;
return client;
} while (0);
free (client);
sock_close (sock);
return NULL;
}
/* we don't need to clean up on err, as we'll go through the node struct and clean all we have inside */
static int _connection_process (connection_queue_t *node) {
refbuf_t *header;
http_parser_t *parser = NULL;
int hdrsize = 0;
int shoutcast = 0;
int err;
char *shoutcast_mount = NULL;
mount_proxy *mountinfo;
ice_config_t *config;
listener_t *listener;
if (!node->refbuf)
node->refbuf = refbuf_new (PER_CLIENT_REFBUF_SIZE);
header = node->refbuf;
{ /* this code tests for shoutcastness */
config = config_get_config();
listener = config_get_listen_sock (config, node->con);
if (listener) {
WARN("listner");
if (listener->shoutcast_compat)
shoutcast = 1;
if (listener->ssl && ssl_ok)
connection_uses_ssl (node->con);
if (listener->shoutcast_mount) {
shoutcast_mount = strdup (listener->shoutcast_mount);
} else {
shoutcast_mount = config->shoutcast_mount;
}
}
WARN("shoutcast %d, mount %s", shoutcast, shoutcast_mount);
mountinfo = config_find_mount (config, shoutcast_mount);
config_release_config();
}
if (shoutcast && !header->sync_point) { /* stage2 is actually handled by generic code */
err = _handle_shoutcast_stage1 (node, shoutcast_mount, mountinfo);
if (err < 0)
return err;
}
hdrsize = util_read_header (node->con, header, HEADER_READ_ENTIRE);
if (hdrsize < 0)
{
ERROR ("Header read failed");
return hdrsize;
}
/* process normal HTTP headers */
if (node->parser) {
parser = node->parser;
} else {
parser = node->parser = httpp_create_parser();
httpp_initialize(parser, NULL);
}
err = httpp_parse (parser, header->data, hdrsize);
if (err == 0) {
ERROR0("HTTP request parsing failed");
return -EINVAL;
}
/* XXX what happens when error in http ??? is err set ? */
if (httpp_getvar (parser, HTTPP_VAR_ERROR_MESSAGE)) {
ERROR("Error(%s)", httpp_getvar(parser, HTTPP_VAR_ERROR_MESSAGE));
return err;
}
if (header->sync_point && (parser->req_type == httpp_req_source ||
parser->req_type == httpp_req_post)) {
hdrsize = util_read_header (node->con, header, HEADER_READ_ENTIRE);
if (hdrsize < 0) {
INFO ("Header read failed");
return hdrsize;
}
}
if (! node->client) {
err = connection_client_setup (node);
if (err < 0)
return err;
header->len -= hdrsize;
if (header->len) {
memmove(header->data, header->data + hdrsize, header->len);
client_set_queue (node->client, header);
}
refbuf_release(header);
}
stats_event_inc (NULL, "connections");
WARN("shoutcast = %d", shoutcast);
return _handle_client (node->client);
}
void connection_accept_loop (void)
{
connection_t *con;
ice_config_t *config;
int duration = 300;
config = config_get_config ();
get_ssl_certificate (config);
config_release_config ();
while (global.running == ICE_RUNNING)
{
con = _accept_connection (duration);
if (con)
{
client_queue_t *node;
ice_config_t *config;
client_t *client = NULL;
listener_t *listener;
global_lock();
if (client_create (&client, con, NULL) < 0)
{
global_unlock();
client_send_403 (client, "Icecast connection limit reached");
/* don't be too eager as this is an imposed hard limit */
thread_sleep (400000);
continue;
}
/* setup client for reading incoming http */
client->refbuf->data [PER_CLIENT_REFBUF_SIZE-1] = '\000';
if (sock_set_blocking (client->con->sock, 0) || sock_set_nodelay (client->con->sock))
{
global_unlock();
WARN0 ("failed to set tcp options on client connection, dropping");
client_destroy (client);
continue;
}
node = calloc (1, sizeof (client_queue_t));
if (node == NULL)
{
global_unlock();
client_destroy (client);
continue;
}
node->client = client;
config = config_get_config();
listener = config_get_listen_sock (config, client->con);
if (listener)
{
if (listener->shoutcast_compat)
node->shoutcast = 1;
if (listener->ssl && ssl_ok)
connection_uses_ssl (client->con);
if (listener->shoutcast_mount)
node->shoutcast_mount = strdup (listener->shoutcast_mount);
}
global_unlock();
config_release_config();
_add_request_queue (node);
stats_event_inc (NULL, "connections");
duration = 5;
}
else
{
if (_req_queue == NULL)
duration = 300; /* use longer timeouts when nothing waiting */
}
process_request_queue ();
}
/* Give all the other threads notification to shut down */
thread_cond_broadcast(&global.shutdown_cond);
/* wait for all the sources to shutdown */
thread_rwlock_wlock(&_source_shutdown_rwlock);
thread_rwlock_unlock(&_source_shutdown_rwlock);
}
void connection_accept_loop(void)
{
connection_t *con;
ice_config_t *config;
config = config_get_config ();
get_ssl_certificate (config);
config_release_config ();
tid = thread_create ("connection thread", _handle_connection, NULL, THREAD_ATTACHED);
while (global.running == ICE_RUNNING)
{
con = _accept_connection();
if (con)
{
client_queue_t *node;
ice_config_t *config;
client_t *client = NULL;
listener_t *listener;
global_lock();
if (client_create (&client, con, NULL) < 0)
{
global_unlock();
client_send_403 (client, "Icecast connection limit reached");
/* don't be too eager as this is an imposed hard limit */
thread_sleep (400000);
continue;
}
global_unlock();
/* setup client for reading incoming http */
client->refbuf->data [PER_CLIENT_REFBUF_SIZE-1] = '\000';
node = calloc (1, sizeof (client_queue_t));
if (node == NULL)
{
client_destroy (client);
continue;
}
node->client = client;
config = config_get_config();
listener = config_get_listen_sock (config, client->con);
if (listener)
{
if (listener->shoutcast_compat)
node->shoutcast = 1;
if (listener->ssl && ssl_ok)
connection_uses_ssl (client->con);
if (listener->shoutcast_mount)
node->shoutcast_mount = strdup (listener->shoutcast_mount);
}
config_release_config();
sock_set_blocking (client->con->sock, SOCK_NONBLOCK);
sock_set_nodelay (client->con->sock);
_add_request_queue (node);
stats_event_inc (NULL, "connections");
}
process_request_queue ();
}
/* Give all the other threads notification to shut down */
thread_cond_broadcast(&global.shutdown_cond);
if (tid)
thread_join (tid);
/* wait for all the sources to shutdown */
thread_rwlock_wlock(&_source_shutdown_rwlock);
thread_rwlock_unlock(&_source_shutdown_rwlock);
}
