diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index ca0eda52a211ca62d546353b4c3784d075189a54..feee6655fa6ea8186eb1b435446f6178b793f808 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -4,9 +4,10 @@ build:
     GIT_SUBMODULE_STRATEGY: recursive
 
   tags:
-    - alpine
     - docker
 
+  image: alpine:3.12
+
   stage: build
 
   before_script:
diff --git a/admin/moveclients.xsl b/admin/moveclients.xsl
index 9328998a07cffe558bc02b020e656cce7062f80a..33ec6857be04a92ea0e63eb3448855da811dd945 100644
--- a/admin/moveclients.xsl
+++ b/admin/moveclients.xsl
@@ -26,9 +26,9 @@
                             </xsl:otherwise>
                         </xsl:choose>
                         <form method="post" action="/admin/moveclients.xsl">
-                            <label for="moveto" class="hidden">
-                                Move from <code><xsl:value-of select="current_source" /></code> to
-                            </label>
+                            Move from
+                            <code><xsl:value-of select="current_source" /></code>
+                            to
                             <select name="destination" id="moveto">
                                 <xsl:for-each select="source">
                                     <option value="{@mount}">
@@ -36,6 +36,13 @@
                                     </option>
                                 </xsl:for-each>
                             </select>
+                            with direction
+                            <select name="direction">
+                                <option value="up">up</option>
+                                <option value="down">down</option>
+                                <option value="replace-current">replace</option>
+                                <option value="replace-all" selected="selected">forget and replace</option>
+                            </select>
                             <input type="hidden" name="mount" value="{current_source}" />
                             &#160;
                             <input type="submit" value="Move listeners" />
diff --git a/conf/icecast.xml.in b/conf/icecast.xml.in
index 54f7ba901f26ed4d7e1eba1af65b1c8a5da09dd9..7a9e7fbbc5b0f9cfc880ef5eda4d381ef5e2b4b6 100644
--- a/conf/icecast.xml.in
+++ b/conf/icecast.xml.in
@@ -267,7 +267,7 @@
         <logdir>@localstatedir@/log/@PACKAGE@</logdir>
         <webroot>@pkgdatadir@/web</webroot>
         <adminroot>@pkgdatadir@/admin</adminroot>
-	<reportxmldb>@pkgdatadir@/report-db.xml</reportxmldb>
+        <reportxmldb>@pkgdatadir@/report-db.xml</reportxmldb>
         <!-- <pidfile>@pkgdatadir@/icecast.pid</pidfile> -->
 
         <!-- Aliases: treat requests for 'source' path as being for 'dest' path
@@ -310,5 +310,35 @@
             <group>nogroup</group>
         </changeowner>
         -->
+
+        <!-- It is generally helpful to set a PRNG seed, what seed to set depends on your OS. -->
+        <!-- Useful on all operating systems is a seed file for Icecast to update.
+             This should be at some location that is (semi-)permanent such as /var/lib or /var/cache
+             A size of 1024 [byte] is suggested.
+             The file can be shared with trusted applications (other instances of Icecast).
+             But should be protected against read and write access by untrusted applications.
+        <prng-seed type="read-write" size="1024">/path/to/storage/icecast.prng-seed</prng-seed>
+        -->
+        <!-- A profile includes common sources of entropy therefore provides a good way to
+             seed the PRNG.
+             Currently defined profiles are: bsd, linux.
+             The bsd profile expects /dev/urandom to be readable.
+             The linux profile includes the bsd profile but adds linux specific interfaces (such as /proc).
+        <prng-seed type="profile">linux</prng-seed>
+        -->
+        <!-- If your OS provides a urandom style device and there is no profile for your OS you can
+             provide a custom device name.
+             The size parameter defines how many bytes are read per (re)seeding. The optimal setting
+             depends on the quality of your device, a general good default is 32 [byte].
+        <prng-seed type="device" size="32">/dev/urandom</prng-seed>
+        -->
+        <!-- If none of above is available on your OS you can add a static seed.
+             This is by far not as secure as the above.
+             The value should be at least 64 characters long if from [a-zA-Z0-9].
+             You MUST keep this parameter secret. It MUST NOT be shared with other instances.
+             You SHOULD change this parameter often.
+        <prng-seed type="static">U4V5etZF...</prng-seed>
+        -->
+
     </security>
 </icecast>
diff --git a/configure.ac b/configure.ac
index d2d914e4d8ef88a164ad306a7b05716015a0ef49..ea9b315b25ac0258d5964d0e21f1e705c4c3081d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -100,6 +100,8 @@ AC_CHECK_HEADERS([sys/timeb.h])
 AC_CHECK_HEADERS([sys/socket.h])
 AC_CHECK_HEADERS([pwd.h grp.h])
 
+AC_C_BIGENDIAN
+
 XIPH_NET
 
 dnl Check for functions
diff --git a/src/Makefile.am b/src/Makefile.am
index 8051f70784100f4eeac7183508c55787336db2e0..1b49e3068bf2b0ad46293dac06011dd7325c0bd0 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -28,9 +28,12 @@ noinst_HEADERS = \
     xslt.h \
     yp.h \
     md5.h \
+    digest.h \
+    prng.h \
     matchfile.h \
     tls.h \
     refobject.h \
+    rqueue.h \
     buffer.h \
     module.h \
     reportxml.h \
@@ -39,6 +42,7 @@ noinst_HEADERS = \
     xml2json.h \
     listensocket.h \
     fastevent.h \
+    navigation.h \
     event.h \
     event_log.h \
     event_exec.h \
@@ -75,8 +79,11 @@ icecast_SOURCES = \
     xslt.c \
     fserve.c \
     admin.c \
+    rqueue.c \
     resourcematch.c \
     md5.c \
+    digest.c \
+    prng.c \
     matchfile.c \
     tls.c \
     refobject.c \
@@ -88,6 +95,7 @@ icecast_SOURCES = \
     xml2json.c \
     listensocket.c \
     fastevent.c \
+    navigation.c \
     format.c \
     format_ogg.c \
     format_mp3.c \
diff --git a/src/acl.c b/src/acl.c
index bd02e7df80b743ef9b30d8ec9a9329d19c549ca1..908ffe64de156ee785ac22dcc730c240558b023c 100644
--- a/src/acl.c
+++ b/src/acl.c
@@ -121,7 +121,7 @@ acl_t *acl_new(void)
     return ret;
 }
 
-acl_t *acl_new_from_xml_node(xmlNodePtr node)
+acl_t *acl_new_from_xml_node(ice_config_t *configuration, xmlNodePtr node)
 {
     acl_t * ret;
     char * tmp;
@@ -212,7 +212,7 @@ acl_t *acl_new_from_xml_node(xmlNodePtr node)
             if (xmlIsBlankNode(child))
                 continue;
             if (xmlStrcmp(child->name, XMLSTR("http-headers")) == 0) {
-                config_parse_http_headers(child->xmlChildrenNode, &(ret->http_headers));
+                config_parse_http_headers(child->xmlChildrenNode, &(ret->http_headers), configuration);
             }
         } while ((child = child->next));
     }
