void event_config_read (void)
{
int ret;
ice_config_t *config;
ice_config_t new_config, old_config;
/* reread config file */
INFO0("Re-reading XML");
config = config_grab_config(); /* Both to get the lock, and to be able
to find out the config filename */
xmlSetGenericErrorFunc (config->config_filename, log_parse_failure);
xmlSetStructuredErrorFunc ("conf/file", config_xml_parse_failure);
ret = config_parse_file(config->config_filename, &new_config);
if(ret < 0) {
ERROR0("Error parsing config, not replacing existing config");
switch(ret) {
case CONFIG_EINSANE:
ERROR0("Config filename null or blank");
break;
case CONFIG_ENOROOT:
ERROR1("Root element not found in %s", config->config_filename);
break;
case CONFIG_EBADROOT:
ERROR1("Not an icecast2 config file: %s",
config->config_filename);
break;
default:
ERROR1("Parse error in reading %s", config->config_filename);
break;
}
config_release_config();
}
else {
restart_logging (&new_config);
config_set_config (&new_config, &old_config);
config_release_config();
connection_thread_shutdown();
redirector_clearall();
fserve_scan ((time_t)0);
config = config_get_config();
yp_recheck_config (config);
fserve_recheck_mime_types (config);
stats_global (config);
workers_adjust (config->workers_count);
connection_listen_sockets_close (config, 0);
redirector_setup (config);
update_relays (config);
config_release_config();
slave_restart();
config_clear (&old_config);
}
}
static sock_t wait_for_serversock (void)
{
#ifdef HAVE_POLL
int i, ret;
struct pollfd ufds [global.server_sockets + 1];
for(i=0; i < global.server_sockets; i++) {
ufds[i].fd = global.serversock[i];
ufds[i].events = POLLIN;
ufds[i].revents = 0;
}
#ifdef HAVE_SIGNALFD
ufds[i].revents = 0;
if (sigfd >= 0)
{
ufds[i].fd = sigfd;
ufds[i].events = POLLIN;
ret = poll(ufds, i+1, 4000);
}
else
ret = poll(ufds, i, 4000);
#else
ret = poll(ufds, global.server_sockets, 333);
#endif
if (ret <= 0)
return SOCK_ERROR;
else {
int dst;
#ifdef HAVE_SIGNALFD
if (ufds[i].revents & POLLIN)
{
struct signalfd_siginfo fdsi;
int ret = read (sigfd, &fdsi, sizeof(struct signalfd_siginfo));
if (ret == sizeof(struct signalfd_siginfo))
{
switch (fdsi.ssi_signo)
{
case SIGINT:
case SIGTERM:
DEBUG0 ("signalfd received a termination");
global.running = ICE_HALTING;
connection_running = 0;
break;
case SIGHUP:
INFO0 ("HUP received, reread scheduled");
global.schedule_config_reread = 1;
break;
default:
WARN1 ("unexpected signal (%d)", fdsi.ssi_signo);
}
}
}
if (ufds[i].revents & (POLLNVAL|POLLERR))
{
ERROR0 ("signalfd descriptor became invalid, doing thread restart");
slave_restart(); // something odd happened
}
#endif
for(i=0; i < global.server_sockets; i++) {
if(ufds[i].revents & POLLIN)
return ufds[i].fd;
if(ufds[i].revents & (POLLHUP|POLLERR|POLLNVAL))
{
if (ufds[i].revents & (POLLHUP|POLLERR))
{
sock_close (global.serversock[i]);
WARN0("Had to close a listening socket");
}
global.serversock[i] = SOCK_ERROR;
}
}
/* remove any closed sockets */
for(i=0, dst=0; i < global.server_sockets; i++)
{
if (global.serversock[i] == SOCK_ERROR)
continue;
if (i!=dst)
global.serversock[dst] = global.serversock[i];
dst++;
}
global.server_sockets = dst;
return SOCK_ERROR;
}
#else
fd_set rfds;
struct timeval tv;
int i, ret;
sock_t max = SOCK_ERROR;
FD_ZERO(&rfds);
for(i=0; i < global.server_sockets; i++) {
FD_SET(global.serversock[i], &rfds);
if (max == SOCK_ERROR || global.serversock[i] > max)
max = global.serversock[i];
}
tv.tv_sec = 0;
tv.tv_usec = 333000;
ret = select(max+1, &rfds, NULL, NULL, &tv);
if(ret < 0) {
return SOCK_ERROR;
}
else if(ret == 0) {
return SOCK_ERROR;
}
else {
for(i=0; i < global.server_sockets; i++) {
if(FD_ISSET(global.serversock[i], &rfds))
return global.serversock[i];
}
return SOCK_ERROR; /* Should be impossible, stop compiler warnings */
}
#endif
}
