diff --git a/lib/fcup_request.h b/lib/fcup_request.h
index b84ef97..bbb2e75 100644
--- a/lib/fcup_request.h
+++ b/lib/fcup_request.h
@@ -70,12 +70,13 @@ char *create_fcup_request(const char *url, int request_id, const char *client_se
 int fcup_request(void *conn_opaque, const char *media_url, const char *client_session_id, int request_id) {
 
     raop_conn_t *conn = (raop_conn_t *) conn_opaque;
+    raop_t *raop = conn->raop;
     int datalen = 0;
     int requestlen = 0;
 
-    int socket_fd = httpd_get_connection_socket_by_type(conn->raop->httpd, CONNECTION_TYPE_PTTH, 1);
+    int socket_fd = httpd_get_connection_socket_by_type(raop->httpd, CONNECTION_TYPE_PTTH, 1);
     
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "fcup_request send socket = %d", socket_fd);
+    logger_log(raop->logger, LOGGER_DEBUG, "fcup_request send socket = %d", socket_fd);
     
     /* create xml plist request data */
     char *plist_xml = create_fcup_request(media_url, request_id, client_session_id, &datalen);
@@ -93,20 +94,20 @@ int fcup_request(void *conn_opaque, const char *media_url, const char *client_se
     int send_len = send(socket_fd, http_request, requestlen, 0);
     if (send_len < 0) {
         int sock_err = SOCKET_GET_ERROR();
-	logger_log(conn->raop->logger, LOGGER_ERR, "fcup_request: send  error %d:%s\n",
+	logger_log(raop->logger, LOGGER_ERR, "fcup_request: send  error %d:%s\n",
 		 sock_err, SOCKET_ERROR_STRING(sock_err));
 	http_response_destroy(request);
         /* shut down connection? */
         return -1;
     }
 
-    if (logger_get_level(conn->raop->logger) >= LOGGER_DEBUG) {
+    if (logger_get_level(raop->logger) >= LOGGER_DEBUG) {
       char *request_str =  utils_data_to_text(http_request, requestlen);
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "\n%s", request_str);
+        logger_log(raop->logger, LOGGER_DEBUG, "\n%s", request_str);
         free (request_str);
     }
     http_response_destroy(request);
-    logger_log(conn->raop->logger, LOGGER_DEBUG,"fcup_request: send sent Request of %d bytes from socket %d\n",
+    logger_log(raop->logger, LOGGER_DEBUG,"fcup_request: send sent Request of %d bytes from socket %d\n",
                send_len, socket_fd);
     return 0;
 }
diff --git a/lib/raop.c b/lib/raop.c
index c5ea215..5a47883 100644
--- a/lib/raop.c
+++ b/lib/raop.c
@@ -155,10 +155,10 @@ conn_init(void *opaque, unsigned char *local, int locallen, unsigned char *remot
     }
 
     utils_ipaddress_to_string(locallen, local, zone_id, ip_address, (int) sizeof(ip_address));
-    logger_log(conn->raop->logger, LOGGER_INFO, "Local : %s", ip_address);
+    logger_log(raop->logger, LOGGER_INFO, "Local : %s", ip_address);
 
     utils_ipaddress_to_string(remotelen, remote, zone_id, ip_address, (int) sizeof(ip_address));
-    logger_log(conn->raop->logger, LOGGER_INFO, "Remote: %s", ip_address);
+    logger_log(raop->logger, LOGGER_INFO, "Remote: %s", ip_address);
 
     conn->local = (unsigned char *) malloc(locallen);
     assert(conn->local);
@@ -192,10 +192,11 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
     char *response_data = NULL;
     int response_datalen = 0;
     raop_conn_t *conn = ptr;
+    raop_t *raop = conn->raop;
     bool hls_request = false;
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "conn_request");
-    bool logger_debug = (logger_get_level(conn->raop->logger) >= LOGGER_DEBUG);
-    bool logger_debug_data = (logger_get_level(conn->raop->logger) >= LOGGER_DEBUG_DATA);
+    logger_log(raop->logger, LOGGER_DEBUG, "conn_request");
+    bool logger_debug = (logger_get_level(raop->logger) >= LOGGER_DEBUG);
+    bool logger_debug_data = (logger_get_level(raop->logger) >= LOGGER_DEBUG_DATA);
 
     /* 
     All requests arriving here have been parsed by llhttp to obtain 
@@ -224,13 +225,13 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
     const char *cseq = http_request_get_header(request, "CSeq");
     bool ble = false;
     if (!strcmp(protocol,"RTSP/1.0") && !cseq  && (strstr(url, "txtAirPlay") || strstr(url, "txtRAOP") )) {
-        logger_log(conn->raop->logger, LOGGER_INFO, "response to Bluetooth LE beacon advertisement received)");
+        logger_log(raop->logger, LOGGER_INFO, "response to Bluetooth LE beacon advertisement received)");
         ble = true;
     }
 
  /* this rejects messages from _airplay._tcp for video streaming protocol unless bool raop->hls_support is true*/   
-    if (!cseq && !conn->raop->hls_support && !ble) {
-        logger_log(conn->raop->logger, LOGGER_INFO, "ignoring AirPlay video streaming request (use option -hls to activate HLS support)");
+    if (!cseq && !raop->hls_support && !ble) {
+        logger_log(raop->logger, LOGGER_INFO, "ignoring AirPlay video streaming request (use option -hls to activate HLS support)");
         return;
     }
 
@@ -240,62 +241,62 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
 
     if (conn->connection_type == CONNECTION_TYPE_UNKNOWN) {
         if (cseq || ble) {
-            if (httpd_count_connection_type(conn->raop->httpd, CONNECTION_TYPE_RAOP)) {
+            if (httpd_count_connection_type(raop->httpd, CONNECTION_TYPE_RAOP)) {
                 char ipaddr[40] = { '\0' };
                 utils_ipaddress_to_string(conn->remotelen, conn->remote, conn->zone_id, ipaddr, (int) (sizeof(ipaddr)));
-                if (httpd_nohold(conn->raop->httpd)) {
-                    logger_log(conn->raop->logger, LOGGER_INFO, "*****\"nohold\" feature: switch to new connection request from %s", ipaddr);		  
-                    httpd_remove_known_connections(conn->raop->httpd);
-                    if (conn->raop->callbacks.video_reset) {
-                        conn->raop->callbacks.video_reset(conn->raop->callbacks.cls, false, true);
+                if (httpd_nohold(raop->httpd)) {
+                    logger_log(raop->logger, LOGGER_INFO, "*****\"nohold\" feature: switch to new connection request from %s", ipaddr);		  
+                    httpd_remove_known_connections(raop->httpd);
+                    if (raop->callbacks.video_reset) {
+                        raop->callbacks.video_reset(raop->callbacks.cls, false, true);
                     }
                 } else {
-                    logger_log(conn->raop->logger, LOGGER_WARNING, "rejecting new connection request from %s", ipaddr);
+                    logger_log(raop->logger, LOGGER_WARNING, "rejecting new connection request from %s", ipaddr);
                     *response = http_response_create();
                     http_response_init(*response, protocol, 409, "Conflict: Server is connected to another client");
                     goto finish;
                 }
             }
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "New connection %p identified as Connection type RAOP", ptr);
-            httpd_set_connection_type(conn->raop->httpd, ptr, CONNECTION_TYPE_RAOP);
+            logger_log(raop->logger, LOGGER_DEBUG, "New connection %p identified as Connection type RAOP", ptr);
+            httpd_set_connection_type(raop->httpd, ptr, CONNECTION_TYPE_RAOP);
             conn->connection_type = CONNECTION_TYPE_RAOP;
         } else if (client_session_id) {
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "New connection %p identified as Connection type AirPlay", ptr);            
-            httpd_set_connection_type(conn->raop->httpd, ptr, CONNECTION_TYPE_AIRPLAY);
+            logger_log(raop->logger, LOGGER_DEBUG, "New connection %p identified as Connection type AirPlay", ptr);            
+            httpd_set_connection_type(raop->httpd, ptr, CONNECTION_TYPE_AIRPLAY);
             conn->connection_type = CONNECTION_TYPE_AIRPLAY;
             conn->client_session_id = (char *) calloc(strlen(client_session_id) + 1, sizeof(char));
             assert(conn->client_session_id);
             memcpy(conn->client_session_id, client_session_id, strlen(client_session_id));
             /* airplay video has been requested: shut down any running RAOP udp services */
-            raop_conn_t *raop_conn = (raop_conn_t *) httpd_get_connection_by_type(conn->raop->httpd, CONNECTION_TYPE_RAOP, 1);
+            raop_conn_t *raop_conn = (raop_conn_t *) httpd_get_connection_by_type(raop->httpd, CONNECTION_TYPE_RAOP, 1);
             if (raop_conn) {
                 raop_rtp_mirror_t *raop_rtp_mirror = raop_conn->raop_rtp_mirror;
                 if (raop_rtp_mirror) {
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "New AirPlay connection: stopping RAOP mirror"
+                    logger_log(raop->logger, LOGGER_DEBUG, "New AirPlay connection: stopping RAOP mirror"
                                " service on RAOP connection %p", raop_conn);
                     raop_rtp_mirror_stop(raop_rtp_mirror);
                 }
 
                 raop_rtp_t *raop_rtp = raop_conn->raop_rtp;
                 if (raop_rtp) {
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "New AirPlay connection: stopping RAOP audio"
+                    logger_log(raop->logger, LOGGER_DEBUG, "New AirPlay connection: stopping RAOP audio"
                                " service on RAOP connection %p", raop_conn);
                     raop_rtp_stop(raop_rtp);
                 }
 
                 raop_ntp_t *raop_ntp = raop_conn->raop_ntp;
                 if (raop_rtp) {
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "New AirPlay connection: stopping NTP time"
+                    logger_log(raop->logger, LOGGER_DEBUG, "New AirPlay connection: stopping NTP time"
                                " service on RAOP connection %p", raop_conn);
                     raop_ntp_stop(raop_ntp);
                 }
             }
         } else if (host) {
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "New connection %p identified as Connection type HLS", ptr);            
-            httpd_set_connection_type(conn->raop->httpd, ptr, CONNECTION_TYPE_HLS);
+            logger_log(raop->logger, LOGGER_DEBUG, "New connection %p identified as Connection type HLS", ptr);            
+            httpd_set_connection_type(raop->httpd, ptr, CONNECTION_TYPE_HLS);
             conn->connection_type = CONNECTION_TYPE_HLS;
         } else {
-            logger_log(conn->raop->logger, LOGGER_WARNING, "connection from unknown connection type");
+            logger_log(raop->logger, LOGGER_WARNING, "connection from unknown connection type");
         }	  
     }
 
@@ -312,21 +313,21 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
         const char *active_remote = http_request_get_header(request, "Active-Remote");
         if (active_remote) {
             conn->have_active_remote = true;
-            if (conn->raop->callbacks.export_dacp) {
+            if (raop->callbacks.export_dacp) {
                 const char *dacp_id = http_request_get_header(request, "DACP-ID");
-                conn->raop->callbacks.export_dacp(conn->raop->callbacks.cls, active_remote, dacp_id);
+                raop->callbacks.export_dacp(raop->callbacks.cls, active_remote, dacp_id);
             }
         }
     }
 
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "\n%s %s %s", method, url, protocol);
+    logger_log(raop->logger, LOGGER_DEBUG, "\n%s %s %s", method, url, protocol);
     if (!strcmp(url,"/playback-info")) {
         logger_debug = logger_debug_data;
     }
     char *header_str= NULL; 
     http_request_get_header_string(request, &header_str);
     if (header_str && logger_debug) {
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "%s", header_str);
+        logger_log(raop->logger, LOGGER_DEBUG, "%s", header_str);
         bool data_is_plist = (strstr(header_str,"apple-binary-plist") != NULL);
         bool data_is_text = (strstr(header_str,"text/") != NULL);
         int request_datalen = 0;
@@ -342,7 +343,7 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
                     uint32_t plist_len = 0;
                     plist_to_xml(req_root_node, &plist_xml, &plist_len);
                     stripped_xml = utils_strip_data_from_plist_xml(plist_xml);
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "%s", (stripped_xml ? stripped_xml : plist_xml));
+                    logger_log(raop->logger, LOGGER_DEBUG, "%s", (stripped_xml ? stripped_xml : plist_xml));
                     if (stripped_xml) {
                         free(stripped_xml);
                     }
@@ -352,11 +353,11 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
                     plist_free(req_root_node);
                 } else if (data_is_text) {
                     char *data_str = utils_data_to_text((char *) request_data, request_datalen);
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "%s", data_str);                    
+                    logger_log(raop->logger, LOGGER_DEBUG, "%s", data_str);                    
                     free(data_str);
                 } else {
                     char *data_str =  utils_data_to_string((unsigned char *) request_data, request_datalen, 16);
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "%s", data_str);
+                    logger_log(raop->logger, LOGGER_DEBUG, "%s", data_str);
                     free(data_str);
                 }
             }