diff --git a/src/acl.h b/src/acl.h
index 6d53d28accd0503e0c7c3b6f64e7e97a6066bacc..fd6d91165828c17294fba9131039f87273350a2e 100644
--- a/src/acl.h
+++ b/src/acl.h
@@ -33,7 +33,7 @@ typedef enum acl_policy_tag {
 
 /* basic functions to work with ACLs */
 acl_t * acl_new(void);
-acl_t * acl_new_from_xml_node(xmlNodePtr node);
+acl_t * acl_new_from_xml_node(ice_config_t *configuration, xmlNodePtr node);
 
 void acl_addref(acl_t * acl);
 void acl_release(acl_t * acl);
diff --git a/src/admin.c b/src/admin.c
index bfc57cc6c42a1aee22e38a9cd2a923f4faa208d2..3f51d9b694fe5c9feaec50dcb31df8865dcb2dfc 100644
--- a/src/admin.c
+++ b/src/admin.c
@@ -118,6 +118,8 @@
 #define DEFAULT_RAW_REQUEST                 ""
 #define DEFAULT_HTML_REQUEST                ""
 #define BUILDM3U_RAW_REQUEST                "buildm3u"
+#define RCHANNEL_AUTO_REQUEST               "rchannel"
+#define RCHANNEL_SOURCE_REQUEST             "getrchannel"
 
 typedef struct {
     const char *prefix;
@@ -207,9 +209,18 @@ static const admin_command_handler_t ui_handlers[] = {
     { "%s",                                 ADMINTYPE_HYBRID,       ADMIN_FORMAT_AUTO,          ADMINSAFE_SAFE,     NULL, ui_command}
 };
 
+static void command_rchannel            (client_t *client, source_t *source, admin_format_t response);
+static void command_get_rchannel        (client_t *client, source_t *source, admin_format_t response);
+
+static const admin_command_handler_t rchannel_handlers[] = {
+    { RCHANNEL_AUTO_REQUEST,               ADMINTYPE_MOUNT,        ADMIN_FORMAT_AUTO,           ADMINSAFE_SAFE,   command_rchannel, NULL},
+    { RCHANNEL_SOURCE_REQUEST,             ADMINTYPE_MOUNT,        ADMIN_FORMAT_AUTO,           ADMINSAFE_SAFE,   command_get_rchannel, NULL}
+};
+
 static admin_command_table_t command_tables[ADMIN_MAX_COMMAND_TABLES] = {
     {.prefix = NULL, .length = (sizeof(handlers)/sizeof(*handlers)), .handlers = handlers},
     {.prefix = "ui", .length = (sizeof(ui_handlers)/sizeof(*ui_handlers)), .handlers = ui_handlers},
+    {.prefix = "rchannel", .length = (sizeof(rchannel_handlers)/sizeof(*rchannel_handlers)), .handlers = rchannel_handlers}
 };
 
 static inline int __is_command_table_valid(const admin_command_table_t * table)
@@ -716,6 +727,7 @@ static void command_move_clients(client_t   *client,
 {
     const char *dest_source;
     const char *idtext = NULL;
+    const char *directiontext = NULL;
     connection_id_t id;
     source_t *dest;
     char buf[255];
@@ -730,6 +742,8 @@ static void command_move_clients(client_t   *client,
     } else {
         idtext = NULL;
     }
+    COMMAND_OPTIONAL(client, "direction", directiontext);
+
     ICECAST_LOG_DEBUG("Done optional check (%d)", parameters_passed);
     if (!parameters_passed) {
         xmlDocPtr doc = admin_build_sourcelist(source->mount, client, response);
@@ -766,7 +780,7 @@ static void command_move_clients(client_t   *client,
 
     ICECAST_LOG_INFO("source is \"%s\", destination is \"%s\"", source->mount, dest->mount);
 
-    source_move_clients(source, dest, idtext ? &id : NULL);
+    source_move_clients(source, dest, idtext ? &id : NULL, navigation_str_to_direction(directiontext, NAVIGATION_DIRECTION_REPLACE_ALL));
 
     snprintf(buf, sizeof(buf), "Clients moved from %s to %s",
         source->mount, dest_source);
@@ -827,6 +841,15 @@ static inline xmlNodePtr __add_listener(client_t        *client,
 
     xmlNewTextChild(node, NULL, XMLSTR("protocol"), XMLSTR(client_protocol_to_string(client->protocol)));
 
+    do {
+        xmlNodePtr history = xmlNewChild(node, NULL, XMLSTR("history"), NULL);
+        size_t i;
+
+        for (i = 0; i < client->history.fill; i++) {
+            xmlNewTextChild(history, NULL, XMLSTR("mount"), XMLSTR(mount_identifier_get_mount(client->history.history[i])));
+        }
+    } while (0);
+
     return node;
 }
 
@@ -1472,6 +1495,14 @@ static void command_dashboard           (client_t *client, source_t *source, adm
         __reportxml_add_maintenance(reportnode, config->reportxml_db, "8defae31-a52e-4bba-b904-76db5362860f", "warning", "No useful location is given in <location>.", NULL);
     if (config->config_problems & CONFIG_PROBLEM_ADMIN)
         __reportxml_add_maintenance(reportnode, config->reportxml_db, "cf86d88e-dc20-4359-b446-110e7065d17a", "warning", "No admin contact given in <admin>. YP directory support will is disabled.", NULL);
+    if (config->config_problems & CONFIG_PROBLEM_PRNG)
+        __reportxml_add_maintenance(reportnode, config->reportxml_db, "e2ba5a8b-4e4f-41ca-b455-68ae5fb6cae0", "error", "No PRNG seed configured. PRNG is insecure.", NULL);
+    if (config->config_problems & CONFIG_PROBLEM_UNKNOWN_NODE)
+        __reportxml_add_maintenance(reportnode, config->reportxml_db, "6620ef7b-46ef-4781-9a5e-8ee7f0f9d44e", "error", "Unknown tags are used in the config file. See the error.log for details.", NULL);
+    if (config->config_problems & CONFIG_PROBLEM_OBSOLETE_NODE)
+        __reportxml_add_maintenance(reportnode, config->reportxml_db, "b6224fc4-53a1-433f-a6cd-d5b85c60f1c9", "error", "Obsolete tags are used in the config file. See the error.log for details and update your configuration accordingly.", NULL);
+    if (config->config_problems & CONFIG_PROBLEM_INVALID_NODE)
+        __reportxml_add_maintenance(reportnode, config->reportxml_db, "0f6f757d-52d8-4b9a-8e57-9bcd528fffba", "error", "Invalid tags are used in the config file. See the error.log for details and update your configuration accordingly.", NULL);
 
     if (!has_sources)
         __reportxml_add_maintenance(reportnode, config->reportxml_db, "f68dd8a3-22b1-4118-aba6-b039f2c5b51e", "info", "Currently no sources are connected to this server.", NULL);
@@ -1549,3 +1580,65 @@ static void ui_command(client_t * client, source_t * source, admin_format_t form
         client_send_error_by_id(client, ICECAST_ERROR_ADMIN_UNRECOGNISED_COMMAND);
     }
 }
+
+static void command_rchannel(client_t *client, source_t *source, admin_format_t response)
+{
+    if(source == NULL){
+        ICECAST_LOG_DEBUG("Rchannel: Source is NULL");
+        return;
+    }
+    const char * message = NULL;
+    COMMAND_REQUIRE(client, "message", message);
+    int message_length = strlen(message);
+    if(message_length == 0)
+        client_send_error_by_id(client, ICECAST_ERROR_RCHANNEL_MESSAGE_EMPTY);
+    else if(message_length > MESSAGE_MAXSIZE)
+        client_send_error_by_id(client, ICECAST_ERROR_RCHANNEL_MESSAGE_TOO_LONG);
+    else if(get_rchannel_queue_size(source) == RCHANNEL_QUEUE_MAXSIZE) /*QUEUE is full*/
+        client_send_error_by_id(client, ICECAST_ERROR_RCHANNEL_QUEUE_FULL);
+    else {
+        add_message_rchannel_queue(source,message);
+        admin_send_response_simple(client,source,response,"Message Recieved",0);
+    }
+}
+static void command_get_rchannel(client_t *client, source_t *source, admin_format_t response){
+    if(source == NULL) {
+        ICECAST_LOG_ERROR("Rchannel: Source is NULL");
+        return;
+    }
+    else if(get_rchannel_queue_size(source) == 0) 
+        client_send_error_by_id(client, ICECAST_ERROR_RCHANNEL_QUEUE_EMPTY);
+    else {
+        reportxml_node_t *rootnode;
+        reportxml_node_t *incidentnode;
+        reportxml_node_t *statenode;
+        reportxml_node_t *resource;
+        reportxml_node_t *messagenode;
+        reportxml_t *report = refobject_new(reportxml_t);
+        rootnode = reportxml_get_root_node(report);
+        int size = get_rchannel_queue_size(source);
+        while(size > 0){
+            ICECAST_LOG_DEBUG("Inside the loop size is %d", size);
+            incidentnode = reportxml_node_new(REPORTXML_NODE_TYPE_INCIDENT, NULL, NULL, NULL);
+            statenode = reportxml_node_new(REPORTXML_NODE_TYPE_STATE, NULL, "348f649c-f78f-4741-977a-f1ad8afb514a", NULL);
+            resource  = reportxml_node_new(REPORTXML_NODE_TYPE_RESOURCE, NULL, NULL, NULL);
+            messagenode = reportxml_node_new(REPORTXML_NODE_TYPE_VALUE, NULL, NULL, NULL);
+            char *buf = get_message_rchannel_queue(source);
+            reportxml_helper_add_value_string(messagenode,"message",buf);
+            remove_message_rchannel_queue(source);
+            reportxml_node_add_child(resource, messagenode);
+            reportxml_node_add_child(incidentnode, statenode);
+            reportxml_node_add_child(incidentnode, resource);
+            reportxml_node_add_child(rootnode, incidentnode);
+            refobject_unref(messagenode);
+            refobject_unref(statenode);
+            refobject_unref(resource);
+            refobject_unref(incidentnode);
+            free(buf);
+            size--;
+        }
+        client_send_reportxml(client, report, DOCUMENT_DOMAIN_ADMIN, NULL, response, 200, NULL);
+        refobject_unref(rootnode);
+        refobject_unref(report);
+    }
+}
\ No newline at end of file
diff --git a/src/auth.c b/src/auth.c
index 5a550ac0030bbebf33154bf403ccfa0f4710a38e..210f7edf745dd8ef2f0bf4ac5196b54cc4e1dcba 100644
--- a/src/auth.c
+++ b/src/auth.c
@@ -795,7 +795,7 @@ static inline int auth_get_authenticator__permission_alter(auth_t *auth, xmlNode
 
     return 0;
 }
-auth_t *auth_get_authenticator(xmlNodePtr node)
+auth_t *auth_get_authenticator(ice_config_t *configuration, xmlNodePtr node)
 {
     auth_t *auth = calloc(1, sizeof(auth_t));
     config_options_t *options = NULL, **next_option = &options;
@@ -931,10 +931,10 @@ auth_t *auth_get_authenticator(xmlNodePtr node)
             *next_option = opt;
             next_option = &opt->next;
         } else if (xmlStrcmp (child->name, XMLSTR("http-headers")) == 0) {
-            config_parse_http_headers(child->xmlChildrenNode, &(auth->http_headers));
+            config_parse_http_headers(child->xmlChildrenNode, &(auth->http_headers), configuration);
         } else if (xmlStrcmp (child->name, XMLSTR("acl")) == 0) {
             if (!auth->acl) {
-                auth->acl  = acl_new_from_xml_node(child);
+                auth->acl  = acl_new_from_xml_node(configuration, child);
             } else {
                 ICECAST_LOG_ERROR("More than one ACL defined in role! Not supported (yet).");
             }
@@ -971,7 +971,7 @@ auth_t *auth_get_authenticator(xmlNodePtr node)
 
     if (!auth->acl) {
         /* If we did not get a <acl> try ACL as part of <role> (old style). */
-        auth->acl  = acl_new_from_xml_node(node);
+        auth->acl  = acl_new_from_xml_node(configuration, node);
     }
     if (!auth->acl) {
         auth_release(auth);
diff --git a/src/auth.h b/src/auth.h
index cacd9e99bc8ea7f5f11c6fb9e27d858c3b6f3511..4f99873cfa52c47db7c0fa89e34cbe1b4a12de29 100644
--- a/src/auth.h
+++ b/src/auth.h
@@ -186,7 +186,7 @@ void auth_shutdown(void);
 
 auth_result auth_str2result(const char *str);
 
-auth_t  *auth_get_authenticator(xmlNodePtr node);
+auth_t  *auth_get_authenticator(ice_config_t *configuration, xmlNodePtr node);
 void    auth_release(auth_t *authenticator);
 void    auth_addref(auth_t *authenticator);
 
diff --git a/src/cfgfile.c b/src/cfgfile.c
index 89d3ec581040f9102a90050d90536b6285625a00..e771c5c56602c2637006d588000784a550bcf51c 100644
--- a/src/cfgfile.c
+++ b/src/cfgfile.c
@@ -45,6 +45,7 @@
 #include "main.h"
 #include "slave.h"
 #include "xslt.h"
+#include "prng.h"
 
 #define CATMODULE                       "CONFIG"
 #define CONFIG_DEFAULT_LOCATION         "Earth"
@@ -155,9 +156,17 @@
 #define CONFIG_LEGACY_ANONYMOUS_ALLOW_WEB   1
 #define CONFIG_LEGACY_ANONYMOUS_ALLOW_ADMIN NULL
 
+enum bad_tag_reason {
+    BTR_UNKNOWN,
+    BTR_OBSOLETE,
+    BTR_INVALID,
+    BTR_EMPTY
+};
+
 static ice_config_t _current_configuration;
 static ice_config_locks _locks;
 
+static void __found_bad_tag(ice_config_t *configuration, xmlNodePtr node, enum bad_tag_reason reason, const char *extra);
 static void _set_defaults(ice_config_t *c);
 static void _parse_root(xmlDocPtr doc, xmlNodePtr node, ice_config_t *c);
 static void _parse_limits(xmlDocPtr doc, xmlNodePtr node, ice_config_t *c);
@@ -184,7 +193,7 @@ static void _parse_events(event_registration_t **events, xmlNodePtr node);
 static void merge_mounts(mount_proxy * dst, mount_proxy * src);
 static inline void _merge_mounts_all(ice_config_t *c);
 
-operation_mode config_str_to_omode(const char *str)
+operation_mode config_str_to_omode(ice_config_t *configuration, xmlNodePtr node, const char *str)
 {
     if (!str || !*str)
         return OMODE_DEFAULT;
@@ -197,12 +206,13 @@ operation_mode config_str_to_omode(const char *str)
     } else if (strcasecmp(str, "strict") == 0) {
         return OMODE_STRICT;
     } else {
+        __found_bad_tag(configuration, node, BTR_INVALID, str);
         ICECAST_LOG_ERROR("Unknown operation mode \"%s\", falling back to DEFAULT.", str);
         return OMODE_DEFAULT;
     }
 }
 
-static listener_type_t config_str_to_listener_type(const char *str)
+static listener_type_t config_str_to_listener_type(ice_config_t *configuration, xmlNodePtr node, const char *str)
 {
     if (!str || !*str) {
         return LISTENER_TYPE_NORMAL;
@@ -211,17 +221,38 @@ static listener_type_t config_str_to_listener_type(const char *str)
     } else if (strcasecmp(str, "virtual") == 0) {
         return LISTENER_TYPE_VIRTUAL;
     } else {
+        __found_bad_tag(configuration, node, BTR_INVALID, str);
         ICECAST_LOG_ERROR("Unknown listener type \"%s\", falling back to NORMAL.", str);
         return LISTENER_TYPE_NORMAL;
     }
 }
 
-char * config_href_to_id(const char *href)
+static fallback_override_t config_str_to_fallback_override_t(ice_config_t *configuration, xmlNodePtr node, const char *str)
+{
+    if (!str || !*str || strcmp(str, "none") == 0) {
+        return FALLBACK_OVERRIDE_NONE;
+    } else if (strcasecmp(str, "all") == 0) {
+        return FALLBACK_OVERRIDE_ALL;
+    } else if (strcasecmp(str, "own") == 0) {
+        return FALLBACK_OVERRIDE_OWN;
+    } else {
+        if (util_str_to_bool(str)) {
+            ICECAST_LOG_WARN("Old style fallback override setting. Please replace %#H with \"all\".", str);
+            return FALLBACK_OVERRIDE_ALL;
+        } else {
+            ICECAST_LOG_WARN("Old style fallback override setting. Please replace %#H with \"none\".", str);
+            return FALLBACK_OVERRIDE_NONE;
+        }
+    }
+}
+
+char * config_href_to_id(ice_config_t *configuration, xmlNodePtr node, const char *href)
 {
     if (!href || !*href)
         return NULL;
 
     if (*href != '#') {
+        __found_bad_tag(configuration, node, BTR_INVALID, href);
         ICECAST_LOG_ERROR("Can not convert string \"%H\" to ID.", href);
         return NULL;
     }
@@ -261,11 +292,11 @@ void config_init_configuration(ice_config_t *configuration)
     configuration->reportxml_db = refobject_new(reportxml_database_t);
 }
 
-static inline void __read_int(xmlDocPtr doc, xmlNodePtr node, int *val, const char *warning)
+static inline void __read_int(ice_config_t *configuration, xmlDocPtr doc, xmlNodePtr node, int *val)
 {
     char *str = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
     if (!str || !*str) {
-        ICECAST_LOG_WARN("%s", warning);
+        __found_bad_tag(configuration, node, BTR_EMPTY, NULL);
     } else {
         *val = util_str_to_int(str, *val);
     }
@@ -273,11 +304,11 @@ static inline void __read_int(xmlDocPtr doc, xmlNodePtr node, int *val, const ch
         xmlFree(str);
 }
 
-static inline void __read_unsigned_int(xmlDocPtr doc, xmlNodePtr node, unsigned int *val, const char *warning)
+static inline void __read_unsigned_int(ice_config_t *configuration, xmlDocPtr doc, xmlNodePtr node, unsigned int *val)
 {
     char *str = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
     if (!str || !*str) {
-        ICECAST_LOG_WARN("%s", warning);
+        __found_bad_tag(configuration, node, BTR_EMPTY, NULL);
     } else {
         *val = util_str_to_unsigned_int(str, *val);
     }
@@ -352,8 +383,154 @@ static int __check_node_impl(xmlNodePtr node, const char *def)
     return res;
 }
 
+static char *__build_node_name(xmlNodePtr node)
+{
+    char *buf[4];
+    size_t have;
+    size_t i;
+    size_t len = 4;
+    char *ret;
+    char *p;
+
+    memset(buf, 0, sizeof(buf));
+
+    for (have = 0; have < (sizeof(buf)/sizeof(*buf)); have++) {
+        int ret = -1;
+        xmlChar *id;
+
+        id = xmlGetProp(node, XMLSTR("id"));
+        if (id) {
+            ret = asprintf(&(buf[have]), "%s[@id=\"%s\"]", node->name, id);
+            xmlFree(id);
+        } else if (xmlStrcmp(node->name, XMLSTR("mount")) == 0) {
+            xmlChar *mount = NULL;
+            xmlNodePtr child = node->xmlChildrenNode;
+            while (child && !mount) {
+                if (xmlStrcmp(child->name, XMLSTR("mount-name")) == 0) {
+                    mount = xmlNodeListGetString(child->doc, child->xmlChildrenNode, 1);
+                }
+                child = child->next;
+            }
+            if (mount) {
+                ret = asprintf(&(buf[have]), "%s[mount-name/text()=\"%s\"]", node->name, mount);
+                xmlFree(mount);
+            } else {
+                ret = asprintf(&(buf[have]), "%s", node->name);
+            }
+        } else {
+            ret = asprintf(&(buf[have]), "%s", node->name);
+        }
+
+        if (ret < 1) {
+            buf[have] = NULL;
+            for (i = 0; i < (sizeof(buf)/sizeof(*buf)); i++)
+                free(buf[i]);
+            return "<error>";
+        }
+
+        node = node->parent;
+        if (!node)
+            break;
+    }
+
+    for (i = 0; i < (sizeof(buf)/sizeof(*buf)); i++) {
+        if (buf[i])
+            len += strlen(buf[i]) + 1;
+    }
+
+    p = ret = malloc(len);
+    if (!ret) {
+        for (i = 0; i < (sizeof(buf)/sizeof(*buf)); i++)
+            free(buf[i]);
+        return "<error>";
+    }
+
+    if (node && node->type != XML_DOCUMENT_NODE) {
+        memcpy(p, "...", 3);
+        p += 3;
+    }
+
+    for (i = have; i > 0; i--) {
+        char *b = buf[i - 1];
+
+        if (b) {
+            size_t l = strlen(b);
+
+            *p = '/';
+            p++;
+            memcpy(p, b, l);
+            p += l;
+            free(b);
+        }
+    }
+
+    *p = 0;
+
+    return ret;
+}
+
+static void __found_bad_tag(ice_config_t *configuration, xmlNodePtr node, enum bad_tag_reason reason, const char *extra)
+{
+    char *name = NULL;
+
+    /* ignore non-configuration errors */
+    if (!configuration)
+        return;
+
+    // ignore comments.
+    if (node->type == XML_COMMENT_NODE)
+        return;
+
+    if (node)
+        name = __build_node_name(node);
 
-static void __append_old_style_auth(auth_stack_t       **stack,
+    switch (reason) {
+        case BTR_UNKNOWN:
+            configuration->config_problems |= CONFIG_PROBLEM_UNKNOWN_NODE;
+            if (name) {
+                ICECAST_LOG_WARN("Unknown tag in config: %s", name);
+            } else {
+                ICECAST_LOG_WARN("Unknown tag in config");
+            }
+        break;
+        case BTR_OBSOLETE:
+            configuration->config_problems |= CONFIG_PROBLEM_OBSOLETE_NODE;
+            if (name) {
+                ICECAST_LOG_WARN("Obsolete tag in config: %s", name);
+                if (extra) {
+                    ICECAST_LOG_WARN("Obsolete tag %s can be replaced: %s", name, extra);
+                }
+            } else {
+                ICECAST_LOG_WARN("Obsolete tag in config");
+            }
+        break;
+        case BTR_INVALID:
+            configuration->config_problems |= CONFIG_PROBLEM_INVALID_NODE;
+            if (name) {
+                if (extra) {
+                    ICECAST_LOG_WARN("Invalid content for tag: %s: %s", name, extra);
+                } else {
+                    ICECAST_LOG_WARN("Invalid content for tag: %s", name);
+                }
+            } else {
+                ICECAST_LOG_WARN("Invalid content for tag");
+            }
+        break;
+        case BTR_EMPTY:
+            configuration->config_problems |= CONFIG_PROBLEM_INVALID_NODE;
+            if (name) {
+                ICECAST_LOG_WARN("Invalid empty tag: %s", name);
+            } else {
+                ICECAST_LOG_WARN("Invalid empty tag");
+            }
+        break;
+    }
+
+    free(name);
+}
+
+static void __append_old_style_auth(ice_config_t        *configuration,
+                                    auth_stack_t       **stack,
                                     const char          *name,
                                     const char          *type,
                                     const char          *username,
@@ -409,7 +586,7 @@ static void __append_old_style_auth(auth_stack_t       **stack,
         xmlSetProp(pass, XMLSTR("value"), XMLSTR(password));
     }
 
-    auth = auth_get_authenticator(role);
+    auth = auth_get_authenticator(configuration, role);
     auth_stack_push(stack, auth);
     auth_release(auth);
 
@@ -430,7 +607,8 @@ static void __append_option_tag(xmlNodePtr  parent,
     xmlSetProp(node, XMLSTR("value"), XMLSTR(value));
 }
 
-static void __append_old_style_urlauth(auth_stack_t **stack,
+static void __append_old_style_urlauth(ice_config_t  *configuration,
+                                       auth_stack_t **stack,
                                        const char    *client_add,
                                        const char    *client_remove,
                                        const char    *action_add,
@@ -478,7 +656,7 @@ static void __append_old_style_urlauth(auth_stack_t **stack,
     __append_option_tag(role, "headers", headers);
     __append_option_tag(role, "header_prefix", header_prefix);
 
-    auth = auth_get_authenticator(role);
+    auth = auth_get_authenticator(configuration, role);
     if (auth) {
         auth_stack_push(stack, auth);
         auth_release(auth);
@@ -663,6 +841,15 @@ listener_t *config_clear_listener(listener_t *listener)
     return next;
 }
 
+static void config_clear_prng_seed(prng_seed_config_t *seed)
+{
+    while (seed) {
+        prng_seed_config_t *next = seed->next;
+        if (seed->filename) xmlFree(seed->filename);
+        seed = next;
+    }
+}
+
 void config_clear(ice_config_t *c)
 {
     mount_proxy         *mount,
@@ -728,6 +915,8 @@ void config_clear(ice_config_t *c)
 
     refobject_unref(c->reportxml_db);
 
+    config_clear_prng_seed(c->prng_seed);
+
     memset(c, 0, sizeof(ice_config_t));
 }
 
@@ -765,6 +954,7 @@ void config_reread_config(void)
         config_set_config(&new_config);
         config = config_get_config_unlocked();
         restart_logging(config);
+        prng_configure(config);
         main_config_reload(config);
         connection_reread_config(config);
         yp_recheck_config(config);
@@ -1031,12 +1221,14 @@ static void _parse_root(xmlDocPtr       doc,
             ICECAST_LOG_WARN("<source-password> defined outside "
                 "<authentication>. This is deprecated and will be removed in "
                 "version 2.X.0");
+            __found_bad_tag(configuration, node, BTR_OBSOLETE, "Use <source-password> in <authentication>.");
 	    /* FIXME Settle target version for removal of this functionality! */
             if (source_password)
                 xmlFree(source_password);
             source_password = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("icelogin")) == 0) {
             ICECAST_LOG_ERROR("<icelogin> support has been removed.");
+            __found_bad_tag(configuration, node, BTR_OBSOLETE, NULL);
         } else if (xmlStrcmp(node->name, XMLSTR("fileserve")) == 0) {
             tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
             configuration->fileserve = util_str_to_bool(tmp);
@@ -1052,7 +1244,7 @@ static void _parse_root(xmlDocPtr       doc,
                 xmlFree(configuration->hostname);
             configuration->hostname = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("mime-types")) == 0) {
-            ICECAST_LOG_WARN("<mime-types> has been moved into <paths>. Please update your configuration file.");
+            __found_bad_tag(configuration, node, BTR_OBSOLETE, "Use <mime-types> in <paths>.");
             if (configuration->mimetypes_fn)
                 xmlFree(configuration->mimetypes_fn);
             configuration->mimetypes_fn = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
@@ -1084,9 +1276,9 @@ static void _parse_root(xmlDocPtr       doc,
                 xmlFree(configuration->master_password);
             configuration->master_password = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("master-server-port")) == 0) {
-            __read_int(doc, node, &configuration->master_server_port, "<master-server-port> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->master_server_port);
         } else if (xmlStrcmp(node->name, XMLSTR("master-update-interval")) == 0) {
-            __read_int(doc, node, &configuration->master_update_interval, "<master-update-interval> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->master_update_interval);
         } else if (xmlStrcmp(node->name, XMLSTR("shoutcast-mount")) == 0) {
             if (configuration->shoutcast_mount)
                 xmlFree(configuration->shoutcast_mount);
@@ -1094,7 +1286,7 @@ static void _parse_root(xmlDocPtr       doc,
         } else if (xmlStrcmp(node->name, XMLSTR("limits")) == 0) {
             _parse_limits(doc, node->xmlChildrenNode, configuration);
         } else if (xmlStrcmp(node->name, XMLSTR("http-headers")) == 0) {
-            config_parse_http_headers(node->xmlChildrenNode, &(configuration->http_headers));
+            config_parse_http_headers(node->xmlChildrenNode, &(configuration->http_headers), configuration);
         } else if (xmlStrcmp(node->name, XMLSTR("relay")) == 0) {
             _parse_relay(doc, node->xmlChildrenNode, configuration, NULL);
         } else if (xmlStrcmp(node->name, XMLSTR("mount")) == 0) {
@@ -1112,6 +1304,8 @@ static void _parse_root(xmlDocPtr       doc,
         } else if (xmlStrcmp(node->name, XMLSTR("event-bindings")) == 0 ||
                    xmlStrcmp(node->name, XMLSTR("kartoffelsalat")) == 0) {
             _parse_events(&configuration->event, node->xmlChildrenNode);
+        } else {
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
     } while ((node = node->next));
 
@@ -1132,7 +1326,7 @@ static void _parse_root(xmlDocPtr       doc,
         }
         if (mount) {
             if (!mount->authstack) {
-                __append_old_style_auth(&mount->authstack,
+                __append_old_style_auth(configuration, &mount->authstack,
                                         CONFIG_LEGACY_SOURCE_NAME_GLOBAL,
                                         AUTH_TYPE_STATIC, "source",
                                         source_password, NULL,
@@ -1153,6 +1347,23 @@ static void _parse_root(xmlDocPtr       doc,
     if (configuration->port == 0)
         configuration->port = 8000;
 
+    if (!configuration->prng_seed) {
+        configuration->config_problems |= CONFIG_PROBLEM_PRNG;
+#ifndef _WIN32
+        configuration->prng_seed = calloc(1, sizeof(prng_seed_config_t));
+        if (configuration->prng_seed) {
+            configuration->prng_seed->filename = (char*)xmlStrdup(XMLSTR("linux")); // the linux profile is also fine on BSD.
+            configuration->prng_seed->type = PRNG_SEED_TYPE_PROFILE;
+            configuration->prng_seed->size = -1;
+            ICECAST_LOG_WARN("Warning, no PRNG seed configured, using default profile \"linux\".");
+        } else {
+            ICECAST_LOG_ERROR("No PRNG seed configured and unable to add one. PRNG is insecure.");
+        }
+#else
+        ICECAST_LOG_ERROR("No PRNG seed configured and unable to add one. PRNG is insecure.");
+#endif
+    }
+
     /* issue some warnings on bad configurations */
     if (!configuration->fileserve)
         ICECAST_LOG_WARN("Warning, serving of static files has been disabled "
@@ -1194,37 +1405,37 @@ static void _parse_limits(xmlDocPtr     doc,
             continue;
 
         if (xmlStrcmp(node->name, XMLSTR("clients")) == 0) {
-            __read_int(doc, node, &configuration->client_limit, "<clients> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->client_limit);
         } else if (xmlStrcmp(node->name, XMLSTR("sources")) == 0) {
-            __read_int(doc, node, &configuration->source_limit, "<sources> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->source_limit);
         } else if (xmlStrcmp(node->name, XMLSTR("bodysize")) == 0) {
-            __read_int(doc, node, &configuration->body_size_limit, "<bodysize> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->body_size_limit);
         } else if (xmlStrcmp(node->name, XMLSTR("queue-size")) == 0) {
-            __read_unsigned_int(doc, node, &configuration->queue_size_limit, "<queue-size> must not be empty.");
+            __read_unsigned_int(configuration, doc, node, &configuration->queue_size_limit);
         } else if (xmlStrcmp(node->name, XMLSTR("client-timeout")) == 0) {
-            __read_int(doc, node, &configuration->client_timeout, "<client-timeout> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->client_timeout);
         } else if (xmlStrcmp(node->name, XMLSTR("header-timeout")) == 0) {
-            __read_int(doc, node, &configuration->header_timeout, "<header-timeout> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->header_timeout);
         } else if (xmlStrcmp(node->name, XMLSTR("source-timeout")) == 0) {
-            __read_int(doc, node, &configuration->source_timeout, "<source-timeout> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->source_timeout);
         } else if (xmlStrcmp(node->name, XMLSTR("body-timeout")) == 0) {
-            __read_int(doc, node, &configuration->body_timeout, "<body-timeout> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->body_timeout);
         } else if (xmlStrcmp(node->name, XMLSTR("burst-on-connect")) == 0) {
-            ICECAST_LOG_WARN("<burst-on-connect> is deprecated, use <burst-size> instead.");
+            __found_bad_tag(configuration, node, BTR_OBSOLETE, "Use <burst-size>.");
             tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
             if (util_str_to_int(tmp, 0) == 0)
                 configuration->burst_size = 0;
             if (tmp)
                 xmlFree(tmp);
         } else if (xmlStrcmp(node->name, XMLSTR("burst-size")) == 0) {
-            __read_unsigned_int(doc, node, &configuration->burst_size, "<burst-size> must not be empty.");
-        } else if (node->type == XML_ELEMENT_NODE) {
-            ICECAST_LOG_ERROR("Unknown config tag: %s", node->name);
+            __read_unsigned_int(configuration, doc, node, &configuration->burst_size);
+        } else {
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
     } while ((node = node->next));
 }
 
-static void _parse_authentication_node(xmlNodePtr node, auth_stack_t  **authstack)
+static void _parse_authentication_node(ice_config_t *configuration, xmlNodePtr node, auth_stack_t  **authstack)
 {
     xmlChar *tmp;
 
@@ -1245,7 +1456,7 @@ static void _parse_authentication_node(xmlNodePtr node, auth_stack_t  **authstac
         if (xmlIsBlankNode(child))
             continue;
         if (xmlStrcmp(child->name, XMLSTR("role")) == 0) {
-            auth_t *auth = auth_get_authenticator(child);
+            auth_t *auth = auth_get_authenticator(configuration, child);
             auth_stack_push(authstack, auth);
             auth_release(auth);
         }
@@ -1254,7 +1465,8 @@ static void _parse_authentication_node(xmlNodePtr node, auth_stack_t  **authstac
 
 static void _parse_mount_oldstyle_authentication(mount_proxy    *mount,
                                                  xmlNodePtr      node,
-                                                 auth_stack_t  **authstack)
+                                                 auth_stack_t  **authstack,
+                                                 ice_config_t   *configuration)
 {
      int        allow_duplicate_users = 1;
      auth_t    *auth;
@@ -1287,13 +1499,13 @@ static void _parse_mount_oldstyle_authentication(mount_proxy    *mount,
          if (!allow_duplicate_users)
              xmlSetProp(node, XMLSTR("connections-per-user"), XMLSTR("0"));
 
-         auth = auth_get_authenticator(node);
+         auth = auth_get_authenticator(configuration, node);
          if (auth) {
              auth_stack_push(authstack, auth);
              auth_release(auth);
          }
 
-         __append_old_style_auth(authstack, NULL, AUTH_TYPE_ANONYMOUS,
+         __append_old_style_auth(configuration, authstack, NULL, AUTH_TYPE_ANONYMOUS,
              NULL, NULL, CONFIG_LEGACY_ANONYMOUS_METHODS, NULL, 0, NULL);
      } else if (strcmp(type, AUTH_TYPE_URL) == 0) {
          /* This block is super fun! Attention! Super fun ahead! Ladies and Gentlemen take care and watch your children! */
@@ -1375,17 +1587,17 @@ static void _parse_mount_oldstyle_authentication(mount_proxy    *mount,
              __append_old_style_url_event(&mount->event, "source-disconnect",
                  mount_add, "mount_remove", username, password);
 
-         __append_old_style_urlauth(authstack, listener_add, listener_remove,
+         __append_old_style_urlauth(configuration, authstack, listener_add, listener_remove,
              "listener_add", "listener_remove", username, password, 0,
              auth_header, timelimit_header, headers, header_prefix);
-         __append_old_style_urlauth(authstack, stream_auth, NULL, "stream_auth",
+         __append_old_style_urlauth(configuration, authstack, stream_auth, NULL, "stream_auth",
              NULL, username, password, 1, auth_header, timelimit_header,
              headers, header_prefix);
          if (listener_add)
-             __append_old_style_auth(authstack, NULL, AUTH_TYPE_ANONYMOUS, NULL,
+             __append_old_style_auth(configuration, authstack, NULL, AUTH_TYPE_ANONYMOUS, NULL,
                  NULL, CONFIG_LEGACY_ANONYMOUS_METHODS, NULL, 0, NULL);
          if (stream_auth)
-             __append_old_style_auth(authstack, NULL, AUTH_TYPE_ANONYMOUS, NULL,
+             __append_old_style_auth(configuration, authstack, NULL, AUTH_TYPE_ANONYMOUS, NULL,
                  NULL, CONFIG_LEGACY_SOURCE_METHODS, NULL, 0, NULL);
 
          if (mount_add)
@@ -1413,7 +1625,7 @@ static void _parse_mount_oldstyle_authentication(mount_proxy    *mount,
      } else {
          ICECAST_LOG_ERROR("Unknown authentication type in legacy mode. "
              "Anonymous listeners and global login for sources disabled.");
-         __append_old_style_auth(authstack, NULL, AUTH_TYPE_ANONYMOUS, NULL,
+         __append_old_style_auth(configuration, authstack, NULL, AUTH_TYPE_ANONYMOUS, NULL,
              NULL, NULL, NULL, 0, NULL);
      }
      xmlFree(type);
@@ -1487,7 +1699,7 @@ static void _parse_mount(xmlDocPtr      doc,
             if(tmp)
                 xmlFree(tmp);
         } else if (xmlStrcmp(node->name, XMLSTR("max-listeners")) == 0) {
-            __read_int(doc, node, &mount->max_listeners, "<max-listeners> must not be empty.");
+            __read_int(configuration, doc, node, &mount->max_listeners);
         } else if (xmlStrcmp(node->name, XMLSTR("max-history")) == 0) {
             tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
             mount->max_history = util_str_to_int(tmp, mount->max_history);
@@ -1499,16 +1711,14 @@ static void _parse_mount(xmlDocPtr      doc,
             mount->charset = (char *)xmlNodeListGetString(doc,
                 node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("mp3-metadata-interval")) == 0) {
-            ICECAST_LOG_WARN("<mp3-metadata-interval> is deprecated and will be "
-                "removed in a future version. "
-                "Please use <icy-metadata-interval> instead.");
+            __found_bad_tag(configuration, node, BTR_OBSOLETE, "Use <icy-metadata-interval>.");
                 /* FIXME when do we plan to remove this? */
-            __read_int(doc, node, &mount->mp3_meta_interval, "<mp3-metadata-interval> must not be empty.");
+            __read_int(configuration, doc, node, &mount->mp3_meta_interval);
         } else if (xmlStrcmp(node->name, XMLSTR("icy-metadata-interval")) == 0) {
-            __read_int(doc, node, &mount->mp3_meta_interval, "<icy-metadata-interval> must not be empty.");
+            __read_int(configuration, doc, node, &mount->mp3_meta_interval);
         } else if (xmlStrcmp(node->name, XMLSTR("fallback-override")) == 0) {
             tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
-            mount->fallback_override = util_str_to_bool(tmp);
+            mount->fallback_override = config_str_to_fallback_override_t(configuration, node, tmp);
             if(tmp)
                 xmlFree(tmp);
         } else if (xmlStrcmp(node->name, XMLSTR("no-mount")) == 0) {
@@ -1517,8 +1727,7 @@ static void _parse_mount(xmlDocPtr      doc,
             if(tmp)
                 xmlFree(tmp);
         } else if (xmlStrcmp(node->name, XMLSTR("no-yp")) == 0) {
-            ICECAST_LOG_WARN("<no-yp> defined. Please use <public>. This is "
-                "deprecated and will be removed in a future version.");
+            __found_bad_tag(configuration, node, BTR_OBSOLETE, "Use <public>.");
                 /* FIXME when do we plan to remove this? */
             tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
             mount->yp_public = util_str_to_bool(tmp) == 0 ? -1 : 0;
@@ -1533,9 +1742,9 @@ static void _parse_mount(xmlDocPtr      doc,
             tmp = (char *)xmlGetProp(node, XMLSTR("type"));
             if (tmp) {
                 xmlFree(tmp);
-                _parse_mount_oldstyle_authentication(mount, node, &authstack);
+                _parse_mount_oldstyle_authentication(mount, node, &authstack, configuration);
             } else {
-                _parse_authentication_node(node, &authstack);
+                _parse_authentication_node(configuration, node, &authstack);
             }
         } else if (xmlStrcmp(node->name, XMLSTR("on-connect")) == 0) {
             tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
@@ -1552,13 +1761,13 @@ static void _parse_mount(xmlDocPtr      doc,
                 xmlFree(tmp);
             }
         } else if (xmlStrcmp(node->name, XMLSTR("max-listener-duration")) == 0) {
-            __read_unsigned_int(doc, node, &mount->max_listener_duration, "<max-listener-duration> must not be empty.");
+            __read_unsigned_int(configuration, doc, node, &mount->max_listener_duration);
         } else if (xmlStrcmp(node->name, XMLSTR("queue-size")) == 0) {
-            __read_unsigned_int(doc, node, &mount->queue_size_limit, "<queue-size> must not be empty.");
+            __read_unsigned_int(configuration, doc, node, &mount->queue_size_limit);
         } else if (xmlStrcmp(node->name, XMLSTR("source-timeout")) == 0) {
-            __read_unsigned_int(doc, node, &mount->source_timeout, "<source-timeout> must not be empty.");
+            __read_unsigned_int(configuration, doc, node, &mount->source_timeout);
         } else if (xmlStrcmp(node->name, XMLSTR("burst-size")) == 0) {
-            __read_int(doc, node, &mount->burst_size, "<burst-size> must not be empty.");
+            __read_int(configuration, doc, node, &mount->burst_size);
         } else if (xmlStrcmp(node->name, XMLSTR("cluster-password")) == 0) {
             mount->cluster_password = (char *)xmlNodeListGetString(doc,
                 node->xmlChildrenNode, 1);
@@ -1590,10 +1799,12 @@ static void _parse_mount(xmlDocPtr      doc,
                 node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("http-headers")) == 0) {
             config_parse_http_headers(node->xmlChildrenNode,
-                &(mount->http_headers));
+                &(mount->http_headers), configuration);
         } else if (xmlStrcmp(node->name, XMLSTR("event-bindings")) == 0 ||
                    xmlStrcmp(node->name, XMLSTR("kartoffelsalat")) == 0) {
             _parse_events(&mount->event, node->xmlChildrenNode);
+        } else {
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
     } while ((node = node->next));
 
@@ -1618,7 +1829,7 @@ static void _parse_mount(xmlDocPtr      doc,
 
     if (password) {
         auth_stack_t *old_style = NULL;
-        __append_old_style_auth(&old_style, CONFIG_LEGACY_SOURCE_NAME_MOUNT,
+        __append_old_style_auth(configuration, &old_style, CONFIG_LEGACY_SOURCE_NAME_MOUNT,
             AUTH_TYPE_STATIC, username ? username : "source", password, NULL,
             CONFIG_LEGACY_SOURCE_METHODS, CONFIG_LEGACY_SOURCE_ALLOW_WEB, CONFIG_LEGACY_SOURCE_ALLOW_ADMIN);
         if (authstack) {
@@ -1665,7 +1876,7 @@ static void _parse_mount(xmlDocPtr      doc,
         current = current->next;
     }
 
-    if (!mount->fallback_mount && (mount->fallback_when_full || mount->fallback_override)) {
+    if (!mount->fallback_mount && (mount->fallback_when_full || mount->fallback_override != FALLBACK_OVERRIDE_NONE)) {
         ICECAST_LOG_WARN("Config for mount %s contains fallback options "
             "but no fallback mount.", mount->mountname);
     }
@@ -1678,7 +1889,8 @@ static void _parse_mount(xmlDocPtr      doc,
 }
 
 void config_parse_http_headers(xmlNodePtr                  node,
-                               ice_config_http_header_t  **http_headers)
+                               ice_config_http_header_t  **http_headers,
+                               ice_config_t               *configuration)
 {
     ice_config_http_header_t *header;
     ice_config_http_header_t *next;
@@ -1707,8 +1919,7 @@ void config_parse_http_headers(xmlNodePtr                  node,
             } else if (strcmp(tmp, "cors") == 0 || strcmp(tmp, "corpse") == 0) {
                 type = HTTP_HEADER_TYPE_CORS;
             } else {
-                ICECAST_LOG_WARN("Unknown type %s for "
-                    "HTTP Header %s", tmp, name);
+                __found_bad_tag(configuration, node, BTR_INVALID, tmp);
                 xmlFree(tmp);
                 break;
             }
@@ -1751,7 +1962,8 @@ void config_parse_http_headers(xmlNodePtr                  node,
 
 static void _parse_relay_upstream(xmlDocPtr      doc,
                                   xmlNodePtr     node,
-                                  relay_config_upstream_t *upstream)
+                                  relay_config_upstream_t *upstream,
+                                  ice_config_t  *configuration)
 {
     char         *tmp;
 
@@ -1767,7 +1979,7 @@ static void _parse_relay_upstream(xmlDocPtr      doc,
             upstream->server = (char *)xmlNodeListGetString(doc,
                 node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("port")) == 0) {
-            __read_int(doc, node, &upstream->port, "<port> setting must not be empty.");
+            __read_int(configuration, doc, node, &upstream->port);
         } else if (xmlStrcmp(node->name, XMLSTR("mount")) == 0) {
             if (upstream->mount)
                 xmlFree(upstream->mount);
@@ -1828,7 +2040,7 @@ static void _parse_relay(xmlDocPtr      doc,
     relay->upstream_default.mp3metadata     = 1;
     relay->on_demand                        = configuration->on_demand;
 
-    _parse_relay_upstream(doc, node, &(relay->upstream_default));
+    _parse_relay_upstream(doc, node, &(relay->upstream_default), configuration);
 
     do {
         if (node == NULL)
@@ -1858,17 +2070,25 @@ static void _parse_relay(xmlDocPtr      doc,
                 if (n) {
                     relay->upstream = n;
                     memset(&(n[relay->upstreams]), 0, sizeof(relay_config_upstream_t));
-                    _parse_relay_upstream(doc, node->xmlChildrenNode, &(n[relay->upstreams]));
+                    _parse_relay_upstream(doc, node->xmlChildrenNode, &(n[relay->upstreams]), configuration);
                     relay->upstreams++;
                 }
             } else if (strcmp(tmp, "default") == 0) {
-                _parse_relay_upstream(doc, node->xmlChildrenNode, &(relay->upstream_default));
+                _parse_relay_upstream(doc, node->xmlChildrenNode, &(relay->upstream_default), configuration);
             } else {
+                __found_bad_tag(configuration, node, BTR_INVALID, tmp);
                 ICECAST_LOG_WARN("<upstream> of unknown type is ignored.");
             }
 
             if (tmp)
                 xmlFree(tmp);
+        } else if (xmlStrcmp(node->name, XMLSTR("server")) == 0 || xmlStrcmp(node->name, XMLSTR("port")) == 0 ||
+                   xmlStrcmp(node->name, XMLSTR("mount")) == 0 || xmlStrcmp(node->name, XMLSTR("relay-shoutcast-metadata")) == 0 ||
+                   xmlStrcmp(node->name, XMLSTR("username")) == 0 || xmlStrcmp(node->name, XMLSTR("password")) == 0 ||
+                   xmlStrcmp(node->name, XMLSTR("bind")) == 0) {
+            __found_bad_tag(configuration, node, BTR_OBSOLETE, "Use a <upstream type=\"default\"> block.");
+        } else {
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
     } while ((node = node->next));
 
@@ -1897,12 +2117,12 @@ static void _parse_listen_socket(xmlDocPtr      doc,
 
     tmp = (char*)xmlGetProp(node, XMLSTR("on-behalf-of"));
     if (tmp) {
-        listener->on_behalf_of = config_href_to_id(tmp);
+        listener->on_behalf_of = config_href_to_id(configuration, node, tmp);
         xmlFree(tmp);
     }
 
     tmp  = (char *)xmlGetProp(node, XMLSTR("type"));
-    listener->type = config_str_to_listener_type(tmp);
+    listener->type = config_str_to_listener_type(configuration, node, tmp);
     xmlFree(tmp);
 
     node = node->xmlChildrenNode;
@@ -1945,13 +2165,15 @@ static void _parse_listen_socket(xmlDocPtr      doc,
             listener->bind_address = (char *)xmlNodeListGetString(doc,
                 node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("so-sndbuf")) == 0) {
-            __read_int(doc, node, &listener->so_sndbuf, "<so-sndbuf> must not be empty.");
+            __read_int(configuration, doc, node, &listener->so_sndbuf);
         } else if (xmlStrcmp(node->name, XMLSTR("listen-backlog")) == 0) {
-            __read_int(doc, node, &listener->listen_backlog, "<listen-backlog> must not be empty.");
+            __read_int(configuration, doc, node, &listener->listen_backlog);
         } else if (xmlStrcmp(node->name, XMLSTR("authentication")) == 0) {
-            _parse_authentication_node(node, &(listener->authstack));
+            _parse_authentication_node(configuration, node, &(listener->authstack));
         } else if (xmlStrcmp(node->name, XMLSTR("http-headers")) == 0) {
-            config_parse_http_headers(node->xmlChildrenNode, &(listener->http_headers));
+            config_parse_http_headers(node->xmlChildrenNode, &(listener->http_headers), configuration);
+        } else {
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
     } while ((node = node->next));
 
@@ -2019,18 +2241,20 @@ static void _parse_authentication(xmlDocPtr doc, xmlNodePtr node,
                 xmlFree(configuration->shoutcast_user);
             configuration->shoutcast_user = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("role")) == 0) {
-            auth_t *auth = auth_get_authenticator(node);
+            auth_t *auth = auth_get_authenticator(configuration, node);
             auth_stack_push(&new_style, auth);
             auth_release(auth);
+        } else {
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
     } while ((node = node->next));
 
     if (admin_password && admin_username)
-        __append_old_style_auth(&old_style, CONFIG_LEGACY_ADMIN_NAME, AUTH_TYPE_STATIC,
+        __append_old_style_auth(configuration, &old_style, CONFIG_LEGACY_ADMIN_NAME, AUTH_TYPE_STATIC,
             admin_username, admin_password, NULL, CONFIG_LEGACY_ADMIN_METHODS, CONFIG_LEGACY_ADMIN_ALLOW_WEB, CONFIG_LEGACY_ADMIN_ALLOW_ADMIN);
 
     if (relay_password && relay_username)
-        __append_old_style_auth(&old_style, CONFIG_LEGACY_RELAY_NAME, AUTH_TYPE_STATIC,
+        __append_old_style_auth(configuration, &old_style, CONFIG_LEGACY_RELAY_NAME, AUTH_TYPE_STATIC,
             relay_username, relay_password, NULL, CONFIG_LEGACY_RELAY_METHODS, CONFIG_LEGACY_RELAY_ALLOW_WEB, CONFIG_LEGACY_RELAY_ALLOW_ADMIN);
 
     if (admin_password)
@@ -2050,7 +2274,7 @@ static void _parse_authentication(xmlDocPtr doc, xmlNodePtr node,
     }
 
     /* default unauthed anonymous account */
-    __append_old_style_auth(&old_style, CONFIG_LEGACY_ANONYMOUS_NAME, AUTH_TYPE_ANONYMOUS,
+    __append_old_style_auth(configuration, &old_style, CONFIG_LEGACY_ANONYMOUS_NAME, AUTH_TYPE_ANONYMOUS,
         NULL, NULL, NULL, CONFIG_LEGACY_ANONYMOUS_METHODS, CONFIG_LEGACY_ANONYMOUS_ALLOW_WEB, CONFIG_LEGACY_ANONYMOUS_ALLOW_ADMIN);
     if (!old_style)
         ICECAST_LOG_ERROR("BAD. old_style=NULL");
@@ -2084,9 +2308,9 @@ static void _parse_oldstyle_directory(xmlDocPtr      doc,
                 xmlFree(yp_dir->url);
             yp_dir->url = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("yp-url-timeout")) == 0) {
-            __read_int(doc, node, &yp_dir->timeout, "<yp-url-timeout> must not be empty.");
+            __read_int(configuration, doc, node, &yp_dir->timeout);
         } else if (xmlStrcmp(node->name, XMLSTR("touch-interval")) == 0) {
-            __read_int(doc, node, &yp_dir->touch_interval, "<touch-interval> must not be empty.");
+            __read_int(configuration, doc, node, &yp_dir->touch_interval);
         }
     } while ((node = node->next));
 
@@ -2148,7 +2372,8 @@ static void _parse_yp_directory(xmlDocPtr      doc,
                     "Only the last one will be used.");
                 free(yp_dir->listen_socket_id);
             }
-            yp_dir->listen_socket_id = config_href_to_id(opt->value);
+            /* FIXME: Pass the correct node to config_href_to_id(). */
+            yp_dir->listen_socket_id = config_href_to_id(configuration, NULL, opt->value);
         } else {
             ICECAST_LOG_WARN("Invalid YP <option> with unknown 'name' attribute.");
         }
@@ -2212,7 +2437,7 @@ static void _parse_resource(xmlDocPtr      doc,
 
     temp = (char *)xmlGetProp(node, XMLSTR("listen-socket"));
     if (temp) {
-        resource->listen_socket = config_href_to_id(temp);
+        resource->listen_socket = config_href_to_id(configuration, node, temp);
         xmlFree(temp);
     }
 
@@ -2223,7 +2448,7 @@ static void _parse_resource(xmlDocPtr      doc,
 
     temp = (char *)xmlGetProp(node, XMLSTR("omode"));
     if (temp) {
-        resource->omode = config_str_to_omode(temp);
+        resource->omode = config_str_to_omode(configuration, node, temp);
         xmlFree(temp);
     } else {
         resource->omode = OMODE_DEFAULT;
@@ -2359,6 +2584,8 @@ static void _parse_paths(xmlDocPtr      doc,
             xmlFree(temp);
         } else if (xmlStrcmp(node->name, XMLSTR("resource")) == 0 || xmlStrcmp(node->name, XMLSTR("alias")) == 0) {
             _parse_resource(doc, node, configuration);
+        } else {
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
     } while ((node = node->next));
 }
@@ -2395,7 +2622,7 @@ static void _parse_logging(xmlDocPtr        doc,
                 xmlFree(configuration->playlist_log);
             configuration->playlist_log = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
         } else if (xmlStrcmp(node->name, XMLSTR("logsize")) == 0) {
-            __read_int(doc, node, &configuration->logsize, "<logsize> must not be empty.");
+            __read_int(configuration, doc, node, &configuration->logsize);
         } else if (xmlStrcmp(node->name, XMLSTR("loglevel")) == 0) {
            char *tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
            configuration->loglevel = util_str_to_loglevel(tmp);
@@ -2413,7 +2640,7 @@ static void _parse_logging(xmlDocPtr        doc,
             int val = CONFIG_DEFAULT_LOG_LINES_KEPT;
             char *logfile = (char *)xmlGetProp(node, XMLSTR("logfile"));
 
-            __read_int(doc, node, &val, "<memorybacklog> must not be empty.");
+            __read_int(configuration, doc, node, &val);
 
             if (logfile) {
                 if (!strcmp(logfile, "error")) {
@@ -2431,6 +2658,8 @@ static void _parse_logging(xmlDocPtr        doc,
                 configuration->access_log_lines_kept = val;
                 configuration->playlist_log_lines_kept = val;
             }
+        } else {
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
     } while ((node = node->next));
 }
@@ -2477,7 +2706,7 @@ static void _parse_tls_context(xmlDocPtr       doc,
                 xmlFree(context->cipher_list);
             context->cipher_list = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
         } else {
-            ICECAST_LOG_ERROR("Unknown config tag: %s", node->name);
+            __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
         }
 
    } while ((node = node->next));
@@ -2523,6 +2752,44 @@ static void _parse_security(xmlDocPtr       doc,
                }
            } while((node = node->next));
            node = oldnode;
+       } else if (xmlStrcmp(node->name, XMLSTR("prng-seed")) == 0) {
+           tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
+           if (tmp) {
+               prng_seed_config_t *seed = calloc(1, sizeof(prng_seed_config_t));
+               seed->filename = tmp;
+               seed->type = PRNG_SEED_TYPE_READ_ONCE;
+               seed->size = -1;
+
+               tmp = (char *)xmlGetProp(node, XMLSTR("type"));
+               if (tmp) {
+                   if (strcmp(tmp, "read-once") == 0) {
+                       seed->type = PRNG_SEED_TYPE_READ_ONCE;
+                   } else if (strcmp(tmp, "read-write") == 0) {
+                       seed->type = PRNG_SEED_TYPE_READ_WRITE;
+                   } else if (strcmp(tmp, "device") == 0) {
+                       seed->type = PRNG_SEED_TYPE_DEVICE;
+                   } else if (strcmp(tmp, "static") == 0) {
+                       seed->type = PRNG_SEED_TYPE_STATIC;
+                   } else if (strcmp(tmp, "profile") == 0) {
+                       seed->type = PRNG_SEED_TYPE_PROFILE;
+                   } else {
+                       ICECAST_LOG_WARN("Unknown type for <prng-seed>: %s", tmp);
+                   }
+                   xmlFree(tmp);
+               }
+
+               tmp = (char *)xmlGetProp(node, XMLSTR("size"));
+               if (tmp) {
+                   seed->size = atoi(tmp);
+                   xmlFree(tmp);
+               }
+
+               if (configuration->prng_seed)
+                   seed->next = configuration->prng_seed;
+               configuration->prng_seed = seed;
+           }
+       } else {
+           __found_bad_tag(configuration, node, BTR_UNKNOWN, NULL);
        }
    } while ((node = node->next));
 }
@@ -2609,7 +2876,7 @@ static void merge_mounts(mount_proxy * dst, mount_proxy * src)
         dst->max_listeners = src->max_listeners;
     if (!dst->fallback_mount)
         dst->fallback_mount = (char*)xmlStrdup((xmlChar*)src->fallback_mount);
-    if (!dst->fallback_override)
+    if (dst->fallback_override == FALLBACK_OVERRIDE_NONE)
         dst->fallback_override = src->fallback_override;
     if (!dst->no_mount)
         dst->no_mount = src->no_mount;
diff --git a/src/cfgfile.h b/src/cfgfile.h
index 3d383a60a1e1e6875f30fee77be67e40d291fd38..77c2d8dedefb3efb7376ab9de6fb528ba8b98d5f 100644
--- a/src/cfgfile.h
+++ b/src/cfgfile.h
@@ -31,6 +31,10 @@
 #define CONFIG_PROBLEM_HOSTNAME         0x0001U
 #define CONFIG_PROBLEM_LOCATION         0x0002U
 #define CONFIG_PROBLEM_ADMIN            0x0004U
+#define CONFIG_PROBLEM_PRNG             0x0008U
+#define CONFIG_PROBLEM_UNKNOWN_NODE     0x0010U
+#define CONFIG_PROBLEM_OBSOLETE_NODE    0x0020U
+#define CONFIG_PROBLEM_INVALID_NODE     0x0040U
 
 typedef enum _http_header_type {
     /* static: headers are passed as is to the client. */
@@ -66,6 +70,12 @@ typedef enum _mount_type {
  MOUNT_TYPE_DEFAULT
 } mount_type;
 
+typedef enum {
+    FALLBACK_OVERRIDE_NONE = 0,
+    FALLBACK_OVERRIDE_ALL,
+    FALLBACK_OVERRIDE_OWN
+} fallback_override_t;
+
 typedef struct _mount_proxy {
     /* The mountpoint this proxy is used for */
     char *mountname;
@@ -88,7 +98,7 @@ typedef struct _mount_proxy {
     /* When this source arrives, do we steal back
      * clients from the fallback?
      */
-    int fallback_override;
+    fallback_override_t fallback_override;
     /* Do we permit direct requests of this mountpoint?
      * (or only indirect, through fallbacks)
      */
@@ -201,6 +211,22 @@ typedef struct {
     relay_config_upstream_t upstream_default;
 } relay_config_t;
 
+typedef enum {
+    PRNG_SEED_TYPE_READ_ONCE,
+    PRNG_SEED_TYPE_READ_WRITE,
+    PRNG_SEED_TYPE_DEVICE,
+    PRNG_SEED_TYPE_STATIC,
+    PRNG_SEED_TYPE_PROFILE
+} prng_seed_type_t;
+
+typedef struct prng_seed_config_tag prng_seed_config_t;
+struct prng_seed_config_tag {
+    char *filename;
+    prng_seed_type_t type;
+    ssize_t size;
+    prng_seed_config_t *next;
+};
+
 struct ice_config_tag {
     char *config_filename;
 
@@ -259,6 +285,7 @@ struct ice_config_tag {
     char *allowfile;
     char *webroot_dir;
     char *adminroot_dir;
+    prng_seed_config_t *prng_seed;
     resource_t *resources;
     reportxml_database_t *reportxml_db;
 
@@ -290,7 +317,7 @@ typedef struct {
 void config_initialize(void);
 void config_shutdown(void);
 
-operation_mode config_str_to_omode(const char *str);
+operation_mode config_str_to_omode(ice_config_t *configuration, xmlNodePtr node, const char *str);
 
 void config_reread_config(void);
 int config_parse_file(const char *filename, ice_config_t *configuration);
@@ -307,7 +334,8 @@ config_options_t *config_parse_options(xmlNodePtr node);
 void config_clear_options(config_options_t *options);
 
 void config_parse_http_headers(xmlNodePtr                  node,
-                               ice_config_http_header_t  **http_headers);
+                               ice_config_http_header_t  **http_headers,
+                               ice_config_t               *configuration);
 void config_clear_http_header(ice_config_http_header_t *header);
 
 int config_rehash(void);
diff --git a/src/client.c b/src/client.c
index 44307e480580f1dedcc3e743a922445e09d03c12..97649b8e7f9cd8ea1a6d575ddd113d21502d4450 100644
--- a/src/client.c
+++ b/src/client.c
@@ -101,6 +101,32 @@ const char * client_protocol_to_string(protocol_t protocol)
     return NULL;
 }
 
+int client_compare(void *compare_arg, void *a, void *b)
+{
+    client_t *clienta = (client_t *) a;
+    client_t *clientb = (client_t *) b;
+
+    (void)compare_arg;
+
+    connection_t *cona = clienta->con;
+    connection_t *conb = clientb->con;
+
+    if (cona->id < conb->id) return -1;
+    if (cona->id > conb->id) return 1;
+
+    return 0;
+}
+
+void client_initialize(void)
+{
+    global_client_list = avl_tree_new(client_compare, NULL);
+}
+
+void client_shutdown(void)
+{
+    avl_tree_free(global_client_list, NULL);
+}
+
 /* create a client_t with the provided connection and parser details. Return
  * 0 on success, -1 if server limit has been reached.  In either case a
  * client_t is returned just in case a message needs to be returned. Should
@@ -138,8 +164,13 @@ int client_create(client_t **c_ptr, connection_t *con, http_parser_t *parser)
     client->refbuf->len = 0; /* force reader code to ignore buffer contents */
     client->pos = 0;
     client->write_to_client = format_generic_write_to_client;
+    navigation_history_init(&(client->history));
     *c_ptr = client;
 
+    avl_tree_wlock(global_client_list);
+    avl_insert(global_client_list, client);
+    avl_tree_unlock(global_client_list);
+
     listener_real = listensocket_get_listener(con->listensocket_real);
     listener_effective = listensocket_get_listener(con->listensocket_effective);
     ICECAST_LOG_DEBUG("Client %p created on connection %p (connection ID: %llu, socket real: %p \"%H\", socket effective: %p \"%H\")",
@@ -267,6 +298,10 @@ void client_destroy(client_t *client)
 
     fastevent_emit(FASTEVENT_TYPE_CLIENT_DESTROY, FASTEVENT_FLAG_MODIFICATION_ALLOWED, FASTEVENT_DATATYPE_CLIENT, client);
 
+    avl_tree_wlock(global_client_list);
+    avl_delete(global_client_list, client, NULL);
+    avl_tree_unlock(global_client_list);
+
     if (client->reuse != ICECAST_REUSE_CLOSE) {
         /* only reuse the client if we reached the body's EOF. */
         if (client_body_eof(client) == 1) {
@@ -310,6 +345,7 @@ void client_destroy(client_t *client)
     free(client->password);
     free(client->role);
     acl_release(client->acl);
+    navigation_history_clear(&(client->history));
 
     free(client);
 }
diff --git a/src/client.h b/src/client.h
index bb62274fcb98737776c337f257f90390445bddb2..0d01ecfcf3cb63f96dd6253943dc8db0e12d3e6c 100644
--- a/src/client.h
+++ b/src/client.h
@@ -23,6 +23,7 @@
 #include "common/httpp/encoding.h"
 
 #include "icecasttypes.h"
+#include "navigation.h"
 #include "errors.h"
 #include "refbuf.h"
 #include "module.h"
@@ -114,6 +115,9 @@ struct _client_tag {
     module_t *handler_module;
     char *handler_function;
 
+    /* History of navigated mount points */
+    navigation_history_t history;
+
     /* is client getting intro data */
     long intro_offset;
 
@@ -139,9 +143,16 @@ struct _client_tag {
     int (*check_buffer)(source_t *source, client_t *client);
 };
 
+avl_tree *global_client_list;
+
 protocol_t client_protocol_from_string(const char *str);
 const char * client_protocol_to_string(protocol_t protocol);
 
+void client_initialize(void);
+void client_shutdown(void);
+
+int client_compare(void *compare_arg, void *a, void *b); // for avl.
+
 int client_create (client_t **c_ptr, connection_t *con, http_parser_t *parser);
 void client_complete(client_t *client);
 void client_destroy(client_t *client);
diff --git a/src/connection.c b/src/connection.c
index 373e5cd148da3ff486497c3f8ab56b60131eb11e..5a1d14424321eea42184fe68492b602dcd191bfd 100644
--- a/src/connection.c
+++ b/src/connection.c
@@ -61,6 +61,7 @@
 #include "refobject.h"
 #include "listensocket.h"
 #include "fastevent.h"
+#include "navigation.h"
 
 #define CATMODULE "connection"
 
@@ -953,6 +954,7 @@ static void __add_listener_to_source(source_t *source, client_t *client)
             }
             ICECAST_LOG_INFO("stream full, trying %s", next->mount);
             source = next;
+            navigation_history_navigate_to(&(client->history), source->identifier, NAVIGATION_DIRECTION_DOWN);
             loop--;
             continue;
         }
@@ -1048,7 +1050,7 @@ static void _handle_get_request(client_t *client) {
 
     avl_tree_rlock(global.source_tree);
     /* let's see if this is a source or just a random fserve file */
-    source = source_find_mount(client->uri);
+    source = source_find_mount_with_history(client->uri, &(client->history));
     if (source) {
         /* true mount */
         do {
@@ -1690,7 +1692,7 @@ static void _handle_connection(void)
                     continue;
                 }
 
-                client->mode = config_str_to_omode(httpp_get_param(client->parser, "omode"));
+                client->mode = config_str_to_omode(NULL, NULL, httpp_get_param(client->parser, "omode"));
 
                 if (_handle_resources(client, &uri) != 0) {
                     client_destroy (client);
diff --git a/src/digest.c b/src/digest.c
new file mode 100644
index 0000000000000000000000000000000000000000..9eff7ba1cb7481a912202d74e90f94508c4940cc
--- /dev/null
+++ b/src/digest.c
@@ -0,0 +1,644 @@
+/* Icecast
+ *
+ * This program is distributed under the GNU General Public License, version 2.
+ * A copy of this license is included with this source.
+ *
+ * Copyright 2020,      Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>
+ *
+ * The SHA3 implementation is based on rhash:
+ * 2013 by Aleksey Kravchenko <rhash.admin@gmail.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "digest.h"
+#include "md5.h"
+
+#include "logging.h"
+#define CATMODULE "digest"
+
+struct digest_tag {
+    /* base object */
+    refobject_base_t __base;
+
+    /* metadata */
+    digest_algo_t algo;
+
+    /* state */
+    int done;
+    union {
+        struct MD5Context md5;
+        struct {
+            /* 1600 bits algorithm hashing state */
+            uint64_t hash[25];
+            /* 1536-bit buffer for leftovers */
+            char message[24*8];
+            /* count of bytes in the message[] buffer */
+            size_t rest;
+            /* size of a message block processed at once */
+            size_t block_size;
+        } sha3;
+    } state;
+};
+
+
+struct hmac_tag {
+    /* base object */
+    refobject_base_t __base;
+
+    digest_algo_t algo;
+    char *key;
+    size_t key_len;
+    digest_t * inner;
+};
+
+static void __hmac_free(refobject_t self, void **userdata)
+{
+    hmac_t *hmac = REFOBJECT_TO_TYPE(self, hmac_t *);
+    free(hmac->key);
+    refobject_unref(hmac->inner);
+}
+
+REFOBJECT_DEFINE_TYPE(digest_t);
+REFOBJECT_DEFINE_TYPE(hmac_t,
+        REFOBJECT_DEFINE_TYPE_FREE(__hmac_free)
+        );
+
+#define ROTL64(qword, n) ((qword) << (n) ^ ((qword) >> (64 - (n))))
+
+#ifdef WORDS_BIGENDIAN
+// TODO: Improve this.
+static inline uint64_t digest_letoh64(uint64_t x)
+{
+    union {
+        uint64_t num;
+        char b[8];
+    } in, out;
+    int i;
+
+    in.num = x;
+    for (i = 0; i < 8; i++)
+        out.b[i] = in.b[7 - i];
+    return out.num;
+}
+#else
+#define digest_letoh64(x) (x)
+#endif
+
+/* SHA3 (Keccak) constants for 24 rounds */
+static uint64_t keccak_round_constants[] = {
+        0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808AULL, 0x8000000080008000ULL,
+        0x000000000000808BULL, 0x0000000080000001ULL, 0x8000000080008081ULL, 0x8000000000008009ULL,
+        0x000000000000008AULL, 0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000AULL,
+        0x000000008000808BULL, 0x800000000000008BULL, 0x8000000000008089ULL, 0x8000000000008003ULL,
+        0x8000000000008002ULL, 0x8000000000000080ULL, 0x000000000000800AULL, 0x800000008000000AULL,
+        0x8000000080008081ULL, 0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL
+};
+
+static inline void sha3_init(digest_t *digest, unsigned int bits)
+{
+    /* The Keccak capacity parameter = bits * 2 */
+    unsigned int rate = 1600 - bits * 2;
+
+    digest->state.sha3.block_size = rate / 8;
+}
+
+#define XORED_A(i) A[(i)] ^ A[(i) + 5] ^ A[(i) + 10] ^ A[(i) + 15] ^ A[(i) + 20]
+#define THETA_STEP(i) \
+        A[(i)]      ^= D[(i)]; \
+        A[(i) + 5]  ^= D[(i)]; \
+        A[(i) + 10] ^= D[(i)]; \
+        A[(i) + 15] ^= D[(i)]; \
+        A[(i) + 20] ^= D[(i)] 
+
+/* Keccak theta() transformation */
+static inline void keccak_theta(uint64_t *A)
+{
+    uint64_t D[5];
+    D[0] = ROTL64(XORED_A(1), 1) ^ XORED_A(4);
+    D[1] = ROTL64(XORED_A(2), 1) ^ XORED_A(0);
+    D[2] = ROTL64(XORED_A(3), 1) ^ XORED_A(1);
+    D[3] = ROTL64(XORED_A(4), 1) ^ XORED_A(2);
+    D[4] = ROTL64(XORED_A(0), 1) ^ XORED_A(3);
+    THETA_STEP(0);
+    THETA_STEP(1);
+    THETA_STEP(2);
+    THETA_STEP(3);
+    THETA_STEP(4);
+}
+
+/* Keccak pi() transformation */
+static inline void keccak_pi(uint64_t *A)
+{
+    uint64_t A1;
+    A1 = A[1];
+    A[ 1] = A[ 6];
+    A[ 6] = A[ 9];
+    A[ 9] = A[22];
+    A[22] = A[14];
+    A[14] = A[20];
+    A[20] = A[ 2];
+    A[ 2] = A[12];
+    A[12] = A[13];
+    A[13] = A[19];
+    A[19] = A[23];
+    A[23] = A[15];
+    A[15] = A[ 4];
+    A[ 4] = A[24];
+    A[24] = A[21];
+    A[21] = A[ 8];
+    A[ 8] = A[16];
+    A[16] = A[ 5];
+    A[ 5] = A[ 3];
+    A[ 3] = A[18];
+    A[18] = A[17];
+    A[17] = A[11];
+    A[11] = A[ 7];
+    A[ 7] = A[10];
+    A[10] = A1;
+    /* note: A[ 0] is left as is */
+}
+
+#define CHI_STEP(i) \
+        A0 = A[0 + (i)]; \
+        A1 = A[1 + (i)]; \
+        A[0 + (i)] ^= ~A1 & A[2 + (i)]; \
+        A[1 + (i)] ^= ~A[2 + (i)] & A[3 + (i)]; \
+        A[2 + (i)] ^= ~A[3 + (i)] & A[4 + (i)]; \
+        A[3 + (i)] ^= ~A[4 + (i)] & A0; \
+        A[4 + (i)] ^= ~A0 & A1
+
+/* Keccak chi() transformation */
+static inline void keccak_chi(uint64_t *A)
+{
+    uint64_t A0, A1;
+    CHI_STEP(0);
+    CHI_STEP(5);
+    CHI_STEP(10);
+    CHI_STEP(15);
+    CHI_STEP(20);
+}
+
+/**
+ * The core transformation. Process the specified block of data.
+ *
+ * @param hash the algorithm state
+ * @param block the message block to process
+ * @param block_size the size of the processed block in bytes
+ */
+static inline void sha3_process_block(uint64_t hash[25], const uint64_t *block, size_t block_size)
+{
+    size_t round;
+
+    /* expanded loop */
+    hash[ 0] ^= digest_letoh64(block[ 0]);
+    hash[ 1] ^= digest_letoh64(block[ 1]);
+    hash[ 2] ^= digest_letoh64(block[ 2]);
+    hash[ 3] ^= digest_letoh64(block[ 3]);
+    hash[ 4] ^= digest_letoh64(block[ 4]);
+    hash[ 5] ^= digest_letoh64(block[ 5]);
+    hash[ 6] ^= digest_letoh64(block[ 6]);
+    hash[ 7] ^= digest_letoh64(block[ 7]);
+    hash[ 8] ^= digest_letoh64(block[ 8]);
+    /* if not sha3-512 */
+    if (block_size > 72) {
+        hash[ 9] ^= digest_letoh64(block[ 9]);
+        hash[10] ^= digest_letoh64(block[10]);
+        hash[11] ^= digest_letoh64(block[11]);
+        hash[12] ^= digest_letoh64(block[12]);
+        /* if not sha3-384 */
+        if (block_size > 104) {
+            hash[13] ^= digest_letoh64(block[13]);
+            hash[14] ^= digest_letoh64(block[14]);
+            hash[15] ^= digest_letoh64(block[15]);
+            hash[16] ^= digest_letoh64(block[16]);
+            /* if not sha3-256 */
+            if (block_size > 136) {
+                hash[17] ^= digest_letoh64(block[17]);
+            }
+        }
+    }
+
+    /* make a permutation of the hash */
+    for (round = 0; round < (sizeof(keccak_round_constants)/sizeof(*keccak_round_constants)); round++) {
+        keccak_theta(hash);
+
+        /* apply Keccak rho() transformation */
+        hash[ 1] = ROTL64(hash[ 1],  1);
+        hash[ 2] = ROTL64(hash[ 2], 62);
+        hash[ 3] = ROTL64(hash[ 3], 28);
+        hash[ 4] = ROTL64(hash[ 4], 27);
+        hash[ 5] = ROTL64(hash[ 5], 36);
+        hash[ 6] = ROTL64(hash[ 6], 44);
+        hash[ 7] = ROTL64(hash[ 7],  6);
+        hash[ 8] = ROTL64(hash[ 8], 55);
+        hash[ 9] = ROTL64(hash[ 9], 20);
+        hash[10] = ROTL64(hash[10],  3);
+        hash[11] = ROTL64(hash[11], 10);
+        hash[12] = ROTL64(hash[12], 43);
+        hash[13] = ROTL64(hash[13], 25);
+        hash[14] = ROTL64(hash[14], 39);
+        hash[15] = ROTL64(hash[15], 41);
+        hash[16] = ROTL64(hash[16], 45);
+        hash[17] = ROTL64(hash[17], 15);
+        hash[18] = ROTL64(hash[18], 21);
+        hash[19] = ROTL64(hash[19],  8);
+        hash[20] = ROTL64(hash[20], 18);
+        hash[21] = ROTL64(hash[21],  2);
+        hash[22] = ROTL64(hash[22], 61);
+        hash[23] = ROTL64(hash[23], 56);
+        hash[24] = ROTL64(hash[24], 14);
+
+        keccak_pi(hash);
+        keccak_chi(hash);
+
+        /* apply iota(hash, round) */
+        *hash ^= keccak_round_constants[round];
+    }
+}
+
+void sha3_write(digest_t *digest, const char *msg, size_t size)
+{
+    size_t rest = digest->state.sha3.rest;
+    size_t block_size = digest->state.sha3.block_size;
+
+    digest->state.sha3.rest = (rest + size) % block_size;
+
+    /* fill partial block */
+    if (rest) {
+        size_t left = block_size - rest;
+        memcpy(digest->state.sha3.message + rest, msg, (size < left ? size : left));
+        if (size < left) return;
+
+        /* process partial block */
+        sha3_process_block(digest->state.sha3.hash, (uint64_t*)digest->state.sha3.message, block_size);
+        msg  += left;
+        size -= left;
+    }
+    while (size >= block_size) {
+        const char *aligned_message_block;
+
+        if (((intptr_t)(void*)msg) & 7) {
+            memcpy(digest->state.sha3.message, msg, block_size);
+            aligned_message_block = digest->state.sha3.message;
+        } else {
+            aligned_message_block = msg;
+        }
+
+        sha3_process_block(digest->state.sha3.hash, (uint64_t*)aligned_message_block, block_size);
+        msg  += block_size;
+        size -= block_size;
+    }
+
+    if (size)
+        memcpy(digest->state.sha3.message, msg, size); /* save leftovers */
+}
+
+static inline size_t sha3_read(digest_t *digest, void *buf, size_t len)
+{
+    const size_t block_size = digest->state.sha3.block_size;
+
+    memset(digest->state.sha3.message + digest->state.sha3.rest, 0, block_size - digest->state.sha3.rest);
+    digest->state.sha3.message[digest->state.sha3.rest] |= 0x06;
+    digest->state.sha3.message[block_size - 1] |= 0x80;
+
+    sha3_process_block(digest->state.sha3.hash, (uint64_t*)digest->state.sha3.message, block_size);
+
+#ifdef WORDS_BIGENDIAN
+    do {
+        size_t i;
+        for (i = 0; i < (sizeof(digest->state.sha3.hash)/sizeof(*digest->state.sha3.hash)); i++)
+            digest->state.sha3.hash[i] = digest_htole64(digest->state.sha3.hash[i]);
+    } while (0);
+#endif
+
+    if (len > (100 - digest->state.sha3.block_size / 2))
+        len = 100 - digest->state.sha3.block_size / 2;
+    memcpy(buf, digest->state.sha3.hash, len);
+    return len;
+}
+
+
+const char *digest_algo_id2str(digest_algo_t algo)
+{
+    switch (algo) {
+
+        case DIGEST_ALGO_MD5:
+            return "MD5";
+        break;
+        case DIGEST_ALGO_SHA3_224:
+            return "SHA3-224";
+        break;
+        case DIGEST_ALGO_SHA3_256:
+            return "SHA3-256";
+        break;
+        case DIGEST_ALGO_SHA3_384:
+            return "SHA3-384";
+        break;
+        case DIGEST_ALGO_SHA3_512:
+            return "SHA3-512";
+        break;
+    }
+
+    return NULL;
+}
+ssize_t     digest_algo_length_bytes(digest_algo_t algo)
+{
+    switch (algo) {
+        case DIGEST_ALGO_MD5:
+            return 16;
+        break;
+        case DIGEST_ALGO_SHA3_224:
+            return 224/8;
+        break;
+        case DIGEST_ALGO_SHA3_256:
+            return 256/8;
+        break;
+        case DIGEST_ALGO_SHA3_384:
+            return 384/8;
+        break;
+        case DIGEST_ALGO_SHA3_512:
+            return 512/8;
+        break;
+    }
+
+    return -1;
+}
+
+digest_t * digest_new(digest_algo_t algo)
+{
+    digest_t *digest = refobject_new__new(digest_t, NULL, NULL, NULL);
+
+    if (!digest)
+        return NULL;
+
+    digest->algo = algo;
+    switch (algo) {
+        case DIGEST_ALGO_MD5:
+            MD5Init(&(digest->state.md5));
+        break;
+        case DIGEST_ALGO_SHA3_224:
+            sha3_init(digest, 224);
+        break;
+        case DIGEST_ALGO_SHA3_256:
+            sha3_init(digest, 256);
+        break;
+        case DIGEST_ALGO_SHA3_384:
+            sha3_init(digest, 384);
+        break;
+        case DIGEST_ALGO_SHA3_512:
+            sha3_init(digest, 512);
+        break;
+        default:
+            refobject_unref(digest);
+            return NULL;
+        break;
+    }
+
+    return digest;
+}
+
+digest_t *  digest_copy(digest_t *digest)
+{
+    digest_t *n;
+
+    if (!digest)
+        return NULL;
+
+    n = refobject_new__new(digest_t, NULL, NULL, NULL);
+    n->algo = digest->algo;
+    n->done = digest->done;
+    n->state = digest->state;
+
+    return n;
+}
+
+ssize_t digest_write(digest_t *digest, const void *data, size_t len)
+{
+    if (!digest || !data)
+        return -1;
+
+    if (digest->done)
+        return -1;
+
+    switch (digest->algo) {
+        case DIGEST_ALGO_MD5:
+            MD5Update(&(digest->state.md5), (const unsigned char *)data, len);
+            return len;
+        break;
+        case DIGEST_ALGO_SHA3_224:
+        case DIGEST_ALGO_SHA3_256:
+        case DIGEST_ALGO_SHA3_384:
+        case DIGEST_ALGO_SHA3_512:
+            sha3_write(digest, data, len);
+            return len;
+        break;
+        default:
+            return -1;
+        break;
+    }
+}
+
+ssize_t digest_read(digest_t *digest, void *buf, size_t len)
+{
+    if (!digest || !buf)
+        return -1;
+
+    if (digest->done)
+        return -1;
+
+    digest->done = 1;
+
+    switch (digest->algo) {
+        case DIGEST_ALGO_MD5:
+            if (len < HASH_LEN) {
+                unsigned char buffer[HASH_LEN];
+                MD5Final(buffer, &(digest->state.md5));
+                memcpy(buf, buffer, len);
+                return len;
+            } else {
+                MD5Final((unsigned char*)buf, &(digest->state.md5));
+                return HASH_LEN;
+            }
+        break;
+        case DIGEST_ALGO_SHA3_224:
+        case DIGEST_ALGO_SHA3_256:
+        case DIGEST_ALGO_SHA3_384:
+        case DIGEST_ALGO_SHA3_512:
+            return sha3_read(digest, buf, len);
+        break;
+        default:
+            return -1;
+        break;
+    }
+}
+
+ssize_t digest_length_bytes(digest_t *digest)
+{
+    if (!digest)
+        return -1;
+
+    return digest_algo_length_bytes(digest->algo);
+}
+
+
+static size_t __digest_algo_blocklength(digest_algo_t algo)
+{
+    switch (algo) {
+        case DIGEST_ALGO_MD5: return 64; break;
+        case DIGEST_ALGO_SHA3_224: return 144; break;
+        case DIGEST_ALGO_SHA3_256: return 136; break;
+        case DIGEST_ALGO_SHA3_384: return 104; break;
+        case DIGEST_ALGO_SHA3_512: return 72; break;
+    }
+
+    return 0;
+}
+
+hmac_t *    hmac_new(digest_algo_t algo, const void *key, size_t keylen)
+{
+    hmac_t *hmac;
+    size_t blocklen = __digest_algo_blocklength(algo);
+    char *keycopy = calloc(1, blocklen);
+    size_t i;
+
+    if (!blocklen)
+        return NULL;
+
+    if (keylen > blocklen) {
+        size_t digestlen = digest_algo_length_bytes(algo);
+        digest_t *digest = digest_new(algo);
+
+        if (!digest) {
+            free(keycopy);
+            return NULL;
+        }
+        if (digest_write(digest, key, keylen) != (ssize_t)keylen) {
+            refobject_unref(digest);
+            free(keycopy);
+            return NULL;
+        }
+        if (digest_read(digest, keycopy, digestlen) != (ssize_t)digestlen) {
+            refobject_unref(digest);
+            free(keycopy);
+            return NULL;
+        }
+        refobject_unref(digest);
+    } else {
+        memcpy(keycopy, key, keylen);
+    }
+
+    hmac = refobject_new__new(hmac_t, NULL, NULL, NULL);
+    if (!hmac)
+        return NULL;
+
+    hmac->algo = algo;
+    hmac->key = keycopy;
+    hmac->key_len = blocklen;
+    hmac->inner = digest_new(algo);
+
+    if (!hmac->inner) {
+        refobject_unref(hmac);
+        return NULL;
+    }
+
+    for (i = 0; i < blocklen; i++) {
+        char x = keycopy[i] ^ 0x36;
+        if (digest_write(hmac->inner, &x, 1) != 1) {
+            refobject_unref(hmac);
+            return NULL;
+        }
+    }
+
+    return hmac;
+}
+
+hmac_t *    hmac_copy(hmac_t *hmac)
+{
+    hmac_t *n;
+
+    if (!hmac)
+        return NULL;
+
+    n = refobject_new__new(hmac_t, NULL, NULL, NULL);
+    n->algo = hmac->algo;
+    n->key = malloc(n->key_len);
+    if (!n->key) {
+        refobject_unref(n);
+        return NULL;
+    }
+    memcpy(n->key, hmac->key, hmac->key_len);
+    n->key_len = hmac->key_len;
+    n->inner = digest_copy(hmac->inner);
+    if (!n->inner) {
+        refobject_unref(n);
+        return NULL;
+    }
+
+    return n;
+}
+
+ssize_t     hmac_write(hmac_t *hmac, const void *data, size_t len)
+{
+    if (!hmac)
+        return -1;
+
+    return digest_write(hmac->inner, data, len);
+}
+
+ssize_t     hmac_read(hmac_t *hmac, void *buf, size_t len)
+{
+    size_t digestlen;
+    digest_t *digest;
+    char *res;
+    size_t i;
+    ssize_t ret;
+
+    if (!hmac)
+        return -1;
+
+    digestlen = digest_algo_length_bytes(hmac->algo);
+
+    digest = digest_new(hmac->algo);
+    if (!digest)
+        return -1;
+
+    res = malloc(digestlen);
+    if (!res) {
+        refobject_unref(digest);
+        return -1;
+    }
+
+    for (i = 0; i < hmac->key_len; i++) {
+        char x = hmac->key[i] ^ 0x5C;
+        if (digest_write(digest, &x, 1) != 1) {
+            free(res);
+            refobject_unref(digest);
+            return -1;
+        }
+    }
+
+    if (digest_read(hmac->inner, res, digestlen) != (ssize_t)digestlen) {
+        free(res);
+        refobject_unref(digest);
+        return -1;
+    }
+
+    if (digest_write(digest, res, digestlen) != (ssize_t)digestlen) {
+        free(res);
+        refobject_unref(digest);
+        return -1;
+    }
+
+    ret = digest_read(digest, buf, len);
+
+    free(res);
+    refobject_unref(digest);
+
+    return ret;
+}
diff --git a/src/digest.h b/src/digest.h
new file mode 100644
index 0000000000000000000000000000000000000000..453653da38fdb30e4c93d71b8a8529b7e9eeee66
--- /dev/null
+++ b/src/digest.h
@@ -0,0 +1,42 @@
+/* Icecast
+ *
+ * This program is distributed under the GNU General Public License, version 2.
+ * A copy of this license is included with this source.
+ *
+ * Copyright 2020,      Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>
+ */
+
+#ifndef __DIGEST_H__
+#define __DIGEST_H__
+
+#include "refobject.h"
+
+REFOBJECT_FORWARD_TYPE(digest_t);
+REFOBJECT_FORWARD_TYPE(hmac_t);
+
+typedef enum {
+    DIGEST_ALGO_MD5,
+    DIGEST_ALGO_SHA3_224,
+    DIGEST_ALGO_SHA3_256,
+    DIGEST_ALGO_SHA3_384,
+    DIGEST_ALGO_SHA3_512
+} digest_algo_t;
+
+const char *digest_algo_id2str(digest_algo_t algo);
+ssize_t     digest_algo_length_bytes(digest_algo_t algo);
+
+digest_t *  digest_new(digest_algo_t algo);
+digest_t *  digest_copy(digest_t *digest);
+ssize_t     digest_write(digest_t *digest, const void *data, size_t len);
+ssize_t     digest_read(digest_t *digest, void *buf, size_t len);
+
+/* Returns the digest size in bytes */
+ssize_t     digest_length_bytes(digest_t *digest);
+
+
+hmac_t *    hmac_new(digest_algo_t algo, const void *key, size_t keylen);
+hmac_t *    hmac_copy(hmac_t *hmac);
+ssize_t     hmac_write(hmac_t *hmac, const void *data, size_t len);
+ssize_t     hmac_read(hmac_t *hmac, void *buf, size_t len);
+
+#endif
diff --git a/src/errors.c b/src/errors.c
index 41dd64b87cbf4d114c90a2d356dddb726d498fd8..41a3415ca6d16c5faef893cfad99ccfbe09a102e 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -143,7 +143,19 @@ static const icecast_error_t __errors[] = {
      .message = "XSLT problem"},
     {.id = ICECAST_ERROR_RECURSIVE_ERROR,                               .http_status = 500,
      .uuid = "13489d5c-eae6-4bf3-889e-ec1fa9a9b9ac",
-     .message = "Recursive error"}
+     .message = "Recursive error"},
+     {.id = ICECAST_ERROR_RCHANNEL_QUEUE_FULL,                          .http_status = 400,
+     .uuid = "36efaaa9-3631-48f1-b90b-e2b0c945b4e9",
+     .message = "Source return channel queue is full"},
+     {.id = ICECAST_ERROR_RCHANNEL_QUEUE_EMPTY,                         .http_status = 400,
+     .uuid = "a8f4ae21-5aec-481e-8af5-6b3ec3b5ad17",
+     .message = "Source return channel queue is empty"},
+     {.id = ICECAST_ERROR_RCHANNEL_MESSAGE_TOO_LONG,                    .http_status = 400,
+     .uuid = "43c6c2c6-0eb2-4189-a6ac-1091eff07dd6",
+     .message = "Message exceeds maximum allowed length"},
+     {.id = ICECAST_ERROR_RCHANNEL_MESSAGE_EMPTY,                       .http_status = 400,
+     .uuid = "8c80ead4-cd46-4402-bf7d-da6bf44021ac",
+     .message = "Message is empty."}
 };
 
 const icecast_error_t * error_get_by_id(icecast_error_id_t id) {
diff --git a/src/errors.h b/src/errors.h
index 0b836772c0e6ef397bdb3e0c60c90dd1ff62374b..d94ae0c83d26ece33636add3d8a0f55f3bde6eb8 100644
--- a/src/errors.h
+++ b/src/errors.h
@@ -51,7 +51,11 @@ typedef enum {
     ICECAST_ERROR_SOURCE_MAX_LISTENERS,
     ICECAST_ERROR_XSLT_PARSE,
     ICECAST_ERROR_XSLT_problem,
-    ICECAST_ERROR_RECURSIVE_ERROR
+    ICECAST_ERROR_RECURSIVE_ERROR,
+    ICECAST_ERROR_RCHANNEL_QUEUE_FULL,
+    ICECAST_ERROR_RCHANNEL_QUEUE_EMPTY,
+    ICECAST_ERROR_RCHANNEL_MESSAGE_TOO_LONG,
+    ICECAST_ERROR_RCHANNEL_MESSAGE_EMPTY
 } icecast_error_id_t;
 
 struct icecast_error_tag {
diff --git a/src/icecasttypes.h b/src/icecasttypes.h
index 4b340e727672d44eea40fd8fb4e435ecc9b9860f..15bd7c607443f99180d2acbae7bc57c78cdaa4a9 100644
--- a/src/icecasttypes.h
+++ b/src/icecasttypes.h
@@ -122,6 +122,15 @@ typedef struct reportxml_database_tag reportxml_database_t;
 typedef struct listensocket_container_tag listensocket_container_t;
 typedef struct listensocket_tag listensocket_t;
 
+/* ---[ digest.[ch] ]--- */
+
+typedef struct digest_tag digest_t;
+typedef struct hmac_tag hmac_t;
+
+/* ---[ navigation.[ch] ]--- */
+
+typedef struct mount_identifier_tag mount_identifier_t;
+
 /* ---[ refobject.[ch] ]--- */
 
 typedef struct refobject_base_tag refobject_base_t;
@@ -137,6 +146,9 @@ typedef union __attribute__ ((__transparent_union__)) {
     reportxml_database_t *reportxml_database;
     listensocket_container_t *listensocket_container;
     listensocket_t *listensocket;
+    digest_t *digest;
+    hmac_t *hmac;
+    mount_identifier_t *mount_identifier;
 } refobject_t;
 #else
 typedef void * refobject_t;
diff --git a/src/main.c b/src/main.c
index ed3e0387044d958cf6cca21bd7458d1664d522e6..aecde8972ae805a55ce89962a75b850dc391a179 100644
--- a/src/main.c
+++ b/src/main.c
@@ -79,6 +79,8 @@
 #include "event.h"
 #include "listensocket.h"
 #include "fastevent.h"
+#include "prng.h"
+#include "navigation.h"
 
 #include <libxml/xmlmemory.h>
 
@@ -144,6 +146,8 @@ static void initialize_subsystems(void)
 {
     log_initialize();
     thread_initialize();
+    prng_initialize();
+    navigation_initialize();
     global_initialize();
 #ifndef FASTEVENT_ENABLED
     fastevent_initialize();
@@ -153,6 +157,7 @@ static void initialize_subsystems(void)
     resolver_initialize();
     config_initialize();
     tls_initialize();
+    client_initialize();
     connection_initialize();
     refbuf_initialize();
 
@@ -173,7 +178,9 @@ static void shutdown_subsystems(void)
     stats_shutdown();
 
     connection_shutdown();
+    client_shutdown();
     tls_shutdown();
+    prng_deconfigure();
     config_shutdown();
     resolver_shutdown();
     sock_shutdown();
@@ -181,6 +188,8 @@ static void shutdown_subsystems(void)
     refobject_unref(fastevent_reg);
     fastevent_shutdown();
 #endif
+    navigation_shutdown();
+    prng_shutdown();
     global_shutdown();
     thread_shutdown();
 
@@ -576,6 +585,7 @@ int main(int argc, char **argv)
     char filename[512] = "";
 #endif
     char pbuf[1024];
+    ice_config_t *config;
 
     /* parse the '-c icecast.xml' option
     ** only, so that we can read a configfile
@@ -644,6 +654,10 @@ int main(int argc, char **argv)
         return 1;
     }
 
+    config = config_get_config();
+    prng_configure(config);
+    config_release_config();
+
     stats_initialize(); /* We have to do this later on because of threading */
     fserve_initialize(); /* This too */
 
diff --git a/src/navigation.c b/src/navigation.c
new file mode 100644
index 0000000000000000000000000000000000000000..43eb22555e0b68ed1af0d3f5ee5278b77ce6e8b0
--- /dev/null
+++ b/src/navigation.c
@@ -0,0 +1,198 @@
+/* Icecast
+ *
+ * This program is distributed under the GNU General Public License, version 2.
+ * A copy of this license is included with this source.
+ *
+ * Copyright 2020,      Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "common/avl/avl.h"
+
+#include "navigation.h"
+
+#include "logging.h"
+#define CATMODULE "navigation"
+
+struct mount_identifier_tag {
+    /* base object */
+    refobject_base_t __base;
+};
+
+REFOBJECT_DEFINE_TYPE(mount_identifier_t);
+
+const char * navigation_direction_to_str(navigation_direction_t dir)
+{
+    switch (dir) {
+        case NAVIGATION_DIRECTION_UP: return "up"; break;
+        case NAVIGATION_DIRECTION_DOWN: return "down"; break;
+        case NAVIGATION_DIRECTION_REPLACE_CURRENT: return "replace-current"; break;
+        case NAVIGATION_DIRECTION_REPLACE_ALL: return "replace-all"; break;
+    }
+
+    return NULL;
+}
+
+navigation_direction_t navigation_str_to_direction(const char *str, navigation_direction_t def)
+{
+    if (!str || !*str)
+        return def;
+
+    if (strcasecmp(str, "up") == 0) {
+        return NAVIGATION_DIRECTION_UP;
+    } else if (strcasecmp(str, "down") == 0) {
+        return NAVIGATION_DIRECTION_DOWN;
+    } else if (strcasecmp(str, "replace_current") == 0 || strcasecmp(str, "replace-current") == 0) {
+        return NAVIGATION_DIRECTION_REPLACE_CURRENT;
+    } else if (strcasecmp(str, "replace_all") == 0 || strcasecmp(str, "replace-all") == 0) {
+        return NAVIGATION_DIRECTION_REPLACE_ALL;
+    } else {
+        return def;
+    }
+}
+
+static int mount_identifier_compare__for_tree(void *compare_arg, void *a, void *b)
+{
+    const char *id_a, *id_b;
+
+    id_a = mount_identifier_get_mount(a);
+    id_b = mount_identifier_get_mount(b);
+
+    if (!id_a || !id_b || id_a == id_b) {
+        return 0;
+    } else {
+        return strcmp(id_a, id_b);
+    }
+}
+
+void navigation_initialize(void)
+{
+}
+
+void navigation_shutdown(void)
+{
+}
+
+
+mount_identifier_t * mount_identifier_new(const char *mount)
+{
+    mount_identifier_t *n;
+
+    if (!mount)
+        return NULL;
+
+    n = refobject_new__new(mount_identifier_t, NULL, mount, NULL);
+    if (!n)
+        return NULL;
+
+    return n;
+}
+
+int                     mount_identifier_compare(mount_identifier_t *a, mount_identifier_t *b)
+{
+    return mount_identifier_compare__for_tree(NULL, a, b);
+}
+
+static inline int navigation_history_pop(navigation_history_t *history)
+{
+    if (history->fill == 0)
+        return 0;
+    history->fill--;
+    refobject_unref(history->history[history->fill]);
+    history->history[history->fill] = NULL;
+    return 0;
+}
+
+static inline int navigation_history_push(navigation_history_t *history, mount_identifier_t *identifier)
+{
+    if (history->fill > 0 && mount_identifier_compare(history->history[history->fill - 1], identifier) == 0)
+        return 0;
+
+    if (refobject_ref(identifier) != 0) {
+        ICECAST_LOG_ERROR("Can not reference identifier=%p, BAD.", identifier);
+        return -1;
+    }
+
+    if (history->fill == (sizeof(history->history)/sizeof(*history->history))) {
+        refobject_unref(history->history[0]);
+        memmove(history->history, &(history->history[1]), sizeof(history->history) - sizeof(*history->history));
+        history->fill--;
+    }
+
+    history->history[history->fill++] = identifier;
+
+    return 0;
+}
+
+void                    navigation_history_clear(navigation_history_t *history)
+{
+    if (!history)
+        return;
+    while (navigation_history_pop(history));
+}
+
+mount_identifier_t *    navigation_history_get_up(navigation_history_t *history)
+{
+    if (!history)
+        return NULL;
+
+    if (history->fill < 2)
+        return NULL;
+
+    if (refobject_ref(history->history[history->fill - 2]) != 0)
+        return NULL;
+
+    return history->history[history->fill - 2];
+}
+
+int                     navigation_history_navigate_to(navigation_history_t *history, mount_identifier_t *identifier, navigation_direction_t direction)
+{
+    ICECAST_LOG_DDEBUG("Called with history=%p, identifier=%p (%#H), direction=%s", history, identifier, mount_identifier_get_mount(identifier), navigation_direction_to_str(direction));
+
+    if (!history || !identifier)
+        return -1;
+
+    if (direction == NAVIGATION_DIRECTION_UP && history->fill < 2)
+        direction = NAVIGATION_DIRECTION_REPLACE_ALL;
+
+    switch (direction) {
+        case NAVIGATION_DIRECTION_UP:
+            if (history->fill < 2)
+                return -1;
+            if (mount_identifier_compare(history->history[history->fill - 2], identifier) != 0)
+                return -1;
+            return navigation_history_pop(history);
+        break;
+        case NAVIGATION_DIRECTION_DOWN:
+            return navigation_history_push(history, identifier);
+        break;
+        case NAVIGATION_DIRECTION_REPLACE_CURRENT:
+            if (history->fill == 0) {
+                return navigation_history_push(history, identifier);
+            } else {
+                if (history->fill > 1 && mount_identifier_compare(history->history[history->fill - 2], identifier) == 0) {
+                    return navigation_history_pop(history);
+                }
+
+                if (refobject_ref(identifier) != 0) {
+                    ICECAST_LOG_ERROR("Can not reference identifier=%p, BAD.", identifier);
+                    return -1;
+                }
+                refobject_unref(history->history[history->fill - 1]);
+                history->history[history->fill - 1] = identifier;
+                return 0;
+            }
+        break;
+        case NAVIGATION_DIRECTION_REPLACE_ALL:
+            navigation_history_clear(history);
+            if (history->fill != 0)
+                return -1;
+            return navigation_history_push(history, identifier);
+        break;
+    }
+
+    return -1;
+}
diff --git a/src/navigation.h b/src/navigation.h
new file mode 100644
index 0000000000000000000000000000000000000000..c38d6d5bd838ca86ec776d59e15754643b01c846
--- /dev/null
+++ b/src/navigation.h
@@ -0,0 +1,47 @@
+/* Icecast
+ *
+ * This program is distributed under the GNU General Public License, version 2.
+ * A copy of this license is included with this source.
+ *
+ * Copyright 2020,      Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>
+ */
+
+#ifndef __NAVIGATION_H__
+#define __NAVIGATION_H__
+
+#include <string.h>
+
+#include "refobject.h"
+
+#define MAX_NAVIGATION_HISTORY_SIZE  8
+
+typedef struct {
+    mount_identifier_t *history[MAX_NAVIGATION_HISTORY_SIZE];
+    size_t fill;
+} navigation_history_t;
+
+typedef enum {
+    NAVIGATION_DIRECTION_UP,
+    NAVIGATION_DIRECTION_DOWN,
+    NAVIGATION_DIRECTION_REPLACE_CURRENT,
+    NAVIGATION_DIRECTION_REPLACE_ALL
+} navigation_direction_t;
+
+REFOBJECT_FORWARD_TYPE(mount_identifier_t);
+
+const char * navigation_direction_to_str(navigation_direction_t dir);
+navigation_direction_t navigation_str_to_direction(const char *str, navigation_direction_t def);
+
+void navigation_initialize(void);
+void navigation_shutdown(void);
+
+mount_identifier_t *    mount_identifier_new(const char *mount);
+#define mount_identifier_get_mount(identifier)  refobject_get_name((identifier))
+int                     mount_identifier_compare(mount_identifier_t *a, mount_identifier_t *b);
+
+#define navigation_history_init(history) memset((history), 0, sizeof(navigation_history_t))
+void                    navigation_history_clear(navigation_history_t *history);
+mount_identifier_t *    navigation_history_get_up(navigation_history_t *history);
+int                     navigation_history_navigate_to(navigation_history_t *history, mount_identifier_t *identifier, navigation_direction_t direction);
+
+#endif
diff --git a/src/prng.c b/src/prng.c
new file mode 100644
index 0000000000000000000000000000000000000000..716f30a4a44eb4f69fedbb36cbf930db076f219d
--- /dev/null
+++ b/src/prng.c
@@ -0,0 +1,365 @@
+/* Icecast
+ *
+ * This program is distributed under the GNU General Public License, version 2.
+ * A copy of this license is included with this source.
+ *
+ * Copyright 2020,      Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>
+ *
+ * The SHA3 implementation is based on rhash:
+ * 2013 by Aleksey Kravchenko <rhash.admin@gmail.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef HAVE_UNAME
+#include <sys/utsname.h>
+#endif
+
+#ifdef HAVE_OPENSSL
+#include <openssl/rand.h>
+#include <openssl/err.h>
+#endif
+
+#include "common/thread/thread.h"
+#include "common/timing/timing.h"
+
+#include "prng.h"
+#include "digest.h"
+#include "cfgfile.h"
+
+#include "logging.h"
+#define CATMODULE "prng"
+
+#define BLOCK_LENGTH                (512/8)
+
+#define SEEDING_FACTOR              128
+#define SEEDING_MAX_BEFORE_RESEED   32768
+
+static int initialized = 0;
+static mutex_t digest_a_lock;
+static mutex_t digest_b_lock;
+static digest_t * digest_a; // protected by digest_a_lock
+static digest_t * digest_b; // protected by digest_b_lock
+static size_t before_reseed; // protected by digest_a_lock
+
+static void prng_initial_seed(void)
+{
+    struct {
+        int debian;
+        uint64_t t;
+#ifdef HAVE_UNAME
+        struct utsname utsname;
+#endif
+#ifdef HAVE_SETUID
+        uid_t uid;
+        pid_t pid;
+        pid_t ppid;
+#endif
+    } seed;
+#ifdef HAVE_OPENSSL
+    char buffer[1024];
+    const char *filename;
+#endif
+
+    memset(&seed, 0, sizeof(seed));
+
+    seed.debian = 4;
+    seed.t = timing_get_time();
+#ifdef HAVE_UNAME
+    uname(&seed.utsname);
+#endif
+#ifdef HAVE_SETUID
+    seed.uid = getuid();
+    seed.pid = getpid();
+    seed.ppid = getppid();
+#endif
+
+    prng_write(&seed, sizeof(seed));
+
+#ifdef HAVE_OPENSSL
+    filename = RAND_file_name(buffer, sizeof(buffer));
+    if (filename)
+        RAND_load_file(filename, -1);
+    ERR_get_error(); // clear error if any
+#endif
+}
+
+static void prng_cross_seed(void)
+{
+    char buffer[1024];
+    ssize_t len;
+
+#ifdef HAVE_OPENSSL
+    if (RAND_bytes((unsigned char*)buffer, sizeof(buffer)) == 1) {
+        prng_write(buffer, sizeof(buffer));
+    } else {
+        ERR_get_error(); // clear error
+    }
+    len = prng_read(buffer, sizeof(buffer));
+    if (len > 0)
+        RAND_add(buffer, len, len/10.);
+#endif
+}
+
+static void prng_read_seeds(prng_seed_config_t *seed, int configure_time)
+{
+    while (seed) {
+        switch (seed->type) {
+            case PRNG_SEED_TYPE_READ_ONCE:
+            case PRNG_SEED_TYPE_READ_WRITE:
+                if (configure_time)
+                    prng_read_file(seed->filename, seed->size);
+                break;
+            case PRNG_SEED_TYPE_DEVICE:
+                prng_read_file(seed->filename, seed->size);
+                break;
+            case PRNG_SEED_TYPE_STATIC:
+                prng_write(seed->filename, strlen(seed->filename));
+                break;
+            case PRNG_SEED_TYPE_PROFILE:
+                if (strcmp(seed->filename, "linux") == 0) {
+                    if (configure_time) {
+                        prng_read_file("/proc/sys/kernel/random/boot_id", -1);
+                        prng_read_file("/etc/machine-id", -1);
+                    }
+                    prng_read_file("/proc/sys/kernel/random/uuid", -1);
+                }
+                if (strcmp(seed->filename, "linux") == 0 || strcmp(seed->filename, "bsd") == 0) {
+                    prng_read_file("/dev/urandom", 64);
+                }
+                break;
+        }
+        seed = seed->next;
+    }
+}
+
+void prng_initialize(void)
+{
+    if (initialized)
+        return;
+
+    thread_mutex_create(&digest_a_lock);
+    thread_mutex_create(&digest_b_lock);
+    digest_a = digest_new(DIGEST_ALGO_SHA3_512);
+    digest_b = digest_new(DIGEST_ALGO_SHA3_512);
+    initialized = 1;
+    prng_initial_seed();
+    prng_cross_seed();
+}
+
+void prng_shutdown(void)
+{
+    if (!initialized)
+        return;
+
+    refobject_unref(digest_b);
+    refobject_unref(digest_a);
+    thread_mutex_destroy(&digest_b_lock);
+    thread_mutex_destroy(&digest_a_lock);
+
+    initialized = 0;
+}
+
+void prng_configure(ice_config_t *config)
+{
+    if (!initialized)
+        return;
+
+    prng_write(config->location, strlen(config->location));
+    prng_write(config->admin, strlen(config->admin));
+    prng_write(config->hostname, strlen(config->hostname));
+    prng_write(config, sizeof(*config));
+    prng_read_seeds(config->prng_seed, 1);
+    prng_cross_seed();
+}
+
+void prng_deconfigure(void)
+{
+    ice_config_t *config;
+    prng_seed_config_t *seed;
+
+    if (!initialized)
+        return;
+
+    config = config_get_config();
+    seed = config->prng_seed;
+    while (seed) {
+        if (seed->type == PRNG_SEED_TYPE_READ_WRITE) {
+            prng_write_file(seed->filename, seed->size);
+        }
+        seed = seed->next;
+    }
+    config_release_config();
+}
+
+void prng_auto_reseed(void)
+{
+    int need_seeding;
+    ice_config_t *config;
+
+    thread_mutex_lock(&digest_a_lock);
+    need_seeding = before_reseed == 0;
+    thread_mutex_unlock(&digest_a_lock);
+
+    if (!need_seeding)
+        return;
+
+    config = config_get_config();
+    prng_read_seeds(config->prng_seed, 0);
+    config_release_config();
+    prng_cross_seed();
+}
+
+void prng_write(const void *buffer, size_t len)
+{
+    if (!initialized)
+        return;
+
+    thread_mutex_lock(&digest_a_lock);
+    digest_write(digest_a, buffer, len);
+    digest_write(digest_a, &len, sizeof(len));
+    before_reseed += len * SEEDING_FACTOR;
+    if (before_reseed > SEEDING_MAX_BEFORE_RESEED)
+        before_reseed = SEEDING_MAX_BEFORE_RESEED;
+    thread_mutex_unlock(&digest_a_lock);
+}
+
+static ssize_t prng_read_block(void *froma, void *buffer, size_t len)
+{
+    char fromb[BLOCK_LENGTH];
+
+    digest_write(digest_b, froma, BLOCK_LENGTH);
+
+    if (digest_read(digest_b, fromb, sizeof(fromb)) != sizeof(fromb))
+        return -1;
+
+    refobject_unref(digest_b);
+    digest_b = digest_new(DIGEST_ALGO_SHA3_512);
+    digest_write(digest_b, fromb, sizeof(fromb));
+    digest_write(digest_b, &len, sizeof(len));
+
+    if (len > sizeof(fromb))
+        len = sizeof(fromb);
+
+    memcpy(buffer, fromb, len);
+
+    return len;
+}
+
+ssize_t prng_read(void *buffer, size_t len)
+{
+    digest_t *copy;
+    char froma[BLOCK_LENGTH];
+    size_t ret = 0;
+    ssize_t res;
+
+    if (!initialized)
+        return -1;
+
+    thread_mutex_lock(&digest_a_lock);
+    digest_write(digest_a, &len, sizeof(len));
+    copy = digest_copy(digest_a);
+    if (before_reseed > len) {
+        before_reseed -= len;
+    } else {
+        before_reseed = 0;
+    }
+    thread_mutex_unlock(&digest_a_lock);
+
+    if (!copy)
+        return -1;
+
+    if (digest_read(copy, froma, sizeof(froma)) != sizeof(froma))
+        return -1;
+
+    refobject_unref(copy);
+
+    thread_mutex_lock(&digest_b_lock);
+    while (ret < len) {
+        res = prng_read_block(froma, buffer + ret, len - ret);
+        if (res < 0) {
+            thread_mutex_unlock(&digest_b_lock);
+            return -1;
+        }
+        ret += res;
+    }
+    thread_mutex_unlock(&digest_b_lock);
+
+    return ret;
+}
+
+int prng_write_file(const char *filename, ssize_t len)
+{
+    char buffer[BLOCK_LENGTH*16];
+    size_t done = 0;
+    FILE *file;
+
+    if (len < 0)
+        len = 1024;
+
+    file = fopen(filename, "wb");
+    if (!file)
+        return -1;
+
+    while (done < (size_t)len) {
+        size_t todo = (size_t)len < sizeof(buffer) ? (size_t)len : sizeof(buffer);
+        ssize_t res = prng_read(buffer, todo);
+        if (res < 1) {
+            fclose(file);
+            return -1;
+        }
+
+        if (fwrite(buffer, 1, res, file) != (size_t)res) {
+            fclose(file);
+            return -1;
+        }
+
+        done += res;
+    }
+
+    fclose(file);
+    return 0;
+}
+
+int prng_read_file(const char *filename, ssize_t len)
+{
+    char buffer[BLOCK_LENGTH*16];
+    size_t done = 0;
+    int fh;
+
+    if (len < 0 || len > 1048576)
+        len = 1048576;
+
+#ifdef O_CLOEXEC
+    fh = open(filename, O_RDONLY|O_CLOEXEC, 0);
+#else
+    fh = open(filename, O_RDONLY, 0);
+#endif
+    if (fh < 0)
+        return -1;
+
+    while (done < (size_t)len) {
+        size_t todo = (size_t)len < sizeof(buffer) ? (size_t)len : sizeof(buffer);
+        size_t res = read(fh, buffer, todo);
+
+        if (res < 1) {
+            close(fh);
+            return 0;
+        }
+
+        prng_write(buffer, res);
+
+        done += res;
+    }
+
+    close(fh);
+    return 0;
+}
diff --git a/src/prng.h b/src/prng.h
new file mode 100644
index 0000000000000000000000000000000000000000..958d5d2264ae1c1c527df1c7b37f3e8168ee5bf0
--- /dev/null
+++ b/src/prng.h
@@ -0,0 +1,26 @@
+/* Icecast
+ *
+ * This program is distributed under the GNU General Public License, version 2.
+ * A copy of this license is included with this source.
+ *
+ * Copyright 2020,      Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>
+ */
+
+#ifndef __PRNG_H__
+#define __PRNG_H__
+
+#include "icecasttypes.h"
+
+void prng_initialize(void);
+void prng_shutdown(void);
+void prng_configure(ice_config_t *config);
+void prng_deconfigure(void);
+void prng_auto_reseed(void);
+
+void prng_write(const void *buffer, size_t len);
+ssize_t prng_read(void *buffer, size_t len);
+
+int prng_write_file(const char *filename, ssize_t len);
+int prng_read_file(const char *filename, ssize_t len);
+
+#endif
diff --git a/src/rqueue.c b/src/rqueue.c
new file mode 100644
index 0000000000000000000000000000000000000000..b5bcc9d8d503c9943a6adfa922d934f63b9094e7
--- /dev/null
+++ b/src/rqueue.c
@@ -0,0 +1,70 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "rqueue.h"
+#include "logging.h"
+#include "util.h"
+
+
+#undef CATMODULE
+#define CATMODULE "rqueue"
+
+int get_size(rchannel_queue_t *rqueue)
+{
+    return rqueue->size;
+}
+
+int pop(rchannel_queue_t *rqueue)
+{
+    if(rqueue->head == NULL){
+        ICECAST_LOG_WARN("Queue is empty pop failed");
+        return -1;
+    }
+    if(rqueue->head == rqueue->tail){ /*Queue contains a single element, head and tail pointers need to be set to NULL*/
+        free(rqueue->head);
+        rqueue->head = NULL;
+        rqueue->tail = NULL;       
+    }
+    else{
+        rchannel_node_t * currHead = rqueue->head;
+        rqueue->head = rqueue->head->next;
+        free(currHead);
+    }
+    rqueue->size--;
+    return 0;
+}
+
+int push(rchannel_queue_t *rqueue, const char * message)
+{
+    rchannel_node_t * node = (rchannel_node_t *) malloc(sizeof(rchannel_node_t));
+    if(!node){
+        ICECAST_LOG_ERROR("Can't create rchannel message node");
+        return -1;
+    }
+    node->message = strdup(message);
+    node->next = NULL;
+    if(rqueue->tail != NULL){ /* Queue is not empty */
+        rqueue->tail->next = node;
+        rqueue->tail = node;
+    }
+    else{ 
+        /*Queue was empty upto this point initialize head and tail pointers*/
+        rqueue->tail = node;
+        rqueue->head = node;
+    }
+    rqueue->size++;
+    return 0;
+}
+
+char * front(rchannel_queue_t *rqueue)
+{
+    if(rqueue->head == NULL){ /*Queue is empty*/
+        ICECAST_LOG_WARN("queue is empty front failed");
+        return NULL;
+    }
+    char * message = rqueue->head->message;
+    char *buf = strdup(message);
+    return buf;
+}
+
diff --git a/src/rqueue.h b/src/rqueue.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1891301d83435683e951ade7ad426bd57feff0f
--- /dev/null
+++ b/src/rqueue.h
@@ -0,0 +1,23 @@
+#ifndef __RQUEUE_H__
+#define __RQUEUE_H__
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct rchannel_node_tag{
+    char * message;
+    struct rchannel_node_tag * next;
+} rchannel_node_t;
+
+typedef struct rchannel_queue_tag{
+     rchannel_node_t *head;
+     rchannel_node_t *tail;
+     int size;
+} rchannel_queue_t;
+
+int get_size(rchannel_queue_t *rqueue);
+int pop(rchannel_queue_t *rqueue);
+int push(rchannel_queue_t *rqueue, const char* message);
+char * front(rchannel_queue_t *rqueue);
+
+#endif
\ No newline at end of file
diff --git a/src/slave.c b/src/slave.c
index 67d4ffb82bba38c2013876aee292a18eb44c563a..f108f0c8e1f7aba62dfc03f2c8376a9e6a64505c 100644
--- a/src/slave.c
+++ b/src/slave.c
@@ -54,6 +54,7 @@
 #include "logging.h"
 #include "source.h"
 #include "format.h"
+#include "prng.h"
 
 #define CATMODULE "slave"
 
@@ -312,6 +313,7 @@ static client_t *open_relay_connection (relay_t *relay, relay_config_upstream_t
             ICECAST_LOG_ERROR("Header read failed for %s (%s:%d%s)", relay->config->localmount, server, port, mount);
             break;
         }
+        prng_write(header, strlen(header));
         parser = httpp_create_parser();
         httpp_initialize (parser, NULL);
         if (! httpp_parse_response (parser, header, strlen(header), relay->config->localmount))
@@ -467,7 +469,7 @@ static void *start_relay_stream (void *arg)
         fallback_source = source_find_mount(relay->source->fallback_mount);
 
         if (fallback_source != NULL)
-            source_move_clients(relay->source, fallback_source, NULL);
+            source_move_clients(relay->source, fallback_source, NULL, NAVIGATION_DIRECTION_DOWN);
 
         avl_tree_unlock(global.source_tree);
     }
@@ -536,7 +538,7 @@ static void check_relay_stream (relay_t *relay)
         {
             relay->source->on_demand = relay->config->on_demand;
 
-            if (source->fallback_mount && source->fallback_override)
+            if (source->fallback_mount && source->fallback_override != FALLBACK_OVERRIDE_NONE)
             {
                 source_t *fallback;
                 avl_tree_rlock (global.source_tree);
@@ -795,18 +797,21 @@ static int update_from_master(ice_config_t *config)
             ICECAST_LOG_INFO("Master accepted streamlist request");
         }
 
-        while (sock_read_line(mastersock, buf, sizeof(buf)))
-        {
-            if (!strlen(buf))
+        while (sock_read_line(mastersock, buf, sizeof(buf))) {
+            size_t len = strlen(buf);
+            if (!len)
                 break;
+            prng_write(buf, len);
         }
-        while (sock_read_line(mastersock, buf, sizeof(buf)))
-        {
+        while (sock_read_line(mastersock, buf, sizeof(buf))) {
+            size_t len = strlen(buf);
             relay_config_t *c = NULL;
             relay_config_t **n;
 
-            if (!strlen(buf))
+            if (!len)
                 continue;
+            prng_write(buf, len);
+
             ICECAST_LOG_DEBUG("read %d from master \"%s\"", count++, buf);
             xmlURIPtr parsed_uri = xmlParseURI(buf);
             if (parsed_uri == NULL) {
@@ -824,19 +829,29 @@ static int update_from_master(ice_config_t *config)
 
             if (c) {
                 if (parsed_uri->server != NULL) {
-                    c->upstream_default.server = strdup(parsed_uri->server);
+                    c->upstream_default.server = (char *)xmlCharStrdup(parsed_uri->server);
                     if (parsed_uri->port == 0) {
                         c->upstream_default.port = 80;
                     } else {
                         c->upstream_default.port = parsed_uri->port;
                     }
                 } else {
-                    c->upstream_default.server = (char *)xmlCharStrdup (master);
+                    c->upstream_default.server = (char *)xmlCharStrdup(master);
                     c->upstream_default.port = port;
                 }
+                if (parsed_uri->user && strchr(parsed_uri->user, ':')) {
+                    char *pw;
+
+                    c->upstream_default.username = (char *)xmlCharStrdup(parsed_uri->user);
+                    pw = strchr(c->upstream_default.username, ':');
+                    if (pw) {
+                        *(pw++) = 0;
+                        c->upstream_default.password = (char *)xmlCharStrdup(pw);
+                    }
+                }
 
-                c->upstream_default.mount = strdup(parsed_uri->path);
-                c->localmount = strdup(parsed_uri->path);
+                c->upstream_default.mount = (char *)xmlCharStrdup(parsed_uri->path);
+                c->localmount = (char *)xmlCharStrdup(parsed_uri->path);
                 c->upstream_default.mp3metadata = 1;
                 c->on_demand = on_demand;
                 ICECAST_LOG_DEBUG("Added relay host=\"%s\", port=%d, mount=\"%s\"", c->upstream_default.server, c->upstream_default.port, c->upstream_default.mount);
@@ -901,6 +916,7 @@ static void *_slave_thread(void *arg)
         global_unlock();
 
         thread_sleep(1000000);
+        prng_auto_reseed();
         thread_mutex_lock(&_slave_mutex);
         if (slave_running == 0) {
             thread_mutex_unlock(&_slave_mutex);
diff --git a/src/source.c b/src/source.c
index ea0eba41b85e62df09436a3e71c9d92af2e76de2..d86e05942ba5773384f76323825f1637e45c8646 100644
--- a/src/source.c
+++ b/src/source.c
@@ -60,16 +60,17 @@
 #include "event.h"
 #include "slave.h"
 #include "acl.h"
+#include "navigation.h"
 
 #undef CATMODULE
 #define CATMODULE "source"
 
 #define MAX_FALLBACK_DEPTH 10
 
+
 mutex_t move_clients_mutex;
 
 /* avl tree helper */
-static int _compare_clients(void *compare_arg, void *a, void *b);
 static int _free_client(void *key);
 static void _parse_audio_info (source_t *source, const char *s);
 static void source_shutdown (source_t *source);
@@ -100,12 +101,13 @@ source_t *source_reserve (const char *mount)
         if (src == NULL)
             break;
 
-        src->client_tree = avl_tree_new(_compare_clients, NULL);
-        src->pending_tree = avl_tree_new(_compare_clients, NULL);
+        src->client_tree = avl_tree_new(client_compare, NULL);
+        src->pending_tree = avl_tree_new(client_compare, NULL);
         src->history = playlist_new(10 /* DOCUMENT: default is max_tracks=10. */);
 
         /* make duplicates for strings or similar */
         src->mount = strdup(mount);
+        src->identifier = mount_identifier_new(mount);
         src->max_listeners = -1;
         thread_mutex_create(&src->lock);
 
@@ -153,7 +155,7 @@ source_t *source_find_mount_raw(const char *mount)
  * check the fallback, and so on.  Must have a global source lock to call
  * this function.
  */
-source_t *source_find_mount(const char *mount)
+source_t *source_find_mount_with_history(const char *mount, navigation_history_t *history)
 {
     source_t *source = NULL;
     ice_config_t *config;
@@ -165,10 +167,20 @@ source_t *source_find_mount(const char *mount)
     {
         source = source_find_mount_raw(mount);
 
-        if (source)
-        {
+        if (source) {
+            if (history)
+                navigation_history_navigate_to(history, source->identifier, NAVIGATION_DIRECTION_DOWN);
+
             if (source->running || source->on_demand)
                 break;
+        } else {
+            if (history) {
+                mount_identifier_t *identifier = mount_identifier_new(mount);
+                if (identifier) {
+                    navigation_history_navigate_to(history, identifier, NAVIGATION_DIRECTION_DOWN);
+                    refobject_unref(identifier);
+                }
+            }
         }
 
         /* we either have a source which is not active (relay) or no source
@@ -187,7 +199,6 @@ source_t *source_find_mount(const char *mount)
     return source;
 }
 
-
 int source_compare_sources(void *arg, void *a, void *b)
 {
     source_t *srca = (source_t *)a;
@@ -207,6 +218,7 @@ void source_clear_source (source_t *source)
 
     avl_tree_wlock (source->pending_tree);
     client_destroy(source->client);
+    rchannel_queue_destroy(source);
     source->client = NULL;
     source->parser = NULL;
     source->con = NULL;
@@ -288,6 +300,9 @@ void source_clear_source (source_t *source)
     free(source->dumpfilename);
     source->dumpfilename = NULL;
 
+    free(source->rchannel_queue);
+    source->rchannel_queue = NULL;
+
     playlist_release(source->history);
     source->history = NULL;
 
@@ -315,10 +330,11 @@ void source_free_source (source_t *source)
 
     /* make sure all YP entries have gone */
     yp_remove (source->mount);
-
+    
+    free(source->rchannel_queue);
+    refobject_unref(source->identifier);
     free (source->mount);
     free (source);
-
     return;
 }
 
@@ -343,7 +359,13 @@ client_t *source_find_client(source_t *source, connection_id_t id)
     return NULL;
 }
 
-static inline void source_move_clients__single(source_t *source, avl_tree *from, avl_tree *to, client_t *client) {
+static inline int source_move_clients__single(source_t *source, source_t *dest, avl_tree *from, avl_tree *to, client_t *client, navigation_direction_t direction) {
+    if (navigation_history_navigate_to(&(client->history), dest->identifier, direction) != 0) {
+        ICECAST_LOG_DWARN("Can not change history: navigation of client=%p{.con->id=%llu, ...} from source=%p{.mount=%#H, ...} to dest=%p{.mount=%#H, ...} with direction %s failed",
+                client, (unsigned long long int)client->con->id, source, source->mount, dest, dest->mount, navigation_direction_to_str(direction));
+        return -1;
+    }
+
     avl_delete(from, client, NULL);
 
     /* when switching a client to a different queue, be wary of the
@@ -358,6 +380,7 @@ static inline void source_move_clients__single(source_t *source, avl_tree *from,
     }
 
     avl_insert(to, (void *)client);
+    return 0;
 }
 
 /* Move clients from source to dest provided dest is running
@@ -365,7 +388,7 @@ static inline void source_move_clients__single(source_t *source, avl_tree *from,
  * The only lock that should be held when this is called is the
  * source tree lock
  */
-void source_move_clients(source_t *source, source_t *dest, connection_id_t *id)
+void source_move_clients(source_t *source, source_t *dest, connection_id_t *id, navigation_direction_t direction)
 {
     unsigned long count = 0;
     if (strcmp(source->mount, dest->mount) == 0) {
@@ -412,24 +435,30 @@ void source_move_clients(source_t *source, source_t *dest, connection_id_t *id)
             fakeclient.con->id = *id;
 
             if (avl_get_by_key(source->client_tree, &fakeclient, &result) == 0) {
-                source_move_clients__single(source, source->client_tree, dest->pending_tree, result);
-                count++;
+                if (source_move_clients__single(source, dest, source->client_tree, dest->pending_tree, result, direction) == 0)
+                    count++;
             }
         } else {
-            while (1) {
-                avl_node *node = avl_get_first(source->pending_tree);
-                if (node == NULL)
-                    break;
-                source_move_clients__single(source, source->pending_tree, dest->pending_tree, node->key);
-                count++;
+            avl_node *next;
+
+            next = avl_get_first(source->pending_tree);
+            while (next) {
+                avl_node *node = next;
+
+                next = avl_get_next(next);
+
+                if (source_move_clients__single(source, dest, source->pending_tree, dest->pending_tree, node->key, direction) == 0)
+                    count++;
             }
 
-            while (1) {
-                avl_node *node = avl_get_first(source->client_tree);
-                if (node == NULL)
-                    break;
-                source_move_clients__single(source, source->client_tree, dest->pending_tree, node->key);
-                count++;
+            next = avl_get_first(source->client_tree);
+            while (next) {
+                avl_node *node = next;
+
+                next = avl_get_next(next);
+
+                if (source_move_clients__single(source, dest, source->client_tree, dest->pending_tree, node->key, direction) == 0)
+                    count++;
             }
         }
 
@@ -657,18 +686,34 @@ static void source_init (source_t *source)
     ** loop or jingle track or whatever the fallback is used for
     */
 
-    if (source->fallback_override && source->fallback_mount)
-    {
+    ICECAST_LOG_DDEBUG("source=%p{.mount=%#H, .fallback_override=%i, .fallback_mount=%#H, ...}", source, source->mount, (int)source->fallback_override, source->fallback_mount);
+    if (source->fallback_override != FALLBACK_OVERRIDE_NONE && source->fallback_mount) {
         source_t *fallback_source;
 
         avl_tree_rlock(global.source_tree);
         fallback_source = source_find_mount(source->fallback_mount);
 
-        if (fallback_source)
-            source_move_clients(fallback_source, source, NULL);
+        if (fallback_source) {
+            ICECAST_LOG_DDEBUG("source=%p{.mount=%#H, .fallback_override=%i, ...}, fallback_source=%p{.mount=%#H, ...}", source, source->mount, (int)source->fallback_override, fallback_source, fallback_source->mount);
+            switch (source->fallback_override) {
+                case FALLBACK_OVERRIDE_NONE:
+                    /* no-op */
+                break;
+                case FALLBACK_OVERRIDE_ALL:
+                    source_move_clients(fallback_source, source, NULL, NAVIGATION_DIRECTION_REPLACE_CURRENT);
+                break;
+                case FALLBACK_OVERRIDE_OWN:
+                    source_move_clients(fallback_source, source, NULL, NAVIGATION_DIRECTION_UP);
+                break;
+            }
+        }
 
         avl_tree_unlock(global.source_tree);
     }
+    source->rchannel_queue = (rchannel_queue_t*) malloc(sizeof(rchannel_queue_t));
+    source->rchannel_queue->head = NULL;
+    source->rchannel_queue->tail = NULL;
+    source->rchannel_queue->size = 0;
 }
 
 
@@ -863,9 +908,10 @@ static void source_shutdown (source_t *source)
         avl_tree_rlock(global.source_tree);
         fallback_source = source_find_mount(source->fallback_mount);
 
-        if (fallback_source != NULL)
-            source_move_clients(source, fallback_source, NULL);
-
+        if (fallback_source != NULL) {
+            source_move_clients(source, fallback_source, NULL, NAVIGATION_DIRECTION_DOWN);
+            source_move_rchannel_queue(source, fallback_source);
+        }
         avl_tree_unlock(global.source_tree);
     }
 
@@ -911,22 +957,6 @@ static void source_shutdown (source_t *source)
 }
 
 
-static int _compare_clients(void *compare_arg, void *a, void *b)
-{
-    client_t *clienta = (client_t *) a;
-    client_t *clientb = (client_t *) b;
-
-    (void)compare_arg;
-
-    connection_t *cona = clienta->con;
-    connection_t *conb = clientb->con;
-
-    if (cona->id < conb->id) return -1;
-    if (cona->id > conb->id) return 1;
-
-    return 0;
-}
-
 int source_remove_client(void *key)
 {
     return 1;
@@ -1442,3 +1472,84 @@ void source_recheck_mounts (int update_all)
     avl_tree_unlock (global.source_tree);
     config_release_config();
 }
+
+
+/* Get size of rchannel queue */
+int get_rchannel_queue_size(source_t * source)
+{
+    if(source == NULL){
+        ICECAST_LOG_WARN("Source not found, queue is empty invalid call");
+        return 0;
+    }
+    thread_mutex_lock(&source->lock);
+    int size = get_size(source->rchannel_queue);
+    thread_mutex_unlock(&source->lock);
+    return size;
+}
+
+/* Add a message to rchannel queue helper
+* Needs to be called with source lock acquired
+*/
+
+
+/* Add a message to rchannel queue */
+int add_message_rchannel_queue(source_t * source, const char * message)
+{
+    if(source == NULL){
+        ICECAST_LOG_WARN("Source not found, add_message_rchannel_queue failed.");
+        return 0;
+    }
+    thread_mutex_lock(&source->lock);
+    int res = push(source->rchannel_queue, message);
+    thread_mutex_unlock(&source->lock);
+    return res;
+}
+
+/* Get the message from front of rchannel queue (FIFO) and copy it to buffer buf */
+char * get_message_rchannel_queue(source_t * source){
+    if(source == NULL){
+        ICECAST_LOG_WARN("Source not found, get_message_rchannel_queue failed");
+        return NULL;
+    }
+    thread_mutex_lock(&source->lock);
+    char * res = front(source->rchannel_queue);
+    thread_mutex_unlock(&source->lock);
+    return res;
+}
+
+/* Remove a message from rchannel queue, fails return -1 if queue is empty */
+int remove_message_rchannel_queue(source_t * source)
+{
+    if(source == NULL) return -1;
+    thread_mutex_lock(&source->lock);
+    int res = pop(source->rchannel_queue);
+    thread_mutex_unlock(&source->lock);
+    return res;
+}
+
+/* Copy rchannel queue messages from source to fallback source */
+void source_move_rchannel_queue(source_t * source, source_t * fallback_source)
+{
+    if(source == NULL || fallback_source == NULL) return;
+    int res = 0;
+    while(1){
+        char * buf  = get_message_rchannel_queue(source);
+        if(buf == NULL) break;
+        res = add_message_rchannel_queue(fallback_source, buf);
+        free(buf);
+        if(res == -1) break;
+    }
+}
+
+/*Used to free the rchannel queue when a source is shut down.*/
+void rchannel_queue_destroy(source_t * source)
+{
+    if(source == NULL) return;
+    thread_mutex_lock(&source->lock);
+    int res = 0;
+    do{
+        res = pop(source->rchannel_queue);
+    }
+    while(res != -1);
+    thread_mutex_unlock(&source->lock);
+}
diff --git a/src/source.h b/src/source.h
index e35e9d909d6bd45a4d303341c9c73a976604a070..3f5afaffce7fbf6b4e94efce0e5c4fb3639e6d21 100644
--- a/src/source.h
+++ b/src/source.h
@@ -25,6 +25,10 @@
 #include "util.h"
 #include "format.h"
 #include "playlist.h"
+#include "rqueue.h"
+
+#define MESSAGE_MAXSIZE 255 /* Max size of a rchannel message */
+#define RCHANNEL_QUEUE_MAXSIZE 10
 
 struct source_tag {
     mutex_t lock;
@@ -33,7 +37,8 @@ struct source_tag {
     http_parser_t *parser;
     time_t client_stats_update;
     
-    char *mount;
+    char *mount; // TODO: Should we at some point migrate away from this to only use identifier?
+    mount_identifier_t *identifier;
 
     /* If this source drops, try to move all clients to this fallback */
     char *fallback_mount;
@@ -60,7 +65,7 @@ struct source_tag {
     unsigned long prev_listeners;
     long max_listeners;
     int yp_public;
-    int fallback_override;
+    fallback_override_t fallback_override;
     int fallback_when_full;
     int shoutcast_compat;
 
@@ -84,6 +89,7 @@ struct source_tag {
     refbuf_t *stream_data_tail;
 
     playlist_t *history;
+    rchannel_queue_t * rchannel_queue; // queue for return channel
 };
 
 source_t *source_reserve (const char *mount);
@@ -91,15 +97,22 @@ void *source_client_thread (void *arg);
 void source_client_callback (client_t *client, void *source);
 void source_update_settings (ice_config_t *config, source_t *source, mount_proxy *mountinfo);
 void source_clear_source (source_t *source);
-source_t *source_find_mount(const char *mount);
+#define source_find_mount(mount) source_find_mount_with_history((mount), NULL)
+source_t *source_find_mount_with_history(const char *mount, navigation_history_t *history);
 source_t *source_find_mount_raw(const char *mount);
 client_t *source_find_client(source_t *source, connection_id_t id);
 int source_compare_sources(void *arg, void *a, void *b);
 void source_free_source(source_t *source);
-void source_move_clients(source_t *source, source_t *dest, connection_id_t *id);
+void source_move_clients(source_t *source, source_t *dest, connection_id_t *id, navigation_direction_t direction);
 int source_remove_client(void *key);
 void source_main(source_t *source);
 void source_recheck_mounts (int update_all);
+int add_message_rchannel_queue(source_t * source, const char * message);
+char * get_message_rchannel_queue(source_t * source);
+int remove_message_rchannel_queue(source_t * source);
+int get_rchannel_queue_size(source_t * source);
+void rchannel_queue_destroy(source_t * source);
+void source_move_rchannel_queue(source_t * source, source_t * fallback_source);
 
 extern mutex_t move_clients_mutex;
 
diff --git a/src/yp.c b/src/yp.c
index acd31ae7ad0be17fed566be39af51b804ea795d5..7248a2559e81683a8ad6950d833a06c93319b42b 100644
--- a/src/yp.c
+++ b/src/yp.c
@@ -30,6 +30,7 @@
 #include "cfgfile.h"
 #include "stats.h"
 #include "listensocket.h"
+#include "prng.h"
 
 #ifdef WIN32
 #define snprintf _snprintf
@@ -111,6 +112,8 @@ static size_t handle_returned_header (void *ptr, size_t size, size_t nmemb, void
     ypdata_t *yp = stream;
     size_t bytes = size * nmemb;
 
+    prng_write(ptr, bytes);
+
     /* ICECAST_LOG_DEBUG("header from YP is \"%.*s\"", bytes, ptr); */
     if (strncasecmp (ptr, "YPResponse: 1", 13) == 0)
         yp->cmd_ok = 1;
diff --git a/web/assets/css/style.css b/web/assets/css/style.css
index 00e634682bbf596b244763f3f23dc1cba3ef287f..1a1306243f11fa8d65fd1024f4beaf27f6b28599 100644
--- a/web/assets/css/style.css
+++ b/web/assets/css/style.css
@@ -343,6 +343,11 @@ aside {
     list-style: none;
 }
 
+.maintenance-level-error > *:first-child::before {
+    font-weight: bold;
+    content: "Error: ";
+}
+
 .maintenance-level-warning > *:first-child::before {
     font-weight: bold;
     content: "Warning: ";