static int _parse_chown (xmlNodePtr node, void *arg)
{
ice_config_t *config = arg;
struct cfg_tag icecast_tags[] =
{
{ "user", config_get_str, &config->user },
{ "group", config_get_str, &config->group },
{ NULL, NULL, NULL }
};
if (parse_xml_tags (node, icecast_tags))
return -1;
config->chuid = 1;
return 0;
}
static int _parse_playlistlog (xmlNodePtr node, void *arg)
{
playlist_log *log = arg;
struct cfg_tag icecast_tags[] =
{
{ "name", config_get_str, &log->name },
{ "archive", config_get_bool, &log->archive },
{ "display", config_get_int, &log->display },
{ "size", config_get_int, &log->size },
{ "duration", config_get_int, &log->duration },
{ NULL, NULL, NULL }
};
log->logid = -1;
return parse_xml_tags (node, icecast_tags);
}
static int _parse_errorlog (xmlNodePtr node, void *arg)
{
error_log *log = arg;
struct cfg_tag icecast_tags[] =
{
{ "name", config_get_str, &log->name },
{ "archive", config_get_bool, &log->archive },
{ "display", config_get_int, &log->display },
{ "level", config_get_int, &log->level },
{ "size", config_get_int, &log->size },
{ NULL, NULL, NULL }
};
log->logid = -1;
log->level = 3;
return parse_xml_tags (node, icecast_tags);
}
static int _parse_authentication (xmlNodePtr node, void *arg)
{
ice_config_t *config = arg;
struct cfg_tag icecast_tags[] =
{
{ "source-password", config_get_str, &config->source_password },
{ "admin-user", config_get_str, &config->admin_username },
{ "admin-password", config_get_str, &config->admin_password },
{ "relay-user", config_get_str, &config->relay_username },
{ "relay-password", config_get_str, &config->relay_password },
{ NULL, NULL, NULL }
};
if (parse_xml_tags (node, icecast_tags))
return -1;
return 0;
}
static int _relay_master (xmlNodePtr node, void *arg)
{
relay_server *relay = arg;
relay_server_master *last, *master = calloc (1, sizeof (relay_server_master));
struct cfg_tag icecast_tags[] =
{
{ "ip", config_get_str, &master->ip },
{ "server", config_get_str, &master->ip },
{ "port", config_get_int, &master->port },
{ "mount", config_get_str, &master->mount },
{ "bind", config_get_str, &master->bind },
{ "timeout", config_get_int, &master->timeout },
{ NULL, NULL, NULL },
};
/* default master details taken from the default relay settings */
master->ip = (char *)xmlCharStrdup (relay->masters->ip);
master->mount = (char *)xmlCharStrdup (relay->masters->mount);
if (relay->masters->bind)
master->bind = (char *)xmlCharStrdup (relay->masters->bind);
master->port = relay->masters->port;
master->timeout = relay->masters->timeout;
if (parse_xml_tags (node, icecast_tags))
return -1;
if (master->port < 1 || master->port > 65535)
master->port = 8000;
if (master->timeout < 1 || master->timeout > 60)
master->timeout = 4;
/* place new details at the end of the list */
last = relay->masters;
while (last->next)
last = last->next;
last->next = master;
return 0;
}
static int _parse_directory (xmlNodePtr node, void *arg)
{
ice_config_t *config = arg;
struct cfg_tag icecast_tags[] =
{
{ "yp-url", config_get_str, &config->yp_url [config->num_yp_directories]},
{ "yp-url-timeout", config_get_int, &config->yp_url_timeout [config->num_yp_directories]},
{ "touch-interval", config_get_int, &config->yp_touch_interval [config->num_yp_directories]},
{ NULL, NULL, NULL }
};
if (config->num_yp_directories >= MAX_YP_DIRECTORIES)
{
ERROR0("Maximum number of yp directories exceeded!");
return -1;
}
if (parse_xml_tags (node, icecast_tags))
return -1;
config->num_yp_directories++;
return 0;
}
static int _parse_master (xmlNodePtr node, void *arg)
{
ice_config_t *config = arg;
struct cfg_tag icecast_tags[] =
{
{ "server", config_get_str, &config->master_server },
{ "port", config_get_int, &config->master_server_port },
{ "ssl-port", config_get_int, &config->master_ssl_port },
{ "username", config_get_str, &config->master_username },
{ "password", config_get_str, &config->master_password },
{ "bind", config_get_str, &config->master_bind },
{ "interval", config_get_int, &config->master_update_interval },
{ "relay-auth", config_get_bool, &config->master_relay_auth },
{ "redirect", config_get_bool, &config->master_redirect },
{ NULL, NULL, NULL },
};
if (parse_xml_tags (node, icecast_tags))
return -1;
return 0;
}
static int _parse_limits (xmlNodePtr node, void *arg)
{
ice_config_t *config = arg;
struct cfg_tag icecast_tags[] =
{
{ "max-bandwidth", config_get_bitrate,&config->max_bandwidth },
{ "clients", config_get_int, &config->client_limit },
{ "sources", config_get_int, &config->source_limit },
{ "queue-size", config_get_int, &config->queue_size_limit },
{ "min-queue-size", config_get_int, &config->min_queue_size },
{ "burst-size", config_get_int, &config->burst_size },
{ "workers", config_get_int, &config->workers_count },
{ "client-timeout", config_get_int, &config->client_timeout },
{ "header-timeout", config_get_int, &config->header_timeout },
{ "source-timeout", config_get_int, &config->source_timeout },
{ NULL, NULL, NULL },
};
if (parse_xml_tags (node, icecast_tags))
return -1;
if (config->workers_count < 1) config->workers_count = 1;
if (config->workers_count > 400) config->workers_count = 400;
return 0;
}
static int _parse_mount (xmlNodePtr node, void *arg)
{
ice_config_t *config = arg;
mount_proxy *mount = calloc(1, sizeof(mount_proxy));
struct cfg_tag icecast_tags[] =
{
{ "mount-name", config_get_str, &mount->mountname },
{ "source-timeout", config_get_int, &mount->source_timeout },
{ "queue-size", config_get_int, &mount->queue_size_limit },
{ "burst-size", config_get_int, &mount->burst_size},
{ "min-queue-size", config_get_int, &mount->min_queue_size},
{ "username", config_get_str, &mount->username },
{ "password", config_get_str, &mount->password },
{ "dump-file", config_get_str, &mount->dumpfile },
{ "intro", config_get_str, &mount->intro_filename },
{ "file-seekable", config_get_bool, &mount->file_seekable },
{ "fallback-mount", config_get_str, &mount->fallback_mount },
{ "fallback-override", config_get_bool, &mount->fallback_override },
{ "fallback-when-full", config_get_bool, &mount->fallback_when_full },
{ "max-listeners", config_get_int, &mount->max_listeners },
{ "max-bandwidth", config_get_bitrate, &mount->max_bandwidth },
{ "wait-time", config_get_int, &mount->wait_time },
{ "filter-theora", config_get_bool, &mount->filter_theora },
{ "limit-rate", config_get_bitrate, &mount->limit_rate },
{ "skip-accesslog", config_get_bool, &mount->skip_accesslog },
{ "charset", config_get_str, &mount->charset },
{ "qblock-size", config_get_int, &mount->queue_block_size },
{ "redirect", config_get_str, &mount->redirect },
{ "metadata-interval", config_get_int, &mount->mp3_meta_interval },
{ "mp3-metadata-interval",
config_get_int, &mount->mp3_meta_interval },
{ "ogg-passthrough", config_get_bool, &mount->ogg_passthrough },
{ "admin_comments_only",config_get_bool, &mount->admin_comments_only },
{ "allow-url-ogg-metadata",
config_get_bool, &mount->url_ogg_meta },
{ "no-mount", config_get_bool, &mount->no_mount },
{ "ban-client", config_get_int, &mount->ban_client },
{ "so-sndbuf", config_get_int, &mount->so_sndbuf },
{ "hidden", config_get_bool, &mount->hidden },
{ "authentication", auth_get_authenticator, &mount->auth },
{ "on-connect", config_get_str, &mount->on_connect },
{ "on-disconnect", config_get_str, &mount->on_disconnect },
{ "max-stream-duration",
config_get_int, &mount->max_stream_duration },
{ "max-listener-duration",
config_get_int, &mount->max_listener_duration },
{ "accesslog", _parse_accesslog, &mount->access_log },
/* YP settings */
{ "cluster-password", config_get_str, &mount->cluster_password },
{ "stream-name", config_get_str, &mount->stream_name },
{ "stream-description", config_get_str, &mount->stream_description },
{ "stream-url", config_get_str, &mount->stream_url },
{ "genre", config_get_str, &mount->stream_genre },
{ "bitrate", config_get_str, &mount->bitrate },
{ "public", config_get_bool, &mount->yp_public },
{ "type", config_get_str, &mount->type },
{ "subtype", config_get_str, &mount->subtype },
{ NULL, NULL, NULL },
};
/* default <mount> settings */
mount->max_listeners = -1;
mount->max_bandwidth = -1;
mount->burst_size = -1;
mount->min_queue_size = -1;
mount->mp3_meta_interval = -1;
mount->yp_public = -1;
mount->url_ogg_meta = 1;
mount->source_timeout = config->source_timeout;
mount->file_seekable = 1;
mount->access_log.type = LOG_ACCESS_CLF;
mount->access_log.logid = -1;
mount->access_log.log_ip = 1;
mount->fallback_override = 1;
if (parse_xml_tags (node, icecast_tags))
return -1;
if (mount->mountname == NULL)
{
config_clear_mount (mount);
return -1;
}
if (mount->auth)
mount->auth->mount = strdup (mount->mountname);
if (mount->admin_comments_only)
mount->url_ogg_meta = 1;
if (mount->url_ogg_meta)
mount->ogg_passthrough = 0;
if (mount->min_queue_size < 0)
mount->min_queue_size = mount->burst_size;
if (mount->queue_block_size < 100)
mount->queue_block_size = 1400;
if (mount->ban_client < 0)
mount->no_mount = 0;
mount->next = config->mounts;
config->mounts = mount;
return 0;
}
static int _parse_root (xmlNodePtr node, ice_config_t *config)
{
char *bindaddress = NULL;
struct cfg_tag icecast_tags[] =
{
{ "location", config_get_str, &config->location },
{ "admin", config_get_str, &config->admin },
{ "server_id", config_get_str, &config->server_id },
{ "server-id", config_get_str, &config->server_id },
{ "source-password", config_get_str, &config->source_password },
{ "hostname", config_get_str, &config->hostname },
{ "port", config_get_int, &config->port },
{ "bind-address", config_get_str, &bindaddress },
{ "fileserve", config_get_bool, &config->fileserve },
{ "relays-on-demand", config_get_bool, &config->on_demand },
{ "master-server", config_get_str, &config->master_server },
{ "master-username", config_get_str, &config->master_username },
{ "master-password", config_get_str, &config->master_password },
{ "master-bind", config_get_str, &config->master_bind },
{ "master-server-port", config_get_int, &config->master_server_port },
{ "master-update-interval",
config_get_int, &config->master_update_interval },
{ "master-relay-auth", config_get_bool, &config->master_relay_auth },
{ "master-ssl-port", config_get_int, &config->master_ssl_port },
{ "master-redirect", config_get_bool, &config->master_redirect },
{ "max-redirect-slaves",config_get_int, &config->max_redirects },
{ "redirect", _parse_redirect, config },
{ "shoutcast-mount", config_get_str, &config->shoutcast_mount },
{ "listen-socket", _parse_listen_sock, config },
{ "limits", _parse_limits, config },
{ "relay", _parse_relay, config },
{ "mount", _parse_mount, config },
{ "master", _parse_master, config },
{ "directory", _parse_directory, config },
{ "paths", _parse_paths, config },
{ "logging", _parse_logging, config },
{ "security", _parse_security, config },
{ "authentication", _parse_authentication, config},
{ NULL, NULL, NULL }
};
config->master_relay_auth = 1;
if (parse_xml_tags (node, icecast_tags))
return -1;
if (config->max_redirects == 0 && config->master_redirect)
config->max_redirects = 1;
if (config->listen_sock_count == 0)
{
if (config->port)
{
listener_t *listener = calloc (1, sizeof(listener_t));
listener->refcount = 1;
listener->port = config->port;
listener->qlen = ICE_LISTEN_QUEUE;
listener->bind_address = (char*)xmlStrdup (XMLSTR(bindaddress));
listener->next = config->listen_sock;
config->listen_sock = listener;
config->listen_sock_count++;
}
else
{
WARN0 ("No listen-socket defintions");
return -1;
}
}
return 0;
}
static int _parse_relay (xmlNodePtr node, void *arg)
{
ice_config_t *config = arg;
relay_server *relay = calloc(1, sizeof(relay_server));
relay_server_host *host = calloc (1, sizeof (relay_server_host));
int on_demand = config->on_demand, icy_metadata = 1, running = 1;
struct cfg_tag icecast_tags[] =
{
{ "master", _relay_host, relay },
{ "host", _relay_host, relay },
{ "server", config_get_str, &host->ip },
{ "ip", config_get_str, &host->ip },
{ "bind", config_get_str, &host->bind },
{ "port", config_get_port, &host->port },
{ "mount", config_get_str, &host->mount },
{ "timeout", config_get_int, &host->timeout },
{ "local-mount", config_get_str, &relay->localmount },
{ "on-demand", config_get_bool, &on_demand },
{ "run-on", config_get_int, &relay->run_on },
{ "retry-delay", config_get_int, &relay->interval },
{ "relay-icy-metadata", config_get_bool, &icy_metadata },
{ "relay-shoutcast-metadata", config_get_bool, &icy_metadata },
{ "username", config_get_str, &relay->username },
{ "password", config_get_str, &relay->password },
{ "enable", config_get_bool, &running },
{ NULL, NULL, NULL },
};
relay->interval = config->master_update_interval;
relay->run_on = 30;
relay->hosts = host;
/* default settings */
host->port = config->port;
host->ip = (char *)xmlCharStrdup ("127.0.0.1");
host->mount = (char*)xmlCharStrdup ("/");
host->timeout = 4;
if (parse_xml_tags (node, icecast_tags))
return -1;
if (on_demand) relay->flags |= RELAY_ON_DEMAND;
if (icy_metadata) relay->flags |= RELAY_ICY_META;
if (running) relay->flags |= RELAY_RUNNING;
/* check for unspecified entries */
if (relay->localmount == NULL)
relay->localmount = (char*)xmlCharStrdup (host->mount);
/* if master is set then remove the default entry at the head of the list */
if (relay->hosts->next)
{
relay->hosts = relay->hosts->next;
if (host->mount) xmlFree (host->mount);
if (host->ip) xmlFree (host->ip);
if (host->bind) xmlFree (host->bind);
free (host);
}
relay->new_details = config->relays;
config->relays = relay;
return 0;
}