@@ -370,7 +371,7 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
         assert(!strcmp(client_session_id, conn->client_session_id));
     }
 
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "Handling request %s with URL %s", method, url);
+    logger_log(raop->logger, LOGGER_DEBUG, "Handling request %s with URL %s", method, url);
     raop_handler_t handler = NULL;
     if (!hls_request && !strcmp(protocol, "RTSP/1.0")) {
         if (!strcmp(method, "POST")) {
@@ -447,7 +448,7 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
     if (handler != NULL) {
         handler(conn, request, *response, &response_data, &response_datalen);
     } else {
-        logger_log(conn->raop->logger, LOGGER_INFO,
+        logger_log(raop->logger, LOGGER_INFO,
                    "Unhandled Client Request: %s %s %s", method, url, protocol);
     }
 
@@ -476,7 +477,7 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
         char *ptr = strchr(header_str, '\n');
         *(++ptr) = '\0';
     }
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "%s", header_str);
+    logger_log(raop->logger, LOGGER_DEBUG, "%s", header_str);
     free(header_str);
     if (response_data) {
         if (response_datalen > 0 && logger_debug) {
@@ -489,7 +490,7 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
                 uint32_t plist_len;
                 plist_to_xml(res_root_node, &plist_xml, &plist_len);
                 stripped_xml = utils_strip_data_from_plist_xml(plist_xml);
-                logger_log(conn->raop->logger, LOGGER_DEBUG, "%s", (stripped_xml ? stripped_xml : plist_xml));
+                logger_log(raop->logger, LOGGER_DEBUG, "%s", (stripped_xml ? stripped_xml : plist_xml));
                 if (stripped_xml) {
                     free(stripped_xml);
                 }
@@ -499,11 +500,11 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
                 plist_free(res_root_node);
             } else if (data_is_text) {
                 char *data_str = utils_data_to_text((char*) response_data, response_datalen);
-                logger_log(conn->raop->logger, LOGGER_DEBUG, "%s", data_str);                    
+                logger_log(raop->logger, LOGGER_DEBUG, "%s", data_str);                    
                 free(data_str);
             } else {
                 char *data_str = utils_data_to_string((unsigned char *) response_data, response_datalen, 16);
-                logger_log(conn->raop->logger, LOGGER_DEBUG, "%s", data_str);
+                logger_log(raop->logger, LOGGER_DEBUG, "%s", data_str);
                 free(data_str);
             }
         }
@@ -516,11 +517,11 @@ conn_request(void *ptr, http_request_t *request, http_response_t **response) {
 static void
 conn_destroy(void *ptr) {
     raop_conn_t *conn = ptr;
+    raop_t *raop = conn->raop;
+    logger_log(raop->logger, LOGGER_DEBUG, "Destroying connection");
 
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "Destroying connection");
-
-    if (conn->raop->callbacks.conn_destroy) {
-        conn->raop->callbacks.conn_destroy(conn->raop->callbacks.cls);
+    if (raop->callbacks.conn_destroy) {
+        raop->callbacks.conn_destroy(raop->callbacks.cls);
     }
 
     if (conn->raop_rtp) {
@@ -535,8 +536,8 @@ conn_destroy(void *ptr) {
         raop_ntp_destroy(conn->raop_ntp);
     }
 
-    if (conn->raop->callbacks.video_flush) {
-        conn->raop->callbacks.video_flush(conn->raop->callbacks.cls);
+    if (raop->callbacks.video_flush) {
+        raop->callbacks.video_flush(raop->callbacks.cls);
     }
 
     free(conn->local);
diff --git a/lib/raop_handlers.h b/lib/raop_handlers.h
index 8ff1dda..1944760 100644
--- a/lib/raop_handlers.h
+++ b/lib/raop_handlers.h
@@ -38,7 +38,8 @@ raop_handler_info(raop_conn_t *conn,
                   http_request_t *request, http_response_t *response,
                   char **response_data, int *response_datalen)
 {
-    assert(conn->raop->dnssd);
+    raop_t *raop = conn->raop;
+    assert(raop->dnssd);
 
     /* There are three possible RTSP/1.0  GET/info requests
        (1) with a CSeq number and with a plist
@@ -93,13 +94,13 @@ raop_handler_info(raop_conn_t *conn,
     }
     
     if (add_txt_airplay) {
-        const char *txt = dnssd_get_airplay_txt(conn->raop->dnssd, &len);
+        const char *txt = dnssd_get_airplay_txt(raop->dnssd, &len);
         plist_t txt_airplay_node = plist_new_data(txt, len);
         plist_dict_set_item(res_node, txtAirPlay, txt_airplay_node);
     }
 
     if (add_txt_raop) {
-        const char *txt = dnssd_get_raop_txt(conn->raop->dnssd, &len);
+        const char *txt = dnssd_get_raop_txt(raop->dnssd, &len);
         plist_t txt_raop_node = plist_new_data(txt, len);
         plist_dict_set_item(res_node, txtRAOP, txt_raop_node);
     }
@@ -111,7 +112,7 @@ raop_handler_info(raop_conn_t *conn,
  
     /* deviceID is the physical hardware address, and will not change */
     int hw_addr_raw_len = 0;
-    const char *hw_addr_raw = dnssd_get_hw_addr(conn->raop->dnssd, &hw_addr_raw_len);
+    const char *hw_addr_raw = dnssd_get_hw_addr(raop->dnssd, &hw_addr_raw_len);
     char *hw_addr = calloc(1, 3 * hw_addr_raw_len);
     //int hw_addr_len =
     utils_hwaddr_airplay(hw_addr, 3 * hw_addr_raw_len, hw_addr_raw, hw_addr_raw_len);
@@ -124,17 +125,17 @@ raop_handler_info(raop_conn_t *conn,
    
     /* Persistent Public Key */
     int pk_len = 0;
-    char *pk = utils_parse_hex(conn->raop->pk_str, strlen(conn->raop->pk_str), &pk_len);
+    char *pk = utils_parse_hex(raop->pk_str, strlen(raop->pk_str), &pk_len);
     plist_t pk_node = plist_new_data(pk, pk_len);
     plist_dict_set_item(res_node, "pk", pk_node);
     free(pk);
 
-    uint64_t features = dnssd_get_airplay_features(conn->raop->dnssd);
+    uint64_t features = dnssd_get_airplay_features(raop->dnssd);
     plist_t features_node = plist_new_uint(features);
     plist_dict_set_item(res_node, "features", features_node);
 
     int name_len = 0;
-    const char *name = dnssd_get_name(conn->raop->dnssd, &name_len);
+    const char *name = dnssd_get_name(raop->dnssd, &name_len);
     plist_t name_node = plist_new_string(name);
     plist_dict_set_item(res_node, "name", name_node);
 
@@ -216,14 +217,14 @@ raop_handler_info(raop_conn_t *conn,
     plist_t displays_0_width_physical_node = plist_new_uint(0);
     plist_t displays_0_height_physical_node = plist_new_uint(0);
     plist_t displays_0_uuid_node = plist_new_string("e0ff8a27-6738-3d56-8a16-cc53aacee925");
-    plist_t displays_0_width_node = plist_new_uint(conn->raop->width);
-    plist_t displays_0_height_node = plist_new_uint(conn->raop->height);
-    plist_t displays_0_width_pixels_node = plist_new_uint(conn->raop->width);
-    plist_t displays_0_height_pixels_node = plist_new_uint(conn->raop->height);
+    plist_t displays_0_width_node = plist_new_uint(raop->width);
+    plist_t displays_0_height_node = plist_new_uint(raop->height);
+    plist_t displays_0_width_pixels_node = plist_new_uint(raop->width);
+    plist_t displays_0_height_pixels_node = plist_new_uint(raop->height);
     plist_t displays_0_rotation_node = plist_new_bool(0); /* set to true in AppleTV gen 3 (which has features bit 8  set */
-    plist_t displays_0_refresh_rate_node = plist_new_real((double) 1.0 / conn->raop->refreshRate);  /* set as real 0.166666  = 60hz in AppleTV gen 3 */
-    plist_t displays_0_max_fps_node = plist_new_uint(conn->raop->maxFPS);
-    plist_t displays_0_overscanned_node = plist_new_bool(conn->raop->overscanned);
+    plist_t displays_0_refresh_rate_node = plist_new_real((double) 1.0 / raop->refreshRate);  /* set as real 0.166666  = 60hz in AppleTV gen 3 */
+    plist_t displays_0_max_fps_node = plist_new_uint(raop->maxFPS);
+    plist_t displays_0_overscanned_node = plist_new_bool(raop->overscanned);
     plist_t displays_0_features = plist_new_uint(14);
 
     plist_dict_set_item(displays_0_node, "uuid", displays_0_uuid_node);
@@ -251,24 +252,25 @@ static void
 raop_handler_pairpinstart(raop_conn_t *conn,
                           http_request_t *request, http_response_t *response,
                           char **response_data, int *response_datalen) {
-    logger_log(conn->raop->logger, LOGGER_INFO, "client sent PAIR-PIN-START request");
+    raop_t *raop = conn->raop;
+    logger_log(raop->logger, LOGGER_INFO, "client sent PAIR-PIN-START request");
     int pin_4 = 0;
-    if (conn->raop->pin > 9999) {
-        pin_4 = conn->raop->pin % 10000;
+    if (raop->pin > 9999) {
+        pin_4 = raop->pin % 10000;
     } else {
         pin_4 = random_pin();
         if (pin_4 < 0) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Failed to generate random pin");
+            logger_log(raop->logger, LOGGER_ERR, "Failed to generate random pin");
         } else {
-            conn->raop->pin = (unsigned short) pin_4 % 10000;
+            raop->pin = (unsigned short) pin_4 % 10000;
         }
     }
     char pin[6] = { '\0' };
     snprintf(pin, 5, "%04u", pin_4);
-    if (conn->raop->callbacks.display_pin) {
-         conn->raop->callbacks.display_pin(conn->raop->callbacks.cls, pin);
+    if (raop->callbacks.display_pin) {
+         raop->callbacks.display_pin(raop->callbacks.cls, pin);
     }
-    logger_log(conn->raop->logger, LOGGER_INFO, "*** CLIENT MUST NOW ENTER PIN = \"%s\" AS AIRPLAY PASSWORD", pin);
+    logger_log(raop->logger, LOGGER_INFO, "*** CLIENT MUST NOW ENTER PIN = \"%s\" AS AIRPLAY PASSWORD", pin);
     *response_data = NULL;
     response_datalen = 0;
 }
@@ -277,22 +279,22 @@ static void
 raop_handler_pairsetup_pin(raop_conn_t *conn,
                            http_request_t *request, http_response_t *response,
                            char **response_data, int *response_datalen) {
-
+    raop_t *raop = conn->raop;
     const char *request_data = NULL;;
     int request_datalen = 0;
     bool data_is_plist = false;
-    bool logger_debug = (logger_get_level(conn->raop->logger) >= LOGGER_DEBUG);
+    bool logger_debug = (logger_get_level(raop->logger) >= LOGGER_DEBUG);
     request_data = http_request_get_data(request, &request_datalen);
-    logger_log(conn->raop->logger, LOGGER_INFO, "client requested pair-setup-pin, datalen = %d", request_datalen);
+    logger_log(raop->logger, LOGGER_INFO, "client requested pair-setup-pin, datalen = %d", request_datalen);
     if (request_datalen > 0) {
         char *header_str= NULL; 
         http_request_get_header_string(request, &header_str);
-        logger_log(conn->raop->logger, LOGGER_INFO, "request header: %s", header_str);
+        logger_log(raop->logger, LOGGER_INFO, "request header: %s", header_str);
         data_is_plist = (strstr(header_str,"apple-binary-plist") != NULL);
         free(header_str);
     }
     if (!data_is_plist) {
-        logger_log(conn->raop->logger, LOGGER_INFO, "did not receive expected plist from client, request_datalen = %d",
+        logger_log(raop->logger, LOGGER_INFO, "did not receive expected plist from client, request_datalen = %d",
                   request_datalen);
         goto authentication_failed;
     }
@@ -317,7 +319,7 @@ raop_handler_pairsetup_pin(raop_conn_t *conn,
         char *user = NULL;
         plist_get_string_val(req_method_node, &method);
         if (strncmp(method, "pin", strlen (method))) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "error, required method is \"pin\", client requested \"%s\"", method);
+            logger_log(raop->logger, LOGGER_ERR, "error, required method is \"pin\", client requested \"%s\"", method);
             *response_data = NULL;
             response_datalen = 0;
 	    free (method);
@@ -327,18 +329,18 @@ raop_handler_pairsetup_pin(raop_conn_t *conn,
         plist_mem_free(method);
         method = NULL;
         plist_get_string_val(req_user_node, &user);
-        logger_log(conn->raop->logger, LOGGER_INFO, "pair-setup-pin:  device_id = %s", user);
-        snprintf(pin, 6, "%04u", conn->raop->pin % 10000);
-        if (conn->raop->pin < 10000) {
-            conn->raop->pin = 0;
+        logger_log(raop->logger, LOGGER_INFO, "pair-setup-pin:  device_id = %s", user);
+        snprintf(pin, 6, "%04u", raop->pin % 10000);
+        if (raop->pin < 10000) {
+            raop->pin = 0;
         }
-        int ret = srp_new_user(conn->session, conn->raop->pairing, (const char *) user,
+        int ret = srp_new_user(conn->session, raop->pairing, (const char *) user,
                                (const char *) pin, &salt, &len_salt, &pk, &len_pk);
         plist_mem_free(user);
         user = NULL;
         plist_free(req_root_node);
         if (ret < 0) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "failed to create user, err = %d", ret);
+            logger_log(raop->logger, LOGGER_ERR, "failed to create user, err = %d", ret);
             goto authentication_failed;
         }
         plist_t res_root_node = plist_new_dict();
@@ -362,22 +364,22 @@ raop_handler_pairsetup_pin(raop_conn_t *conn,
         plist_get_data_val(req_proof_node, &client_proof, &client_proof_len);
         if (logger_debug) {
             char *str = utils_data_to_string((const unsigned char *) client_proof, client_proof_len, 20);
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "client SRP6a proof <M> :\n%s", str);	    
+            logger_log(raop->logger, LOGGER_DEBUG, "client SRP6a proof <M> :\n%s", str);	    
             free (str);
         }
         memcpy(proof, client_proof, (int) client_proof_len);
         free (client_proof);
-        int ret = srp_validate_proof(conn->session, conn->raop->pairing, (const unsigned char *) client_pk,
+        int ret = srp_validate_proof(conn->session, raop->pairing, (const unsigned char *) client_pk,
                                      (int) client_pk_len, proof, (int) client_proof_len, (int) sizeof(proof));
         free (client_pk);
         plist_free(req_root_node);
         if (ret < 0) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Client Authentication Failure (client proof not validated)");
+            logger_log(raop->logger, LOGGER_ERR, "Client Authentication Failure (client proof not validated)");
             goto authentication_failed;
         }
         if (logger_debug) {
 	    char *str = utils_data_to_string((const unsigned char *) proof, sizeof(proof), 20);
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "server SRP6a proof <M1> :\n%s", str);
+            logger_log(raop->logger, LOGGER_DEBUG, "server SRP6a proof <M1> :\n%s", str);
             free (str);
         }
         plist_t res_root_node = plist_new_dict();
@@ -401,9 +403,9 @@ raop_handler_pairsetup_pin(raop_conn_t *conn,
 
         if (logger_debug) {
             char *str = utils_data_to_string((const unsigned char *) client_epk, client_epk_len, 16);
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "client_epk %d:\n%s\n", (int) client_epk_len, str);
+            logger_log(raop->logger, LOGGER_DEBUG, "client_epk %d:\n%s\n", (int) client_epk_len, str);
             str = utils_data_to_string((const unsigned char *) client_authtag, client_authtag_len, 16);
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "client_authtag  %d:\n%s\n", (int) client_authtag_len, str);
+            logger_log(raop->logger, LOGGER_DEBUG, "client_authtag  %d:\n%s\n", (int) client_authtag_len, str);
             free (str);
         }
 
@@ -412,12 +414,12 @@ raop_handler_pairsetup_pin(raop_conn_t *conn,
         free (client_authtag);
         free (client_epk);
         plist_free(req_root_node);
-        ret = srp_confirm_pair_setup(conn->session, conn->raop->pairing, epk, authtag);
+        ret = srp_confirm_pair_setup(conn->session, raop->pairing, epk, authtag);
         if (ret < 0) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "pair-pin-setup (step 3): client authentication failed\n");
+            logger_log(raop->logger, LOGGER_ERR, "pair-pin-setup (step 3): client authentication failed\n");
             goto authentication_failed;
         } else {
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "pair-pin-setup success\n");
+            logger_log(raop->logger, LOGGER_DEBUG, "pair-pin-setup success\n");
         }
         pairing_session_set_setup_status(conn->session);
         plist_t res_root_node = plist_new_dict();
@@ -439,6 +441,7 @@ raop_handler_pairsetup(raop_conn_t *conn,
                        http_request_t *request, http_response_t *response,
                        char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;
     unsigned char public_key[ED25519_KEY_SIZE];
     //const char *data;
     int datalen = 0;
@@ -446,11 +449,11 @@ raop_handler_pairsetup(raop_conn_t *conn,
     //data =
     http_request_get_data(request, &datalen);
     if (datalen != 32) {
-        logger_log(conn->raop->logger, LOGGER_ERR, "Invalid pair-setup data");
+        logger_log(raop->logger, LOGGER_ERR, "Invalid pair-setup data");
         return;
     }
 
-    pairing_get_public_key(conn->raop->pairing, public_key);
+    pairing_get_public_key(raop->pairing, public_key);
     pairing_session_set_setup_status(conn->session);
 
     *response_data = calloc(1, sizeof(public_key));
@@ -466,9 +469,10 @@ raop_handler_pairverify(raop_conn_t *conn,
                         http_request_t *request, http_response_t *response,
                         char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;
     bool register_check = false;  
     if (pairing_session_check_handshake_status(conn->session)) {
-        if (conn->raop->use_pin) {
+        if (raop->use_pin) {
             pairing_session_set_setup_status(conn->session);
             register_check = true;
         } else {
@@ -482,32 +486,32 @@ raop_handler_pairverify(raop_conn_t *conn,
 
     data = (unsigned char *) http_request_get_data(request, &datalen);
     if (datalen < 4) {
-        logger_log(conn->raop->logger, LOGGER_ERR, "Invalid pair-verify data");
+        logger_log(raop->logger, LOGGER_ERR, "Invalid pair-verify data");
         return;
     }
     switch (data[0]) {
     case 1:
         if (datalen != 4 + X25519_KEY_SIZE + ED25519_KEY_SIZE) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Invalid pair-verify data");
+            logger_log(raop->logger, LOGGER_ERR, "Invalid pair-verify data");
             return;
         }
         /* We can fall through these errors, the result will just be garbage... */
         if (pairing_session_handshake(conn->session, data + 4, data + 4 + X25519_KEY_SIZE)) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Error initializing pair-verify handshake");
+            logger_log(raop->logger, LOGGER_ERR, "Error initializing pair-verify handshake");
         }
         if (pairing_session_get_public_key(conn->session, public_key)) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Error getting ECDH public key");
+            logger_log(raop->logger, LOGGER_ERR, "Error getting ECDH public key");
         }
         if (pairing_session_get_signature(conn->session, signature)) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Error getting ED25519 signature");
+            logger_log(raop->logger, LOGGER_ERR, "Error getting ED25519 signature");
         }
         if (register_check) {
             bool registered_client = true;
-            if (conn->raop->callbacks.check_register) {
+            if (raop->callbacks.check_register) {
                 const unsigned char *pk = data + 4 + X25519_KEY_SIZE;
                 char *pk64;
                 ed25519_pk_to_base64(pk, &pk64);
-                registered_client = conn->raop->callbacks.check_register(conn->raop->callbacks.cls, pk64);
+                registered_client = raop->callbacks.check_register(raop->callbacks.cls, pk64);
                 free (pk64);
             }
 
@@ -524,18 +528,18 @@ raop_handler_pairverify(raop_conn_t *conn,
         }
         break;
     case 0:
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "2nd pair-verify step: checking signature");
+        logger_log(raop->logger, LOGGER_DEBUG, "2nd pair-verify step: checking signature");
         if (datalen != 4 + PAIRING_SIG_SIZE) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Invalid pair-verify data");
+            logger_log(raop->logger, LOGGER_ERR, "Invalid pair-verify data");
             return;
         }
 
         if (pairing_session_finish(conn->session, data + 4)) {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Incorrect pair-verify signature");
+            logger_log(raop->logger, LOGGER_ERR, "Incorrect pair-verify signature");
             http_response_set_disconnect(response, 1);
             return;
         }
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "pair-verify: signature is verified");	    
+        logger_log(raop->logger, LOGGER_DEBUG, "pair-verify: signature is verified");	    
         http_response_add_header(response, "Content-Type", "application/octet-stream");
         break;
     }
@@ -546,6 +550,7 @@ raop_handler_fpsetup(raop_conn_t *conn,
                      http_request_t *request, http_response_t *response,
                      char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;  
     const unsigned char *data = NULL;
     int datalen = 0;
 
@@ -575,7 +580,7 @@ raop_handler_fpsetup(raop_conn_t *conn,
             }
         }
     } else {
-        logger_log(conn->raop->logger, LOGGER_ERR, "Invalid fp-setup data length");
+        logger_log(raop->logger, LOGGER_ERR, "Invalid fp-setup data length");
         return;
     }
 }
@@ -593,9 +598,10 @@ raop_handler_setup(raop_conn_t *conn,
                    http_request_t *request, http_response_t *response,
                    char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;
     const char *dacp_id = NULL;
     const char *active_remote_header = NULL;
-    bool logger_debug = (logger_get_level(conn->raop->logger) >= LOGGER_DEBUG);
+    bool logger_debug = (logger_get_level(raop->logger) >= LOGGER_DEBUG);
     
     const char *data = NULL;
     int data_len = 0;
@@ -605,8 +611,8 @@ raop_handler_setup(raop_conn_t *conn,
     active_remote_header = http_request_get_header(request, "Active-Remote");
 
     if (dacp_id && active_remote_header) {
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "DACP-ID: %s", dacp_id);
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "Active-Remote: %s", active_remote_header);
+        logger_log(raop->logger, LOGGER_DEBUG, "DACP-ID: %s", dacp_id);
+        logger_log(raop->logger, LOGGER_DEBUG, "Active-Remote: %s", active_remote_header);
         if (conn->raop_rtp) {
             raop_rtp_remote_control_id(conn->raop_rtp, dacp_id, active_remote_header);
         }
@@ -628,7 +634,7 @@ raop_handler_setup(raop_conn_t *conn,
         unsigned char aeskey[16] = { 0 };
         unsigned char eaeskey[72] = { 0 };
 
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "SETUP 1");
+        logger_log(raop->logger, LOGGER_DEBUG, "SETUP 1");
 
         // First setup
 
@@ -638,50 +644,50 @@ raop_handler_setup(raop_conn_t *conn,
 
 
         /* RFC2617 Digest authentication (md5 hash) of uxplay client-access password, if set */
-        if (!conn->authenticated && conn->raop->callbacks.passwd) {
+        if (!conn->authenticated && raop->callbacks.passwd) {
             size_t pin_len = 4;
             const char *authorization = NULL;
             authorization = http_request_get_header(request, "Authorization");
             if (!authorization) {
                 // if random_pw is set, but client has changed, unset it 
-                if (conn->raop->random_pw && strncmp(conn->raop->random_pw + pin_len + 1,  deviceID, 17)) {
-                    free(conn->raop->random_pw);
-                    conn->raop->random_pw = NULL;
+                if (raop->random_pw && strncmp(raop->random_pw + pin_len + 1,  deviceID, 17)) {
+                    free(raop->random_pw);
+                    raop->random_pw = NULL;
                 }
             }
             int len = 0;
-            const char *password = conn->raop->callbacks.passwd(conn->raop->callbacks.cls, &len);
+            const char *password = raop->callbacks.passwd(raop->callbacks.cls, &len);
             // len = -1 means use a random password for this connection; len = 0 means no password
-            if (len == -1 && conn->raop->random_pw && conn->raop->auth_fail_count >= MAX_PW_ATTEMPTS) {
+            if (len == -1 && raop->random_pw && raop->auth_fail_count >= MAX_PW_ATTEMPTS) {
                 // change random_pw after MAX_PW_ATTEMPTS  failed authentication attempts
-                logger_log(conn->raop->logger, LOGGER_INFO, "Too many authentication failures: generate new random password");
-                free(conn->raop->random_pw);
-                conn->raop->random_pw = NULL;
+                logger_log(raop->logger, LOGGER_INFO, "Too many authentication failures: generate new random password");
+                free(raop->random_pw);
+                raop->random_pw = NULL;
             }
-            if (len == -1 && !conn->raop->random_pw) {
+            if (len == -1 && !raop->random_pw) {
                 // get and store 4 random digits
                 int pin_4  = random_pin();
                 if (pin_4 < 0) {
-                    logger_log(conn->raop->logger, LOGGER_ERR, "Failed to generate random pin");
+                    logger_log(raop->logger, LOGGER_ERR, "Failed to generate random pin");
                     pin_4 = 1234;
                 }
-                conn->raop->random_pw =  (char *) calloc(pin_len + 1 + 18, sizeof(char));
-                char *pin = conn->raop->random_pw;
+                raop->random_pw =  (char *) calloc(pin_len + 1 + 18, sizeof(char));
+                char *pin = raop->random_pw;
                 snprintf(pin, pin_len + 1, "%04u", pin_4 % 10000);
                 pin[pin_len] = '\0';
                 snprintf(pin + pin_len + 1, 18, "%s", deviceID);
-                conn->raop->auth_fail_count = 0;
+                raop->auth_fail_count = 0;
             }
-            if (len == -1 && !authorization && conn->raop->random_pw) {
-                if (conn->raop->callbacks.display_pin) {
-                    conn->raop->callbacks.display_pin(conn->raop->callbacks.cls, conn->raop->random_pw);
+            if (len == -1 && !authorization && raop->random_pw) {
+                if (raop->callbacks.display_pin) {
+                    raop->callbacks.display_pin(raop->callbacks.cls, raop->random_pw);
                 }
-                logger_log(conn->raop->logger, LOGGER_INFO, "*** CLIENT MUST NOW ENTER PIN = \"%s\" AS AIRPLAY PASSWORD", conn->raop->random_pw);
-                conn->raop->auth_fail_count++;
+                logger_log(raop->logger, LOGGER_INFO, "*** CLIENT MUST NOW ENTER PIN = \"%s\" AS AIRPLAY PASSWORD", raop->random_pw);
+                raop->auth_fail_count++;
             }
 	    if (len && !conn->authenticated) {
  	        if (len == -1) {
-                    password = (const char *) conn->raop->random_pw;
+                    password = (const char *) raop->random_pw;
                 }
                 char nonce_string[33] = { '\0' };
                 //bool stale = false;  //not implemented
@@ -693,27 +699,27 @@ raop_handler_setup(raop_conn_t *conn,
 		    if (!conn->authenticated) {
                         // if random_pw is used, the auth_fail_count will be the number of times it is displayed after creation
                         if (len != -1) {
-                            conn->raop->auth_fail_count++;
+                            raop->auth_fail_count++;
                         }
-                        logger_log(conn->raop->logger, LOGGER_INFO, "*** authentication failure: count = %u", conn->raop->auth_fail_count);
+                        logger_log(raop->logger, LOGGER_INFO, "*** authentication failure: count = %u", raop->auth_fail_count);
                     }
                     if (conn->authenticated) {
                         //printf("initial authenticatication OK\n");
-                        conn->authenticated = conn->authenticated && !strcmp(nonce_string, conn->raop->nonce);
+                        conn->authenticated = conn->authenticated && !strcmp(nonce_string, raop->nonce);
                         if (!conn->authenticated) {
-                            logger_log(conn->raop->logger, LOGGER_INFO, "authentication rejected (nonce mismatch) %s %s",
-                                       nonce_string, conn->raop->nonce);
+                            logger_log(raop->logger, LOGGER_INFO, "authentication rejected (nonce mismatch) %s %s",
+                                       nonce_string, raop->nonce);
                         }			
                     }
-                    if (conn->authenticated && conn->raop->random_pw) {
-                        free (conn->raop->random_pw);
-                        conn->raop->random_pw = NULL;
+                    if (conn->authenticated && raop->random_pw) {
+                        free (raop->random_pw);
+                        raop->random_pw = NULL;
                     }
-                    if (conn->raop->nonce) {
-                        free(conn->raop->nonce);
-                        conn->raop->nonce = NULL;
+                    if (raop->nonce) {
+                        free(raop->nonce);
+                        raop->nonce = NULL;
                     }
-                    logger_log(conn->raop->logger, LOGGER_INFO, "Client authentication %s", (conn->authenticated ? "success" : "failure"));
+                    logger_log(raop->logger, LOGGER_INFO, "Client authentication %s", (conn->authenticated ? "success" : "failure"));
                 }
                 if (!conn->authenticated) {
                     /* create a nonce */
@@ -722,12 +728,12 @@ raop_handler_setup(raop_conn_t *conn,
                     int len = 16;
                     uint64_t now = raop_ntp_get_local_time();
                     assert (!pairing_session_make_nonce(conn->session, &now, url, nonce, len));
-                    if (conn->raop->nonce) {
-                        free(conn->raop->nonce);
+                    if (raop->nonce) {
+                        free(raop->nonce);
                     }
-                    conn->raop->nonce = utils_hex_to_string(nonce, len);
+                    raop->nonce = utils_hex_to_string(nonce, len);
                     char response_text[80] = "Digest realm=\"raop\", nonce=\"";
-                    strncat(response_text, conn->raop->nonce, 80 - strlen(response_text) - 1);
+                    strncat(response_text, raop->nonce, 80 - strlen(response_text) - 1);
                     strncat(response_text, "\"", 80 - strlen(response_text) - 1);
                     http_response_init(response, "RTSP/1.0", 401, "Unauthorized");
                     http_response_add_header(response, "WWW-Authenticate", response_text);
@@ -745,15 +751,15 @@ raop_handler_setup(raop_conn_t *conn,
         plist_get_string_val(req_model_node, &model);  
         plist_t req_name_node = plist_dict_get_item(req_root_node, "name");
         plist_get_string_val(req_name_node, &name);  
-        if (conn->raop->callbacks.report_client_request) {
-            conn->raop->callbacks.report_client_request(conn->raop->callbacks.cls, deviceID, model, name, &admit_client);
+        if (raop->callbacks.report_client_request) {
+            raop->callbacks.report_client_request(raop->callbacks.cls, deviceID, model, name, &admit_client);
         }
-        if (admit_client && deviceID && name && conn->raop->callbacks.register_client) {
+        if (admit_client && deviceID && name && raop->callbacks.register_client) {
             char *client_device_id = NULL;
             char *client_pk = NULL;   /* encoded as null-terminated  base64 string, must be freed*/
             get_pairing_session_client_data(conn->session, &client_device_id, &client_pk);
             if (client_pk && !strcmp(deviceID, client_device_id)) { 
-                conn->raop->callbacks.register_client(conn->raop->callbacks.cls, client_device_id, client_pk, name); 
+                raop->callbacks.register_client(raop->callbacks.cls, client_device_id, client_pk, name); 
                 free (client_pk);
             }
         }
@@ -773,10 +779,10 @@ raop_handler_setup(raop_conn_t *conn,
         plist_get_data_val(req_eiv_node, &eiv, &eiv_len);
         memcpy(aesiv, eiv, 16);
         free(eiv);	
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "eiv_len = %llu", eiv_len);
+        logger_log(raop->logger, LOGGER_DEBUG, "eiv_len = %llu", eiv_len);
         if (logger_debug) {
             char* str = utils_data_to_string(aesiv, 16, 16);
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "16 byte aesiv (needed for AES-CBC audio decryption iv):\n%s", str);
+            logger_log(raop->logger, LOGGER_DEBUG, "16 byte aesiv (needed for AES-CBC audio decryption iv):\n%s", str);
             free(str);
         }
 
@@ -785,23 +791,23 @@ raop_handler_setup(raop_conn_t *conn,
         plist_get_data_val(req_ekey_node, &ekey, &ekey_len);
         memcpy(eaeskey,ekey,72);
         free(ekey);
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "ekey_len = %llu", ekey_len);
+        logger_log(raop->logger, LOGGER_DEBUG, "ekey_len = %llu", ekey_len);
         // eaeskey is 72 bytes, aeskey is 16 bytes
         if (logger_debug) {
             char *str = utils_data_to_string((unsigned char *) eaeskey, ekey_len, 16);
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "ekey:\n%s", str);
+            logger_log(raop->logger, LOGGER_DEBUG, "ekey:\n%s", str);
             free (str);
         }
         int ret = fairplay_decrypt(conn->fairplay, (unsigned char*) eaeskey, aeskey);
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "fairplay_decrypt ret = %d", ret);
+        logger_log(raop->logger, LOGGER_DEBUG, "fairplay_decrypt ret = %d", ret);
         if (logger_debug) {
             char *str = utils_data_to_string(aeskey, 16, 16);
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "16 byte aeskey (fairplay-decrypted from ekey):\n%s", str);
+            logger_log(raop->logger, LOGGER_DEBUG, "16 byte aeskey (fairplay-decrypted from ekey):\n%s", str);
             free(str);
         }
 
         const char *user_agent = http_request_get_header(request, "User-Agent");
-        logger_log(conn->raop->logger, LOGGER_INFO, "Client identified as User-Agent: %s", user_agent);	
+        logger_log(raop->logger, LOGGER_INFO, "Client identified as User-Agent: %s", user_agent);	
 
         bool old_protocol = false;
 #ifdef OLD_PROTOCOL_CLIENT_USER_AGENT_LIST    /* set in global.h */
@@ -809,7 +815,7 @@ raop_handler_setup(raop_conn_t *conn,
         if (strstr(user_agent, "AirMyPC")) old_protocol = true;   //AirMyPC/7200 still uses old protocol: unlikely to change (?)
 #endif
         if  (old_protocol) {    /* some windows AirPlay-client emulators use old AirPlay 1 protocol with unhashed AES key */
-            logger_log(conn->raop->logger, LOGGER_INFO, "Client identifed as using old protocol (unhashed) AES audio key)");
+            logger_log(raop->logger, LOGGER_INFO, "Client identifed as using old protocol (unhashed) AES audio key)");
         } else {
             unsigned char ecdh_secret[X25519_KEY_SIZE];
             if (pairing_get_ecdh_secret_key(conn->session, ecdh_secret)) {
@@ -829,7 +835,7 @@ raop_handler_setup(raop_conn_t *conn,
 
                 if (logger_debug) {
                     char *str = utils_data_to_string(ecdh_secret, X25519_KEY_SIZE, 16);
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "32 byte shared ecdh_secret:\n%s", str);
+                    logger_log(raop->logger, LOGGER_DEBUG, "32 byte shared ecdh_secret:\n%s", str);
                     free(str);
                 }
                 memcpy(eaeskey, aeskey, 16);
@@ -841,7 +847,7 @@ raop_handler_setup(raop_conn_t *conn,
                 memcpy(aeskey, eaeskey, 16);
                 if (logger_debug) {
                     char *str = utils_data_to_string(aeskey, 16, 16);
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "16 byte aeskey after sha-256 hash with ecdh_secret:\n%s", str);
+                    logger_log(raop->logger, LOGGER_DEBUG, "16 byte aeskey after sha-256 hash with ecdh_secret:\n%s", str);
                     free(str);
                 }
             }
@@ -853,7 +859,7 @@ raop_handler_setup(raop_conn_t *conn,
 	    uint8_t bool_val = 0;
 	    plist_get_bool_val(req_is_remote_control_only_node, &bool_val);  
             if (bool_val) {
-                logger_log(conn->raop->logger, LOGGER_ERR, "Client specified AirPlay2 \"Remote Control\" protocol\n"
+                logger_log(raop->logger, LOGGER_ERR, "Client specified AirPlay2 \"Remote Control\" protocol\n"
 			   " Only AirPlay v1 protocol (using NTP and timing port) is supported");
             }
         }
@@ -871,13 +877,13 @@ raop_handler_setup(raop_conn_t *conn,
                  time_protocol = TP_OTHER;
              }
              if (time_protocol != NTP) {
-                 logger_log(conn->raop->logger, LOGGER_ERR, "Client specified timingProtocol=%s,"
+                 logger_log(raop->logger, LOGGER_ERR, "Client specified timingProtocol=%s,"
                             " but timingProtocol= NTP is required here", timing_protocol);
              }
              plist_mem_free (timing_protocol);
              timing_protocol = NULL;
         } else {
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "Client did not specify timingProtocol,"
+            logger_log(raop->logger, LOGGER_DEBUG, "Client did not specify timingProtocol,"
                        " old protocol without offset will be used");
             time_protocol = TP_UNSPECIFIED;
         }
@@ -887,12 +893,12 @@ raop_handler_setup(raop_conn_t *conn,
              plist_get_uint_val(req_timing_port_node, &timing_rport);
         }
         if (timing_rport) {
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "timing_rport = %llu", timing_rport);
+            logger_log(raop->logger, LOGGER_DEBUG, "timing_rport = %llu", timing_rport);
         } else {
-            logger_log(conn->raop->logger, LOGGER_ERR, "Client did not supply timing_rport,"
+            logger_log(raop->logger, LOGGER_ERR, "Client did not supply timing_rport,"
                        " may be using unsupported AirPlay2 \"Remote Control\" protocol");
         }
-        unsigned short timing_lport = conn->raop->timing_lport;
+        unsigned short timing_lport = raop->timing_lport;
 
         conn->raop_ntp = NULL;
         conn->raop_rtp = NULL;
@@ -901,18 +907,18 @@ raop_handler_setup(raop_conn_t *conn,
         int len = utils_ipaddress_to_string(conn->remotelen, conn->remote, conn->zone_id, remote, (int) sizeof(remote));
         if (!len || len > sizeof(remote)) {
             char *str = utils_data_to_string(conn->remote, conn->remotelen, 16);
-            logger_log(conn->raop->logger, LOGGER_ERR, "failed to extract valid client ip address:\n"
+            logger_log(raop->logger, LOGGER_ERR, "failed to extract valid client ip address:\n"
                        "*** UxPlay will be unable to send communications to client.\n"
                        "*** address length %d, zone_id %u address data:\n%sparser returned \"%s\"\n",
                        conn->remotelen, conn->zone_id, str, remote);
             free(str);
         }
-        conn->raop_ntp = raop_ntp_init(conn->raop->logger, &conn->raop->callbacks, remote,
+        conn->raop_ntp = raop_ntp_init(raop->logger, &raop->callbacks, remote,
                                        conn->remotelen, (unsigned short) timing_rport, &time_protocol);
         raop_ntp_start(conn->raop_ntp, &timing_lport);
-        conn->raop_rtp = raop_rtp_init(conn->raop->logger, &conn->raop->callbacks, conn->raop_ntp,
+        conn->raop_rtp = raop_rtp_init(raop->logger, &raop->callbacks, conn->raop_ntp,
                                        remote, conn->remotelen, aeskey, aesiv);
-        conn->raop_rtp_mirror = raop_rtp_mirror_init(conn->raop->logger, &conn->raop->callbacks,
+        conn->raop_rtp_mirror = raop_rtp_mirror_init(raop->logger, &raop->callbacks,
                                                      conn->raop_ntp, remote, conn->remotelen, aeskey);
 
         /* the event port is not used in mirror mode or audio mode */
@@ -922,7 +928,7 @@ raop_handler_setup(raop_conn_t *conn,
         plist_dict_set_item(res_root_node, "timingPort", res_timing_port_node);
         plist_dict_set_item(res_root_node, "eventPort", res_event_port_node);
 
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "eport = %d, tport = %d", event_port, timing_lport);
+        logger_log(raop->logger, LOGGER_DEBUG, "eport = %d, tport = %d", event_port, timing_lport);
     }
 
     // Process stream setup requests
@@ -936,24 +942,24 @@ raop_handler_setup(raop_conn_t *conn,
             plist_t req_stream_type_node = plist_dict_get_item(req_stream_node, "type");
             uint64_t type;
             plist_get_uint_val(req_stream_type_node, &type);
-            logger_log(conn->raop->logger, LOGGER_DEBUG, "type = %llu", type);
+            logger_log(raop->logger, LOGGER_DEBUG, "type = %llu", type);
 
             switch (type) {
             case 110: {
                 // Mirroring
-                unsigned short dport = conn->raop->mirror_data_lport;
+                unsigned short dport = raop->mirror_data_lport;
                 plist_t stream_id_node = plist_dict_get_item(req_stream_node, "streamConnectionID");
                 uint64_t stream_connection_id = 0;
                 plist_get_uint_val(stream_id_node, &stream_connection_id);
-                logger_log(conn->raop->logger, LOGGER_DEBUG, "streamConnectionID (needed for AES-CTR video decryption"
+                logger_log(raop->logger, LOGGER_DEBUG, "streamConnectionID (needed for AES-CTR video decryption"
                            " key and iv): %llu", stream_connection_id);
 
                 if (conn->raop_rtp_mirror) {
                     raop_rtp_mirror_init_aes(conn->raop_rtp_mirror, &stream_connection_id);
-                    raop_rtp_mirror_start(conn->raop_rtp_mirror, &dport, conn->raop->clientFPSdata);
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "Mirroring initialized successfully");
+                    raop_rtp_mirror_start(conn->raop_rtp_mirror, &dport, raop->clientFPSdata);
+                    logger_log(raop->logger, LOGGER_DEBUG, "Mirroring initialized successfully");
                 } else {
-                    logger_log(conn->raop->logger, LOGGER_ERR, "Mirroring not initialized at SETUP, playing will fail!");
+                    logger_log(raop->logger, LOGGER_ERR, "Mirroring not initialized at SETUP, playing will fail!");
                     http_response_set_disconnect(response, 1);
                 }
 
@@ -968,7 +974,7 @@ raop_handler_setup(raop_conn_t *conn,
                 }
             case 96: {
                 // Audio
-                unsigned short cport = conn->raop->control_lport, dport = conn->raop->data_lport; 
+                unsigned short cport = raop->control_lport, dport = raop->data_lport; 
                 unsigned short remote_cport = 0;
                 unsigned char ct = 0;
                 unsigned int sr = AUDIO_SAMPLE_RATE; /* all AirPlay audio formats supported so far have sample rate 44.1kHz */
@@ -982,7 +988,7 @@ raop_handler_setup(raop_conn_t *conn,
                 plist_get_uint_val(req_stream_ct_node, &uint_val);
                 ct = (unsigned char) uint_val;
 
-                if (conn->raop->callbacks.audio_get_format) {
+                if (raop->callbacks.audio_get_format) {
                     /* get additional audio format parameters  */
                     uint64_t audioFormat = 0;
                     unsigned short spf = 0;
@@ -1013,14 +1019,14 @@ raop_handler_setup(raop_conn_t *conn,
                         usingScreen = false;
                     }
 
-                    conn->raop->callbacks.audio_get_format(conn->raop->callbacks.cls, &ct, &spf, &usingScreen, &isMedia, &audioFormat);
+                    raop->callbacks.audio_get_format(raop->callbacks.cls, &ct, &spf, &usingScreen, &isMedia, &audioFormat);
                 }
 
                 if (conn->raop_rtp) {
                     raop_rtp_start_audio(conn->raop_rtp, &remote_cport, &cport, &dport, &ct, &sr);
-                    logger_log(conn->raop->logger, LOGGER_DEBUG, "RAOP initialized success");
+                    logger_log(raop->logger, LOGGER_DEBUG, "RAOP initialized success");
                 } else {
-                    logger_log(conn->raop->logger, LOGGER_ERR, "RAOP not initialized at SETUP, playing will fail!");
+                    logger_log(raop->logger, LOGGER_ERR, "RAOP not initialized at SETUP, playing will fail!");
                     http_response_set_disconnect(response, 1);
                 }
 
@@ -1037,7 +1043,7 @@ raop_handler_setup(raop_conn_t *conn,
                 }
 
             default:
-                logger_log(conn->raop->logger, LOGGER_ERR, "SETUP tries to setup stream of unknown type %llu", type);
+                logger_log(raop->logger, LOGGER_ERR, "SETUP tries to setup stream of unknown type %llu", type);
                 http_response_set_disconnect(response, 1);
                 break;
             }
@@ -1057,6 +1063,7 @@ raop_handler_get_parameter(raop_conn_t *conn,
                            http_request_t *request, http_response_t *response,
                            char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;  
     const char *content_type = NULL;
     const char *data = NULL;
     int datalen = 0;
@@ -1077,8 +1084,8 @@ raop_handler_get_parameter(raop_conn_t *conn,
             /* This is a bit ugly, but seems to be how airport works too */
             if ((datalen - (current - data) >= 8) && !strncmp(current, "volume\r\n", 8)) {
                 char volume[25] = "volume: 0.0\r\n";
-                if (conn->raop->callbacks.audio_set_client_volume) {
-                    snprintf(volume, 25, "volume: %9.6f\r\n", conn->raop->callbacks.audio_set_client_volume(conn->raop->callbacks.cls));
+                if (raop->callbacks.audio_set_client_volume) {
+                    snprintf(volume, 25, "volume: %9.6f\r\n", raop->callbacks.audio_set_client_volume(raop->callbacks.cls));
                 }
                 http_response_add_header(response, "Content-Type", "text/parameters");
                 *response_data = strdup(volume);
@@ -1096,7 +1103,7 @@ raop_handler_get_parameter(raop_conn_t *conn,
 
             if ((datalen - (next - data) >= 2) && !strncmp(next, "\r\n", 2)) {
                 if ((next - current) > 0) {
-                    logger_log(conn->raop->logger, LOGGER_WARNING,
+                    logger_log(raop->logger, LOGGER_WARNING,
                                "Found an unknown parameter: %.*s", (next - current), current);
                 }
                 current = next + 2;
@@ -1112,6 +1119,7 @@ raop_handler_set_parameter(raop_conn_t *conn,
                            http_request_t *request, http_response_t *response,
                            char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;
     const char *content_type = NULL;
     const char *data = NULL;
     int datalen = 0;
@@ -1137,22 +1145,22 @@ raop_handler_set_parameter(raop_conn_t *conn,
                 raop_rtp_set_progress(conn->raop_rtp, start, curr, end);
             }
         } else if (!conn->raop_rtp) {
-            logger_log(conn->raop->logger, LOGGER_WARNING, "RAOP not initialized at SET_PARAMETER");
+            logger_log(raop->logger, LOGGER_WARNING, "RAOP not initialized at SET_PARAMETER");
         }
         free(datastr);
     } else if (!strcmp(content_type, "image/jpeg") || !strcmp(content_type, "image/png")) {
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "Got image data of %d bytes", datalen);
+        logger_log(raop->logger, LOGGER_DEBUG, "Got image data of %d bytes", datalen);
         if (conn->raop_rtp) {
             raop_rtp_set_coverart(conn->raop_rtp, data, datalen);
         } else {
-            logger_log(conn->raop->logger, LOGGER_WARNING, "RAOP not initialized at SET_PARAMETER coverart");
+            logger_log(raop->logger, LOGGER_WARNING, "RAOP not initialized at SET_PARAMETER coverart");
         }
     } else if (!strcmp(content_type, "application/x-dmap-tagged")) {
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "Got metadata of %d bytes", datalen);
+        logger_log(raop->logger, LOGGER_DEBUG, "Got metadata of %d bytes", datalen);
         if (conn->raop_rtp) {
             raop_rtp_set_metadata(conn->raop_rtp, data, datalen);
         } else {
-            logger_log(conn->raop->logger, LOGGER_WARNING, "RAOP not initialized at SET_PARAMETER metadata");
+            logger_log(raop->logger, LOGGER_WARNING, "RAOP not initialized at SET_PARAMETER metadata");
         }
     }
 }
@@ -1162,6 +1170,7 @@ raop_handler_audiomode(raop_conn_t *conn,
                       http_request_t *request, http_response_t *response,
                       char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;
     const char *data = NULL;
     char *audiomode = NULL;
     int data_len = 0;
@@ -1172,7 +1181,7 @@ raop_handler_audiomode(raop_conn_t *conn,
     plist_get_string_val(req_audiomode_node, &audiomode);
     /* not sure what should be done with this request: usually audioMode requested is "default" */
     int log_level = (strstr(audiomode, "default") ? LOGGER_DEBUG : LOGGER_INFO);
-    logger_log(conn->raop->logger, log_level, "Unhandled RTSP request \"audioMode: %s\"", audiomode);
+    logger_log(raop->logger, log_level, "Unhandled RTSP request \"audioMode: %s\"", audiomode);
     plist_mem_free(audiomode);
     plist_free(req_root_node);
 }
@@ -1182,9 +1191,10 @@ raop_handler_feedback(raop_conn_t *conn,
                       http_request_t *request, http_response_t *response,
                       char **response_data, int *response_datalen)
 {
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "raop_handler_feedback");
+    raop_t *raop = conn->raop;
+    logger_log(raop->logger, LOGGER_DEBUG, "raop_handler_feedback");
     /* register receipt of client's "heartbeat" signal  */
-    conn->raop->callbacks.conn_feedback(conn->raop->callbacks.cls);
+    raop->callbacks.conn_feedback(raop->callbacks.cls);
 }
 
 static void
@@ -1192,10 +1202,11 @@ raop_handler_record(raop_conn_t *conn,
                     http_request_t *request, http_response_t *response,
                     char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;
     char audio_latency[12] = { '\0' };
-    unsigned int ad = (unsigned int) (((uint64_t) conn->raop->audio_delay_micros) * AUDIO_SAMPLE_RATE / SECOND_IN_USECS);
+    unsigned int ad = (unsigned int) (((uint64_t) raop->audio_delay_micros) * AUDIO_SAMPLE_RATE / SECOND_IN_USECS);
     snprintf(audio_latency, sizeof(audio_latency), "%u", ad);
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "raop_handler_record");
+    logger_log(raop->logger, LOGGER_DEBUG, "raop_handler_record");
     http_response_add_header(response, "Audio-Latency", audio_latency);
     http_response_add_header(response, "Audio-Jack-Status", "connected; type=analog");
 }
@@ -1205,12 +1216,13 @@ raop_handler_flush(raop_conn_t *conn,
                       http_request_t *request, http_response_t *response,
                       char **response_data, int *response_datalen)
 {
+    raop_t *raop = conn->raop;
     const char *rtpinfo = NULL;
     int next_seq = -1;
 
     rtpinfo = http_request_get_header(request, "RTP-Info");
     if (rtpinfo) {
-        logger_log(conn->raop->logger, LOGGER_DEBUG, "Flush with RTP-Info: %s", rtpinfo);
+        logger_log(raop->logger, LOGGER_DEBUG, "Flush with RTP-Info: %s", rtpinfo);
         if (!strncmp(rtpinfo, "seq=", 4)) {
             next_seq = strtol(rtpinfo + 4, NULL, 10);
         }
@@ -1218,7 +1230,7 @@ raop_handler_flush(raop_conn_t *conn,
     if (conn->raop_rtp) {
         raop_rtp_flush(conn->raop_rtp, next_seq);
     } else {
-        logger_log(conn->raop->logger, LOGGER_WARNING, "RAOP not initialized at FLUSH");
+        logger_log(raop->logger, LOGGER_WARNING, "RAOP not initialized at FLUSH");
     }
 }
 
@@ -1228,6 +1240,7 @@ raop_handler_teardown(raop_conn_t *conn,
                       char **response_data, int *response_datalen)
 {
     /* get the teardown request type(s):  (type 96, 110, or none) */
+    raop_t *raop = conn->raop;
     const char *data = NULL;
     int data_len = 0;
     bool teardown_96 = false, teardown_110 = false;
@@ -1251,7 +1264,7 @@ raop_handler_teardown(raop_conn_t *conn,
         }
     }
     plist_free(req_root_node);
-    logger_log(conn->raop->logger, LOGGER_DEBUG, "TEARDOWN request,  96=%d, 110=%d", teardown_96, teardown_110);
+    logger_log(raop->logger, LOGGER_DEBUG, "TEARDOWN request,  96=%d, 110=%d", teardown_96, teardown_110);
   
     http_response_add_header(response, "Connection", "close");
   
@@ -1260,12 +1273,12 @@ raop_handler_teardown(raop_conn_t *conn,
             /* Stop our audio RTP session */
             raop_rtp_stop(conn->raop_rtp);
             /* stop any  coverart rendering */
-            if (conn->raop->callbacks.audio_stop_coverart_rendering) {
-                conn->raop->callbacks.audio_stop_coverart_rendering(conn->raop->callbacks.cls);
+            if (raop->callbacks.audio_stop_coverart_rendering) {
+                raop->callbacks.audio_stop_coverart_rendering(raop->callbacks.cls);
             }
         }
     } else if (teardown_110) {
-      conn->raop->callbacks.video_reset(conn->raop->callbacks.cls, false, false);
+      raop->callbacks.video_reset(raop->callbacks.cls, false, false);
         if (conn->raop_rtp_mirror) {
         /* Stop our video RTP session */
             raop_rtp_mirror_stop(conn->raop_rtp_mirror);
@@ -1281,12 +1294,12 @@ raop_handler_teardown(raop_conn_t *conn,
             conn->raop_rtp_mirror = NULL;
         }
         /* shut down any HLS connections */
-        int hls_count = httpd_count_connection_type(conn->raop->httpd, CONNECTION_TYPE_HLS);
+        int hls_count = httpd_count_connection_type(raop->httpd, CONNECTION_TYPE_HLS);
         if (hls_count) {
-	  conn->raop->callbacks.video_reset(conn->raop->callbacks.cls, true, false);
+	  raop->callbacks.video_reset(raop->callbacks.cls, true, false);
         }
     }
-    if (conn->raop->callbacks.conn_teardown) {
-        conn->raop->callbacks.conn_teardown(conn->raop->callbacks.cls, &teardown_96, &teardown_110);
+    if (raop->callbacks.conn_teardown) {
+        raop->callbacks.conn_teardown(raop->callbacks.cls, &teardown_96, &teardown_110);
     }
 }