[Spice-devel] [PATCH server 0.8 1/3] server: introduce red_log and red_warn

Alon Levy alevy at redhat.com
Sun Oct 9 07:29:46 PDT 2011


change all red_printf variants to call red_log, including red_warn.
Introduce a static (per compile unit) spice_log_level, settable on
first access (via get_spice_log_level) from the environment variable
SPICE_LOG_LEVEL (we already have SPICEC_LOG_LEVEL and spice-gtk has
SPICE_DEBUG, though much more verbose and useful, but relying on glib).

This might seem like a waste of time if we move to glib, but we haven't
yet and I want the ability to add prints that are not on by default into
the code base (as opposed to locally for each developer).
---
 server/agent-msg-filter.c       |    8 +-
 server/red_channel.c            |   12 +-
 server/red_common.h             |   45 ++++-
 server/red_dispatcher.c         |   19 +-
 server/red_tunnel_worker.c      |  142 ++++++++--------
 server/red_worker.c             |  160 +++++++++---------
 server/reds.c                   |  372 +++++++++++++++++++-------------------
 server/smartcard.c              |   14 +-
 server/snd_worker.c             |   42 +++---
 server/tests/basic_event_loop.c |    1 +
 server/zlib_encoder.c           |    2 +-
 11 files changed, 426 insertions(+), 391 deletions(-)

diff --git a/server/agent-msg-filter.c b/server/agent-msg-filter.c
index cd1f78c..afa0f76 100644
--- a/server/agent-msg-filter.c
+++ b/server/agent-msg-filter.c
@@ -36,7 +36,7 @@ int agent_msg_filter_process_data(struct AgentMsgFilter *filter,
     struct VDAgentMessage msg_header;
 
     if (len > VD_AGENT_MAX_DATA_SIZE) {
-        red_printf("invalid agent message: too large");
+        red_warn("invalid agent message: too large");
         return AGENT_MSG_FILTER_PROTO_ERROR;
     }
 
@@ -44,7 +44,7 @@ int agent_msg_filter_process_data(struct AgentMsgFilter *filter,
     if (filter->msg_data_to_read) {
 data_to_read:
         if (len > filter->msg_data_to_read) {
-            red_printf("invalid agent message: data exceeds size from header");
+            red_warn("invalid agent message: data exceeds size from header");
             return AGENT_MSG_FILTER_PROTO_ERROR;
         }
         filter->msg_data_to_read -= len;
@@ -52,14 +52,14 @@ data_to_read:
     }
 
     if (len < sizeof(msg_header)) {
-        red_printf("invalid agent message: incomplete header");
+        red_warn("invalid agent message: incomplete header");
         return AGENT_MSG_FILTER_PROTO_ERROR;
     }
     memcpy(&msg_header, data, sizeof(msg_header));
     len -= sizeof(msg_header);
 
     if (msg_header.protocol != VD_AGENT_PROTOCOL) {
-        red_printf("invalid agent protocol: %u", msg_header.protocol);
+        red_warn("invalid agent protocol: %u", msg_header.protocol);
         return AGENT_MSG_FILTER_PROTO_ERROR;
     }
 
diff --git a/server/red_channel.c b/server/red_channel.c
index da0fb9f..b7c0db5 100644
--- a/server/red_channel.c
+++ b/server/red_channel.c
@@ -55,7 +55,7 @@ static int red_peer_receive(RedsStream *stream, uint8_t *buf, uint32_t size)
             } else if (errno == EPIPE) {
                 return -1;
             } else {
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 return -1;
             }
         } else {
@@ -91,7 +91,7 @@ static void red_peer_handle_incoming(RedsStream *stream, IncomingHandler *handle
             if (!handler->msg) {
                 handler->msg = handler->alloc_msg_buf(handler->opaque, &handler->header);
                 if (handler->msg == NULL) {
-                    red_printf("ERROR: channel refused to allocate buffer.");
+                    red_warn("ERROR: channel refused to allocate buffer.");
                     handler->on_error(handler->opaque);
                     return;
                 }
@@ -165,7 +165,7 @@ static void red_peer_handle_outgoing(RedsStream *stream, OutgoingHandler *handle
                 handler->on_error(handler->opaque);
                 return;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 handler->on_error(handler->opaque);
                 return;
             }
@@ -314,7 +314,7 @@ void red_channel_destroy(RedChannel *channel)
 
 void red_channel_shutdown(RedChannel *channel)
 {
-    red_printf("");
+    red_log(2, "");
     if (channel->stream && !channel->stream->shutdown) {
         channel->core->watch_update_mask(channel->stream->watch,
                                          SPICE_WATCH_EVENT_READ);
@@ -335,7 +335,7 @@ int red_channel_handle_message(RedChannel *channel, SpiceDataHeader *header, uin
     switch (header->type) {
     case SPICE_MSGC_ACK_SYNC:
         if (header->size != sizeof(uint32_t)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             return FALSE;
         }
         channel->ack_data.client_generation = *(uint32_t *)(msg);
@@ -347,7 +347,7 @@ int red_channel_handle_message(RedChannel *channel, SpiceDataHeader *header, uin
         }
         break;
     default:
-        red_printf("invalid message type %u", header->type);
+        red_warn("invalid message type %u", header->type);
         return FALSE;
     }
     return TRUE;
diff --git a/server/red_common.h b/server/red_common.h
index c863922..c060495 100644
--- a/server/red_common.h
+++ b/server/red_common.h
@@ -26,6 +26,31 @@
 #include <messages.h>
 #include <spice/macros.h>
 
+#define LOG_INVALID -1
+#define LOG_NONE 0
+#define LOG_WARN 1
+/* anything higher is not defined */
+
+#define SPICE_DEFAULT_LOG_LEVEL LOG_WARN
+
+static int spice_log_level = LOG_INVALID;
+
+static inline int get_spice_log_level(void) {
+    char *log_level;
+
+    if (spice_log_level != LOG_INVALID) {
+        return spice_log_level;
+    }
+    log_level = getenv("SPICE_LOG_LEVEL");
+
+    if (log_level == NULL) {
+        spice_log_level = SPICE_DEFAULT_LOG_LEVEL;
+    } else {
+        spice_log_level = atoi(log_level);
+    }
+    return spice_log_level;
+}
+
 #define ASSERT(x) if (!(x)) {                               \
     printf("%s: ASSERT %s failed\n", __FUNCTION__, #x);     \
     abort();                                                \
@@ -46,23 +71,29 @@
     abort();                                                     \
 }
 
-#define red_printf(format, ...) \
-    printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ )
+#define red_warn(format, ...) red_log(LOG_WARN, format, ## __VA_ARGS__)
 
-#define red_printf_once(format, ...) {                              \
+#define red_log(level, format, ...)                                     \
+    do {                                                                \
+        if (level <= get_spice_log_level()) {                           \
+            printf("spice(%d) %s: " format "\n", level, __FUNCTION__, ## __VA_ARGS__ );  \
+        }                                                               \
+    } while (0)
+
+#define red_log_once(level, format, ...) {                       \
     static int do_print = TRUE;                                     \
     if (do_print) {                                                 \
         do_print = FALSE;                                           \
-        printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ );  \
+        red_log(level, "%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ );  \
     }                                                               \
 }
 
-#define red_printf_some(every, format, ...) {                       \
+#define red_log_some(level, every, format, ...) do {                \
     static int count = 0;                                           \
     if (count++ % (every) == 0) {                                   \
-        printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ );  \
+        red_log(level, "%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ );  \
     }                                                               \
-}
+} while (0)
 
 enum {
     STREAM_VIDEO_INVALID,
diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
index f74b13e..f846a8c 100644
--- a/server/red_dispatcher.c
+++ b/server/red_dispatcher.c
@@ -79,7 +79,7 @@ static void red_dispatcher_set_peer(Channel *channel, RedsStream *stream, int mi
 {
     RedDispatcher *dispatcher;
 
-    red_printf("");
+    red_log(2, "");
     dispatcher = (RedDispatcher *)channel->data;
     RedWorkerMessage message = RED_WORKER_MESSAGE_DISPLAY_CONNECT;
     write_message(dispatcher->channel, &message);
@@ -90,7 +90,7 @@ static void red_dispatcher_set_peer(Channel *channel, RedsStream *stream, int mi
 static void red_dispatcher_shutdown_peer(Channel *channel)
 {
     RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
-    red_printf("");
+    red_log(2, "");
     RedWorkerMessage message = RED_WORKER_MESSAGE_DISPLAY_DISCONNECT;
     write_message(dispatcher->channel, &message);
 }
@@ -98,7 +98,7 @@ static void red_dispatcher_shutdown_peer(Channel *channel)
 static void red_dispatcher_migrate(Channel *channel)
 {
     RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
-    red_printf("channel type %u id %u", channel->type, channel->id);
+    red_log(2, "channel type %u id %u", channel->type, channel->id);
     RedWorkerMessage message = RED_WORKER_MESSAGE_DISPLAY_MIGRATE;
     write_message(dispatcher->channel, &message);
 }
@@ -109,7 +109,7 @@ static void red_dispatcher_set_cursor_peer(Channel *channel, RedsStream *stream,
                                            uint32_t *caps)
 {
     RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
-    red_printf("");
+    red_log(2, "");
     RedWorkerMessage message = RED_WORKER_MESSAGE_CURSOR_CONNECT;
     write_message(dispatcher->channel, &message);
     send_data(dispatcher->channel, &stream, sizeof(RedsStream *));
@@ -119,7 +119,7 @@ static void red_dispatcher_set_cursor_peer(Channel *channel, RedsStream *stream,
 static void red_dispatcher_shutdown_cursor_peer(Channel *channel)
 {
     RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
-    red_printf("");
+    red_log(2, "");
     RedWorkerMessage message = RED_WORKER_MESSAGE_CURSOR_DISCONNECT;
     write_message(dispatcher->channel, &message);
 }
@@ -127,7 +127,7 @@ static void red_dispatcher_shutdown_cursor_peer(Channel *channel)
 static void red_dispatcher_cursor_migrate(Channel *channel)
 {
     RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
-    red_printf("channel type %u id %u", channel->type, channel->id);
+    red_log(2, "channel type %u id %u", channel->type, channel->id);
     RedWorkerMessage message = RED_WORKER_MESSAGE_CURSOR_MIGRATE;
     write_message(dispatcher->channel, &message);
 }
@@ -229,7 +229,8 @@ static RedWorkerMessage red_dispatcher_async_start(RedDispatcher *dispatcher,
 {
     pthread_mutex_lock(&dispatcher->async_lock);
     if (dispatcher->async_message != RED_WORKER_MESSAGE_NOP) {
-        red_printf("error: async clash. second async ignored");
+        red_warn("warning: async clash. have %d, ignoring %d",
+                   dispatcher->async_message, message);
         pthread_mutex_unlock(&dispatcher->async_lock);
         return RED_WORKER_MESSAGE_NOP;
     }
@@ -570,7 +571,7 @@ static void red_dispatcher_loadvm_commands(RedDispatcher *dispatcher,
 {
     RedWorkerMessage message = RED_WORKER_MESSAGE_LOADVM_COMMANDS;
 
-    red_printf("");
+    red_log(2, "");
     write_message(dispatcher->channel, &message);
     send_data(dispatcher->channel, &count, sizeof(uint32_t));
     send_data(dispatcher->channel, ext, sizeof(QXLCommandExt) * count);
@@ -824,7 +825,7 @@ void red_dispatcher_async_complete(struct RedDispatcher *dispatcher, uint64_t co
     case RED_WORKER_MESSAGE_FLUSH_SURFACES_ASYNC:
         break;
     default:
-        red_printf("unexpected message");
+        red_warn("unexpected message");
     }
     dispatcher->async_message = RED_WORKER_MESSAGE_NOP;
     pthread_mutex_unlock(&dispatcher->async_lock);
diff --git a/server/red_tunnel_worker.c b/server/red_tunnel_worker.c
index 46cccb5..b90f253 100644
--- a/server/red_tunnel_worker.c
+++ b/server/red_tunnel_worker.c
@@ -41,7 +41,7 @@
 //#define DEBUG_NETWORK
 
 #ifdef DEBUG_NETWORK
-#define PRINT_SCKT(sckt) red_printf("TUNNEL_DBG SOCKET(connection_id=%d port=%d, service=%d)",\
+#define PRINT_SCKT(sckt) red_log(2, "TUNNEL_DBG SOCKET(connection_id=%d port=%d, service=%d)",\
                                     sckt->connection_id, ntohs(sckt->local_port),             \
                                     sckt->far_service->id)
 #endif
@@ -477,7 +477,7 @@ static inline void tunnel_channel_activate_migrated_sockets(TunnelChannel *chann
    failed (which triggered from a call to slirp) */
 #define SET_TUNNEL_ERROR(channel,format, ...) {   \
     channel->tunnel_error = TRUE;                 \
-    red_printf(format, ## __VA_ARGS__);           \
+    red_warn(format, ## __VA_ARGS__);             \
 }
 
 /* should be checked after each subroutine that may cause error or after calls to slirp routines */
@@ -608,7 +608,8 @@ static void handle_tunnel_channel_migrate(struct Channel *channel);
 static void tunnel_shutdown(TunnelWorker *worker)
 {
     int i;
-    red_printf("");
+
+    red_log(2, "");
     /* shutdown input from channel */
     if (worker->channel) {
         red_channel_shutdown(&worker->channel->base);
@@ -1054,7 +1055,7 @@ static inline TunnelService *__tunnel_worker_add_service(TunnelWorker *worker, u
         TunnelService *service_of_same_group;
         if (!(service_of_same_group = __tunnel_worker_find_service_of_group(worker, group))) {
             if (!net_slirp_allocate_virtual_ip(&new_service->virt_ip)) {
-                red_printf("failed to allocate virtual ip");
+                red_warn("failed to allocate virtual ip");
                 free(new_service);
                 return NULL;
             }
@@ -1062,7 +1063,7 @@ static inline TunnelService *__tunnel_worker_add_service(TunnelWorker *worker, u
             if (strcmp(name, service_of_same_group->name) == 0) {
                 new_service->virt_ip.s_addr = service_of_same_group->virt_ip.s_addr;
             } else {
-                red_printf("inconsistent name for service group %d", group);
+                red_warn("inconsistent name for service group %d", group);
                 free(new_service);
                 return NULL;
             }
@@ -1084,7 +1085,7 @@ static inline TunnelService *__tunnel_worker_add_service(TunnelWorker *worker, u
     worker->num_services++;
 
 #ifdef DEBUG_NETWORK
-    red_printf("TUNNEL_DBG: ==>SERVICE ADDED: id=%d virt ip=%s port=%d name=%s desc=%s",
+    red_log(2, "TUNNEL_DBG: ==>SERVICE ADDED: id=%d virt ip=%s port=%d name=%s desc=%s",
                new_service->id, inet_ntoa(new_service->virt_ip),
                new_service->port, new_service->name, new_service->description);
 #endif
@@ -1137,12 +1138,12 @@ static TunnelPrintService *tunnel_worker_add_print_service(TunnelWorker *worker,
     if (redc_service->type == SPICE_TUNNEL_IP_TYPE_IPv4) {
         memcpy(service->ip, redc_service->u.ip.data, sizeof(SpiceTunnelIPv4));
     } else {
-        red_printf("unexpected ip type=%d", redc_service->type);
+        red_warn("unexpected ip type=%d", redc_service->type);
         tunnel_worker_free_print_service(worker, service);
         return NULL;
     }
 #ifdef DEBUG_NETWORK
-    red_printf("TUNNEL_DBG: ==>PRINT SERVICE ADDED: ip=%d.%d.%d.%d", service->ip[0],
+    red_log(2, "TUNNEL_DBG: ==>PRINT SERVICE ADDED: ip=%d.%d.%d.%d", service->ip[0],
                service->ip[1], service->ip[2], service->ip[3]);
 #endif
     return service;
@@ -1159,7 +1160,7 @@ static int tunnel_channel_handle_service_add(TunnelChannel *channel,
         out_service = tunnel_worker_add_service(channel->worker, sizeof(TunnelService),
                                                 service_msg);
     } else {
-        red_printf("invalid service type");
+        red_warn("invalid service type");
     }
 
     free(service_msg);
@@ -1412,7 +1413,7 @@ static int tunnel_channel_handle_socket_connect_ack(TunnelChannel *channel, RedS
                                                     uint32_t tokens)
 {
 #ifdef DEBUG_NETWORK
-    red_printf("TUNNEL_DBG");
+    red_log(2, "TUNNEL_DBG");
 #endif
     if (channel->mig_inprogress || channel->base.migrate) {
         sckt->mig_client_status_msg = SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK;
@@ -1421,7 +1422,7 @@ static int tunnel_channel_handle_socket_connect_ack(TunnelChannel *channel, RedS
     }
 
     if (sckt->client_status != CLIENT_SCKT_STATUS_WAIT_OPEN) {
-        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK status=%d", sckt->client_status);
+        red_warn("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK status=%d", sckt->client_status);
         return FALSE;
     }
     sckt->client_status = CLIENT_SCKT_STATUS_OPEN;
@@ -1435,7 +1436,7 @@ static int tunnel_channel_handle_socket_connect_ack(TunnelChannel *channel, RedS
         sckt->out_data.num_tokens = tokens;
         net_slirp_socket_connected_notify(sckt->slirp_sckt);
     } else {
-        red_printf("unexpected slirp status status=%d", sckt->slirp_status);
+        red_warn("unexpected slirp status status=%d", sckt->slirp_status);
         return FALSE;
     }
 
@@ -1453,7 +1454,7 @@ static int tunnel_channel_handle_socket_connect_nack(TunnelChannel *channel, Red
     }
 
     if (sckt->client_status != CLIENT_SCKT_STATUS_WAIT_OPEN) {
-        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK status=%d", sckt->client_status);
+        red_warn("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK status=%d", sckt->client_status);
         return FALSE;
     }
     sckt->client_status = CLIENT_SCKT_STATUS_CLOSED;
@@ -1478,7 +1479,7 @@ static int tunnel_channel_handle_socket_fin(TunnelChannel *channel, RedSocket *s
     }
 
     if (sckt->client_status != CLIENT_SCKT_STATUS_OPEN) {
-        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_FIN status=%d", sckt->client_status);
+        red_warn("unexpected SPICE_MSGC_TUNNEL_SOCKET_FIN status=%d", sckt->client_status);
         return FALSE;
     }
     sckt->client_status = CLIENT_SCKT_STATUS_SHUTDOWN_SEND;
@@ -1495,7 +1496,7 @@ static int tunnel_channel_handle_socket_fin(TunnelChannel *channel, RedSocket *s
         net_slirp_socket_can_receive_notify(sckt->slirp_sckt);
     } else if (sckt->slirp_status == SLIRP_SCKT_STATUS_SHUTDOWN_RECV) {
         // it already received the FIN
-        red_printf("unexpected slirp status=%d", sckt->slirp_status);
+        red_warn("unexpected slirp status=%d", sckt->slirp_status);
         return FALSE;
     }
 
@@ -1544,7 +1545,7 @@ static int tunnel_channel_handle_socket_closed(TunnelChannel *channel, RedSocket
         // slirp can be in wait close if both slirp and client sent fin previously
         // otherwise, the prev client status would also have been wait close, and this
         // case was handled above
-        red_printf("unexpected slirp_status=%d", sckt->slirp_status);
+        red_warn("unexpected slirp_status=%d", sckt->slirp_status);
         return FALSE;
     }
 
@@ -1569,8 +1570,8 @@ static int tunnel_channel_handle_socket_closed_ack(TunnelChannel *channel, RedSo
     }
 
     if (sckt->slirp_status != SLIRP_SCKT_STATUS_CLOSED) {
-        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK slirp_status=%d",
-                   sckt->slirp_status);
+        red_warn("unexpected SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK slirp_status=%d",
+                 sckt->slirp_status);
         return FALSE;
     }
 
@@ -1583,8 +1584,8 @@ static int tunnel_channel_handle_socket_receive_data(TunnelChannel *channel, Red
 {
     if ((sckt->client_status == CLIENT_SCKT_STATUS_SHUTDOWN_SEND) ||
         (sckt->client_status == CLIENT_SCKT_STATUS_CLOSED)) {
-        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_DATA client_status=%d",
-                   sckt->client_status);
+        red_warn("unexpected SPICE_MSGC_TUNNEL_SOCKET_DATA client_status=%d",
+                 sckt->client_status);
         return FALSE;
     }
 
@@ -1595,9 +1596,9 @@ static int tunnel_channel_handle_socket_receive_data(TunnelChannel *channel, Red
         return (!CHECK_TUNNEL_ERROR(channel));
     } else if ((sckt->in_data.num_buffers == MAX_SOCKET_IN_BUFFERS) &&
                !channel->mig_inprogress && !channel->base.migrate) {
-        red_printf("socket in buffers overflow, socket will be closed"
-                   " (local_port=%d, service_id=%d)",
-                   ntohs(sckt->local_port), sckt->far_service->id);
+        red_warn("socket in buffers overflow, socket will be closed"
+                 " (local_port=%d, service_id=%d)",
+                 ntohs(sckt->local_port), sckt->far_service->id);
         __tunnel_worker_free_socket_rcv_buf(sckt->worker, recv_data);
         tunnel_socket_force_close(channel, sckt);
         return (!CHECK_TUNNEL_ERROR(channel));
@@ -1605,7 +1606,7 @@ static int tunnel_channel_handle_socket_receive_data(TunnelChannel *channel, Red
 
     tunnel_socket_assign_rcv_buf(sckt, recv_data, buf_size);
     if (!sckt->in_data.client_total_num_tokens) {
-        red_printf("token violation");
+        red_warn("token violation");
         return FALSE;
     }
 
@@ -1749,7 +1750,7 @@ static int tunnel_channel_handle_migrate_mark(TunnelChannel *channel)
     RedSocket *sckt;
 
     if (!channel->expect_migrate_mark) {
-        red_printf("unexpected");
+        red_warn("unexpected");
         return FALSE;
     }
     channel->expect_migrate_mark = FALSE;
@@ -1758,7 +1759,7 @@ static int tunnel_channel_handle_migrate_mark(TunnelChannel *channel)
 
     migrate_item->slirp_state_size = net_slirp_state_export(&migrate_item->slirp_state);
     if (!migrate_item->slirp_state) {
-        red_printf("failed export slirp state");
+        red_warn("failed export slirp state");
         goto error;
     }
 
@@ -1891,7 +1892,7 @@ RawTunneledBuffer *__tunnel_socket_alloc_restore_tokens_buf(RedSocket *sckt, int
     buf->base.base.release_proc = restore_tokens_buf_release;
     buf->num_tokens = num_tokens;
 #ifdef DEBUG_NETWORK
-    red_printf("TUNNEL DBG: num_tokens=%d", num_tokens);
+    red_log(2, "TUNNEL DBG: num_tokens=%d", num_tokens);
 #endif
     return &buf->base.base;
 }
@@ -2055,7 +2056,8 @@ static void tunnel_channel_restore_migrated_socket(TunnelChannel *channel,
 static void tunnel_channel_restore_socket_state(TunnelChannel *channel, RedSocket *sckt)
 {
     int ret = TRUE;
-    red_printf("");
+
+    red_log(2, "");
     // handling client status msgs that were received during migration
     switch (sckt->mig_client_status_msg) {
     case 0:
@@ -2162,14 +2164,14 @@ static int tunnel_channel_handle_migrate_data(TunnelChannel *channel,
     int i;
 
     if (!channel->expect_migrate_data) {
-        red_printf("unexpected");
+        red_warn("unexpected");
         goto error;
     }
     channel->expect_migrate_data = FALSE;
 
     if (migrate_data->magic != TUNNEL_MIGRATE_DATA_MAGIC ||
         migrate_data->version != TUNNEL_MIGRATE_DATA_VERSION) {
-        red_printf("invalid content");
+        red_warn("invalid content");
         goto error;
     }
 
@@ -2186,7 +2188,7 @@ static int tunnel_channel_handle_migrate_data(TunnelChannel *channel,
                                                                         services_list->services[i]),
                                                 migrate_data->data);
         if (CHECK_TUNNEL_ERROR(channel)) {
-            red_printf("failed restoring service");
+            red_warn("failed restoring service");
             goto error;
         }
     }
@@ -2199,7 +2201,7 @@ static int tunnel_channel_handle_migrate_data(TunnelChannel *channel,
                                                                        sockets_list->sockets[i]),
                                                migrate_data->data);
         if (CHECK_TUNNEL_ERROR(channel)) {
-            red_printf("failed restoring socket");
+            red_warn("failed restoring socket");
             goto error;
         }
     }
@@ -2242,7 +2244,7 @@ static int tunnel_channel_handle_message(RedChannel *channel, SpiceDataHeader *h
         // the first field in these messages is connection id
         sckt = tunnel_channel->worker->sockets + (*((uint16_t *)msg));
         if (!sckt->allocated) {
-            red_printf("red socket not found");
+            red_warn("red socket not found");
             return FALSE;
         }
         break;
@@ -2253,18 +2255,18 @@ static int tunnel_channel_handle_message(RedChannel *channel, SpiceDataHeader *h
     switch (header->type) {
     case SPICE_MSGC_TUNNEL_SERVICE_ADD:
         if (header->size < sizeof(SpiceMsgcTunnelAddGenericService)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             free(msg);
             return FALSE;
         }
         return tunnel_channel_handle_service_add(tunnel_channel,
                                                  (SpiceMsgcTunnelAddGenericService *)msg);
     case SPICE_MSGC_TUNNEL_SERVICE_REMOVE:
-        red_printf("REDC_TUNNEL_REMOVE_SERVICE not supported yet");
+        red_warn("REDC_TUNNEL_REMOVE_SERVICE not supported yet");
         return FALSE;
     case SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK:
         if (header->size != sizeof(SpiceMsgcTunnelSocketOpenAck)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             return FALSE;
         }
 
@@ -2273,7 +2275,7 @@ static int tunnel_channel_handle_message(RedChannel *channel, SpiceDataHeader *h
 
     case SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK:
         if (header->size != sizeof(SpiceMsgcTunnelSocketOpenNack)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             return FALSE;
         }
 
@@ -2281,7 +2283,7 @@ static int tunnel_channel_handle_message(RedChannel *channel, SpiceDataHeader *h
     case SPICE_MSGC_TUNNEL_SOCKET_DATA:
     {
         if (header->size < sizeof(SpiceMsgcTunnelSocketData)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             return FALSE;
         }
 
@@ -2291,25 +2293,25 @@ static int tunnel_channel_handle_message(RedChannel *channel, SpiceDataHeader *h
     }
     case SPICE_MSGC_TUNNEL_SOCKET_FIN:
         if (header->size != sizeof(SpiceMsgcTunnelSocketFin)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             return FALSE;
         }
         return tunnel_channel_handle_socket_fin(tunnel_channel, sckt);
     case SPICE_MSGC_TUNNEL_SOCKET_CLOSED:
         if (header->size != sizeof(SpiceMsgcTunnelSocketClosed)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             return FALSE;
         }
         return tunnel_channel_handle_socket_closed(tunnel_channel, sckt);
     case SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK:
         if (header->size != sizeof(SpiceMsgcTunnelSocketClosedAck)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             return FALSE;
         }
         return tunnel_channel_handle_socket_closed_ack(tunnel_channel, sckt);
     case SPICE_MSGC_TUNNEL_SOCKET_TOKEN:
         if (header->size != sizeof(SpiceMsgcTunnelSocketTokens)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             return FALSE;
         }
 
@@ -2319,7 +2321,7 @@ static int tunnel_channel_handle_message(RedChannel *channel, SpiceDataHeader *h
         return tunnel_channel_handle_migrate_mark(tunnel_channel);
     case SPICE_MSGC_MIGRATE_DATA:
         if (header->size < sizeof(TunnelMigrateData)) {
-            red_printf("bad message size");
+            red_warn("bad message size");
             free(msg);
             return FALSE;
         }
@@ -2594,9 +2596,9 @@ static void tunnel_channel_send_socket_fin(TunnelChannel *channel, PipeItem *ite
     ASSERT(!sckt->out_data.ready_chunks_queue.head);
 
     if (sckt->out_data.process_queue->head) {
-        red_printf("socket sent FIN but there are still buffers in outgoing process queue"
-                   "(local_port=%d, service_id=%d)",
-                   ntohs(sckt->local_port), sckt->far_service->id);
+        red_warn("socket sent FIN but there are still buffers in outgoing process queue"
+                 "(local_port=%d, service_id=%d)",
+                 ntohs(sckt->local_port), sckt->far_service->id);
     }
 
     channel->send_data.u.socket_fin.connection_id = sckt->connection_id;
@@ -2619,16 +2621,16 @@ static void tunnel_channel_send_socket_close(TunnelChannel *channel, PipeItem *i
 
     // can happen when it is a forced close
     if (sckt->out_data.ready_chunks_queue.head) {
-        red_printf("socket closed but there are still buffers in outgoing ready queue"
-                   "(local_port=%d, service_id=%d)",
-                   ntohs(sckt->local_port),
-                   sckt->far_service->id);
+        red_warn("socket closed but there are still buffers in outgoing ready queue"
+                 "(local_port=%d, service_id=%d)",
+                 ntohs(sckt->local_port),
+                 sckt->far_service->id);
     }
 
     if (sckt->out_data.process_queue->head) {
-        red_printf("socket closed but there are still buffers in outgoing process queue"
-                   "(local_port=%d, service_id=%d)",
-                   ntohs(sckt->local_port), sckt->far_service->id);
+        red_warn("socket closed but there are still buffers in outgoing process queue"
+                 "(local_port=%d, service_id=%d)",
+                 ntohs(sckt->local_port), sckt->far_service->id);
     }
 
     channel->send_data.u.socket_close.connection_id = sckt->connection_id;
@@ -2924,7 +2926,7 @@ static int tunnel_socket_connect(SlirpUsrNetworkInterface *usr_interface,
     ASSERT(usr_interface);
 
 #ifdef DEBUG_NETWORK
-    red_printf("TUNNEL_DBG");
+    red_log(2, "TUNNEL_DBG");
 #endif
     worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
     ASSERT(worker->channel);
@@ -2938,13 +2940,13 @@ static int tunnel_socket_connect(SlirpUsrNetworkInterface *usr_interface,
     }
 
     if (tunnel_worker_find_socket(worker, src_port, far_service->id)) {
-        red_printf("slirp tried to open a socket that is still opened");
+        red_warn("slirp tried to open a socket that is still opened");
         errno = EADDRINUSE;
         return -1;
     }
 
     if (worker->num_sockets == MAX_SOCKETS_NUM) {
-        red_printf("number of tunneled sockets exceeds the limit");
+        red_warn("number of tunneled sockets exceeds the limit");
         errno = ENFILE;
         return -1;
     }
@@ -2992,7 +2994,7 @@ static int tunnel_socket_send(SlirpUsrNetworkInterface *usr_interface, UserSocke
 
     if ((sckt->client_status != CLIENT_SCKT_STATUS_OPEN) &&
         (sckt->client_status != CLIENT_SCKT_STATUS_SHUTDOWN_SEND)) {
-        red_printf("client socket is unable to receive data");
+        red_warn("client socket is unable to receive data");
         errno = ECONNRESET;
         return -1;
     }
@@ -3000,7 +3002,7 @@ static int tunnel_socket_send(SlirpUsrNetworkInterface *usr_interface, UserSocke
 
     if ((sckt->slirp_status == SLIRP_SCKT_STATUS_SHUTDOWN_SEND) ||
         (sckt->slirp_status == SLIRP_SCKT_STATUS_WAIT_CLOSE)) {
-        red_printf("send was shutdown");
+        red_warn("send was shutdown");
         errno = EPIPE;
         return -1;
     }
@@ -3026,9 +3028,9 @@ static int tunnel_socket_send(SlirpUsrNetworkInterface *usr_interface, UserSocke
             ASSERT(sckt->out_data.process_queue->head);
             if ((sckt->out_data.data_size + len) >
                                                   (MAX_SOCKET_OUT_BUFFERS * MAX_SOCKET_DATA_SIZE)) {
-                red_printf("socket out buffers overflow, socket will be closed"
-                           " (local_port=%d, service_id=%d)",
-                           ntohs(sckt->local_port), sckt->far_service->id);
+                red_warn("socket out buffers overflow, socket will be closed"
+                         " (local_port=%d, service_id=%d)",
+                         ntohs(sckt->local_port), sckt->far_service->id);
                 tunnel_socket_force_close(worker->channel, sckt);
                 size_to_send = 0;
             } else {
@@ -3118,9 +3120,9 @@ static int tunnel_socket_recv(SlirpUsrNetworkInterface *usr_interface, UserSocke
     // if there is data in ready queue, when it is acked, slirp will call recv and get 0
     if (__should_send_fin_to_guest(sckt)) {
         if (sckt->in_data.process_queue->head) {
-            red_printf("client socket sent FIN but there are still buffers in incoming process"
-                       "queue (local_port=%d, service_id=%d)",
-                       ntohs(sckt->local_port), sckt->far_service->id);
+            red_warn("client socket sent FIN but there are still buffers in incoming process"
+                     "queue (local_port=%d, service_id=%d)",
+                     ntohs(sckt->local_port), sckt->far_service->id);
         }
         return 0; // slirp will call shutdown recv now and it will also send FIN to the guest.
     }
@@ -3326,7 +3328,7 @@ static void arm_timer(SlirpUsrNetworkInterface *usr_interface, UserTimer *timer,
     worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
 #ifdef DEBUG_NETWORK
     if (!worker->channel) {
-        red_printf("channel not connected");
+        red_warn("channel not connected");
     }
 #endif
     if (worker->channel && worker->channel->mig_inprogress) {
@@ -3348,12 +3350,12 @@ static int tunnel_channel_config_socket(RedChannel *channel)
     int delay_val;
 
     if ((flags = fcntl(channel->stream->socket, F_GETFL)) == -1) {
-        red_printf("accept failed, %s", strerror(errno)); // can't we just use red_error?
+        red_warn("accept failed, %s", strerror(errno)); // can't we just use red_error?
         return FALSE;
     }
 
     if (fcntl(channel->stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
-        red_printf("accept failed, %s", strerror(errno));
+        red_warn("accept failed, %s", strerror(errno));
         return FALSE;
     }
 
@@ -3361,7 +3363,7 @@ static int tunnel_channel_config_socket(RedChannel *channel)
 
     if (setsockopt(channel->stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val,
                    sizeof(delay_val)) == -1) {
-        red_printf("setsockopt failed, %s", strerror(errno));
+        red_warn("setsockopt failed, %s", strerror(errno));
     }
 
     return TRUE;
@@ -3396,7 +3398,7 @@ static void tunnel_channel_disconnect(RedChannel *channel)
     if (!channel) {
         return;
     }
-    red_printf("");
+    red_log(2, "");
     worker = tunnel_channel->worker;
 
     tunnel_worker_disconnect_slirp(worker);
@@ -3461,7 +3463,7 @@ static void handle_tunnel_channel_shutdown(struct Channel *channel)
 static void handle_tunnel_channel_migrate(struct Channel *channel)
 {
 #ifdef DEBUG_NETWORK
-    red_printf("TUNNEL_DBG: MIGRATE STARTED");
+    red_log(2, "TUNNEL_DBG: MIGRATE STARTED");
 #endif
     TunnelChannel *tunnel_channel = ((TunnelWorker *)channel->data)->channel;
     tunnel_channel->mig_inprogress = TRUE;
diff --git a/server/red_worker.c b/server/red_worker.c
index 5f07803..0d67586 100644
--- a/server/red_worker.c
+++ b/server/red_worker.c
@@ -995,46 +995,46 @@ static void print_compress_stats(DisplayChannel *display_channel)
                        display_channel->zlib_glz_stat.comp_size :
                        display_channel->glz_stat.comp_size;
 
-    red_printf("==> Compression stats for display %u", display_channel->base.id);
-    red_printf("Method   \t  count  \torig_size(MB)\tenc_size(MB)\tenc_time(s)");
-    red_printf("QUIC     \t%8d\t%13.2f\t%12.2f\t%12.2f",
+    red_log(2, "==> Compression stats for display %u", display_channel->base.id);
+    red_log(2, "Method   \t  count  \torig_size(MB)\tenc_size(MB)\tenc_time(s)");
+    red_log(2, "QUIC     \t%8d\t%13.2f\t%12.2f\t%12.2f",
                display_channel->quic_stat.count,
                stat_byte_to_mega(display_channel->quic_stat.orig_size),
                stat_byte_to_mega(display_channel->quic_stat.comp_size),
                stat_cpu_time_to_sec(display_channel->quic_stat.total)
                );
-    red_printf("GLZ      \t%8d\t%13.2f\t%12.2f\t%12.2f",
+    red_log(2, "GLZ      \t%8d\t%13.2f\t%12.2f\t%12.2f",
                display_channel->glz_stat.count,
                stat_byte_to_mega(display_channel->glz_stat.orig_size),
                stat_byte_to_mega(display_channel->glz_stat.comp_size),
                stat_cpu_time_to_sec(display_channel->glz_stat.total)
                );
-    red_printf("ZLIB GLZ \t%8d\t%13.2f\t%12.2f\t%12.2f",
+    red_log(2, "ZLIB GLZ \t%8d\t%13.2f\t%12.2f\t%12.2f",
                display_channel->zlib_glz_stat.count,
                stat_byte_to_mega(display_channel->zlib_glz_stat.orig_size),
                stat_byte_to_mega(display_channel->zlib_glz_stat.comp_size),
                stat_cpu_time_to_sec(display_channel->zlib_glz_stat.total)
                );
-    red_printf("LZ       \t%8d\t%13.2f\t%12.2f\t%12.2f",
+    red_log(2, "LZ       \t%8d\t%13.2f\t%12.2f\t%12.2f",
                display_channel->lz_stat.count,
                stat_byte_to_mega(display_channel->lz_stat.orig_size),
                stat_byte_to_mega(display_channel->lz_stat.comp_size),
                stat_cpu_time_to_sec(display_channel->lz_stat.total)
                );
-    red_printf("JPEG     \t%8d\t%13.2f\t%12.2f\t%12.2f",
+    red_log(2, "JPEG     \t%8d\t%13.2f\t%12.2f\t%12.2f",
                display_channel->jpeg_stat.count,
                stat_byte_to_mega(display_channel->jpeg_stat.orig_size),
                stat_byte_to_mega(display_channel->jpeg_stat.comp_size),
                stat_cpu_time_to_sec(display_channel->jpeg_stat.total)
                );
-    red_printf("JPEG-RGBA\t%8d\t%13.2f\t%12.2f\t%12.2f",
+    red_log(2, "JPEG-RGBA\t%8d\t%13.2f\t%12.2f\t%12.2f",
                display_channel->jpeg_alpha_stat.count,
                stat_byte_to_mega(display_channel->jpeg_alpha_stat.orig_size),
                stat_byte_to_mega(display_channel->jpeg_alpha_stat.comp_size),
                stat_cpu_time_to_sec(display_channel->jpeg_alpha_stat.total)
                );
-    red_printf("-------------------------------------------------------------------");
-    red_printf("Total    \t%8d\t%13.2f\t%12.2f\t%12.2f",
+    red_log(2, "-------------------------------------------------------------------");
+    red_log(2, "Total    \t%8d\t%13.2f\t%12.2f\t%12.2f",
                display_channel->lz_stat.count + display_channel->glz_stat.count +
                                                 display_channel->quic_stat.count +
                                                 display_channel->jpeg_stat.count +
@@ -1917,7 +1917,7 @@ void __show_current(TreeItem *item, void *data)
 static void show_current(RedWorker *worker, Ring *ring)
 {
     if (ring_is_empty(ring)) {
-        red_printf("TEST: TREE: EMPTY");
+        red_log(2, "TEST: TREE: EMPTY");
         return;
     }
     current_tree_for_each(worker, ring, __show_current, NULL);
@@ -2918,7 +2918,7 @@ static void red_reset_stream_trace(RedWorker *worker)
         if (!stream->current) {
             red_stop_stream(worker, stream);
         } else {
-            red_printf("attached stream");
+            red_log(2, "attached stream");
         }
     }
 
@@ -3010,7 +3010,7 @@ static inline int red_current_add(RedWorker *worker, Ring *ring, Drawable *drawa
                 if (!((DrawItem *)sibling)->container_root) {
                     container = __new_container(worker, (DrawItem *)sibling);
                     if (!container) {
-                        red_printf("create new container failed");
+                        red_warn("create new container failed");
                         region_destroy(&exclude_rgn);
                         return FALSE;
                     }
@@ -3174,17 +3174,17 @@ static inline int red_current_add_qxl(RedWorker *worker, Ring *ring, Drawable *d
 #ifdef RED_WORKER_STAT
     if ((++worker->add_count % 100) == 0) {
         stat_time_t total = worker->add_stat.total;
-        red_printf("add with shadow count %u",
+        red_log(2, "add with shadow count %u",
                    worker->add_with_shadow_count);
         worker->add_with_shadow_count = 0;
-        red_printf("add[%u] %f exclude[%u] %f __exclude[%u] %f",
+        red_log(2, "add[%u] %f exclude[%u] %f __exclude[%u] %f",
                    worker->add_stat.count,
                    stat_cpu_time_to_sec(total),
                    worker->exclude_stat.count,
                    stat_cpu_time_to_sec(worker->exclude_stat.total),
                    worker->__exclude_stat.count,
                    stat_cpu_time_to_sec(worker->__exclude_stat.total));
-        red_printf("add %f%% exclude %f%% exclude2 %f%% __exclude %f%%",
+        red_log(2, "add %f%% exclude %f%% exclude2 %f%% __exclude %f%%",
                    (double)(total - worker->exclude_stat.total) / total * 100,
                    (double)(worker->exclude_stat.total) / total * 100,
                    (double)(worker->exclude_stat.total -
@@ -3902,7 +3902,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
         break;
     }
     default:
-        red_printf("invalid type");
+        red_warn("invalid type");
     }
 }
 
@@ -4396,7 +4396,7 @@ static int red_process_commands(RedWorker *worker, uint32_t max_pipe_size, int *
                             &message, ext_cmd.cmd.data);
 #ifdef DEBUG
             /* alert: accessing message.data is insecure */
-            red_printf("MESSAGE: %s", message.data);
+            red_log(2, "MESSAGE: %s", message.data);
 #endif
             release_info_ext.group_id = ext_cmd.group_id;
             release_info_ext.info = message.release_info;
@@ -4857,7 +4857,7 @@ static void quic_usr_error(QuicUsrContext *usr, const char *fmt, ...)
     va_start(ap, fmt);
     vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
     va_end(ap);
-    red_printf("%s", usr_data->message_buf);
+    red_warn("%s", usr_data->message_buf);
 
     longjmp(usr_data->jmp_env, 1);
 }
@@ -4870,7 +4870,7 @@ static void lz_usr_error(LzUsrContext *usr, const char *fmt, ...)
     va_start(ap, fmt);
     vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
     va_end(ap);
-    red_printf("%s", usr_data->message_buf);
+    red_warn("%s", usr_data->message_buf);
 
     longjmp(usr_data->jmp_env, 1);
 }
@@ -4898,7 +4898,7 @@ static void quic_usr_warn(QuicUsrContext *usr, const char *fmt, ...)
     va_start(ap, fmt);
     vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
     va_end(ap);
-    red_printf("%s", usr_data->message_buf);
+    red_warn("%s", usr_data->message_buf);
 }
 
 static void lz_usr_warn(LzUsrContext *usr, const char *fmt, ...)
@@ -4909,7 +4909,7 @@ static void lz_usr_warn(LzUsrContext *usr, const char *fmt, ...)
     va_start(ap, fmt);
     vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
     va_end(ap);
-    red_printf("%s", usr_data->message_buf);
+    red_warn("%s", usr_data->message_buf);
 }
 
 static void glz_usr_warn(GlzEncoderUsrContext *usr, const char *fmt, ...)
@@ -4920,7 +4920,7 @@ static void glz_usr_warn(GlzEncoderUsrContext *usr, const char *fmt, ...)
     va_start(ap, fmt);
     vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
     va_end(ap);
-    red_printf("%s", usr_data->message_buf);
+    red_warn("%s", usr_data->message_buf);
 }
 
 static void *quic_usr_malloc(QuicUsrContext *usr, int size)
@@ -5362,7 +5362,7 @@ static inline int red_glz_compress_image(DisplayChannel *display_channel,
     zlib_data->data.bufs_head = zlib_data->data.bufs_tail;
 
     if (!zlib_data->data.bufs_head) {
-        red_printf("failed to allocate zlib compress buffer");
+        red_warn("failed to allocate zlib compress buffer");
         goto glz;
     }
 
@@ -5523,7 +5523,7 @@ static int red_jpeg_compress_image(DisplayChannel *display_channel, SpiceImage *
     jpeg_data->data.bufs_head = jpeg_data->data.bufs_tail;
 
     if (!jpeg_data->data.bufs_head) {
-        red_printf("failed to allocate compress buffer");
+        red_warn("failed to allocate compress buffer");
         return FALSE;
     }
 
@@ -5762,7 +5762,7 @@ static inline int red_compress_image(DisplayChannel *display_channel,
 
     if (quic_compress) {
 #ifdef COMPRESS_DEBUG
-        red_printf("QUIC compress");
+        red_log(2, "QUIC compress");
 #endif
         // if bitmaps is picture-like, compress it using jpeg
         if (can_lossy && display_channel->enable_jpeg &&
@@ -5808,12 +5808,12 @@ static inline int red_compress_image(DisplayChannel *display_channel,
             ret = red_lz_compress_image(display_channel, dest, src, o_comp_data,
                                         drawable->group_id);
 #ifdef COMPRESS_DEBUG
-            red_printf("LZ LOCAL compress");
+            red_log(2, "LZ LOCAL compress");
 #endif
         }
 #ifdef COMPRESS_DEBUG
         else {
-            red_printf("LZ global compress fmt=%d", src->format);
+            red_log(2, "LZ global compress fmt=%d", src->format);
         }
 #endif
         return ret;
@@ -7345,7 +7345,7 @@ static void red_send_data(RedChannel *channel, void *item)
                 channel->disconnect(channel);
                 return;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 channel->disconnect(channel);
                 return;
             }
@@ -7476,7 +7476,7 @@ static inline uint8_t *red_get_image_line(RedWorker *worker, SpiceChunks *chunks
     }
 
     if (chunk->len - *offset < stride) {
-        red_printf("bad chunk alignment");
+        red_warn("bad chunk alignment");
         return NULL;
     }
     ret = chunk->data + *offset;
@@ -7687,7 +7687,7 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable
         }
         break;
     default:
-        red_printf_some(1000, "unsupported format %d", image->u.bitmap.format);
+        red_log_some(LOG_WARN, 1000, "unsupported format %d", image->u.bitmap.format);
         return FALSE;
     }
 
@@ -8307,7 +8307,7 @@ static void display_channel_push(RedWorker *worker)
             free(pipe_item);
             break;
         case PIPE_ITEM_TYPE_MIGRATE:
-            red_printf("PIPE_ITEM_TYPE_MIGRATE");
+            red_log(2, "PIPE_ITEM_TYPE_MIGRATE");
             display_channel_send_migrate(display_channel);
             free(pipe_item);
             break;
@@ -8379,7 +8379,7 @@ static void cursor_channel_push(RedWorker *worker)
             free(pipe_item);
             break;
         case PIPE_ITEM_TYPE_MIGRATE:
-            red_printf("PIPE_ITEM_TYPE_MIGRATE");
+            red_log(2, "PIPE_ITEM_TYPE_MIGRATE");
             cursor_channel_send_migrate(cursor_channel);
             free(pipe_item);
             break;
@@ -8762,7 +8762,7 @@ static inline void flush_display_commands(RedWorker *worker)
             red_receive(channel);
             red_send_data(channel, NULL);
             if (red_now() >= end_time) {
-                red_printf("update timeout");
+                red_warn("update timeout");
                 red_disconnect_display(channel);
             } else {
                 sleep_count++;
@@ -8804,7 +8804,7 @@ static inline void flush_cursor_commands(RedWorker *worker)
             red_receive(channel);
             red_send_data(channel, NULL);
             if (red_now() >= end_time) {
-                red_printf("flush cursor timeout");
+                red_warn("flush cursor timeout");
                 red_disconnect_cursor(channel);
             } else {
                 sleep_count++;
@@ -8854,7 +8854,7 @@ static int display_channel_wait_for_init(DisplayChannel *display_channel)
             return TRUE;
         }
         if (red_now() > end_time) {
-            red_printf("timeout");
+            red_warn("timeout");
             red_disconnect_display((RedChannel *)display_channel);
             break;
         }
@@ -8904,7 +8904,7 @@ static int channel_handle_message(RedChannel *channel, size_t size, uint32_t typ
     case SPICE_MSGC_DISCONNECTING:
         break;
     default:
-        red_printf("invalid message type %u", type);
+        red_warn("invalid message type %u", type);
         return FALSE;
     }
     return TRUE;
@@ -8948,7 +8948,7 @@ static GlzSharedDictionary *red_create_glz_dictionary(DisplayChannel *display,
                                                             MAX_LZ_ENCODERS,
                                                             &display->glz_data.usr);
 #ifdef COMPRESS_DEBUG
-    red_printf("Lz Window %d Size=%d", id, window_size);
+    red_log(2, "Lz Window %d Size=%d", id, window_size);
 #endif
     if (!glz_dict) {
         PANIC("failed creating lz dictionary");
@@ -9136,7 +9136,7 @@ static int display_channel_handle_migrate_glz_dictionary(DisplayChannel *channel
 static int display_channel_handle_migrate_mark(DisplayChannel *channel)
 {
     if (!channel->expect_migrate_mark) {
-        red_printf("unexpected");
+        red_warn("unexpected");
         return FALSE;
     }
     channel->expect_migrate_mark = FALSE;
@@ -9150,18 +9150,18 @@ static int display_channel_handle_migrate_data(DisplayChannel *channel, size_t s
     int i;
 
     if (!channel->expect_migrate_data) {
-        red_printf("unexpected");
+        red_warn("unexpected");
         return FALSE;
     }
     channel->expect_migrate_data = FALSE;
     if (size < sizeof(*migrate_data)) {
-        red_printf("bad message size");
+        red_warn("bad message size");
         return FALSE;
     }
     migrate_data = (DisplayChannelMigrateData *)message;
     if (migrate_data->magic != DISPLAY_MIGRATE_DATA_MAGIC ||
                                             migrate_data->version != DISPLAY_MIGRATE_DATA_VERSION) {
-        red_printf("invalid content");
+        red_warn("invalid content");
         return FALSE;
     }
     ASSERT(channel->base.send_data.serial == 0);
@@ -9202,7 +9202,7 @@ static int display_channel_handle_message(RedChannel *channel, size_t size, uint
     switch (type) {
     case SPICE_MSGC_DISPLAY_INIT:
         if (!((DisplayChannel *)channel)->expect_init) {
-            red_printf("unexpected SPICE_MSGC_DISPLAY_INIT");
+            red_warn("unexpected SPICE_MSGC_DISPLAY_INIT");
             return FALSE;
         }
         ((DisplayChannel *)channel)->expect_init = FALSE;
@@ -9239,7 +9239,7 @@ static void red_receive(RedChannel *channel)
                 channel->disconnect(channel);
                 return;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 channel->disconnect(channel);
                 return;
             }
@@ -9261,7 +9261,7 @@ static void red_receive(RedChannel *channel)
                                          SPICE_VERSION_MINOR, &parsed_size, &parsed_free);
 
                 if (parsed == NULL) {
-                    red_printf("failed to parse message type %d", header->type);
+                    red_warn("failed to parse message type %d", header->type);
                     channel->disconnect(channel);
                     return;
                 }
@@ -9303,18 +9303,18 @@ static RedChannel *__new_channel(RedWorker *worker, int size, uint32_t channel_i
     int delay_val;
 
     if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
-        red_printf("accept failed, %s", strerror(errno));
+        red_warn("accept failed, %s", strerror(errno));
         goto error1;
     }
 
     if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
-        red_printf("accept failed, %s", strerror(errno));
+        red_warn("accept failed, %s", strerror(errno));
         goto error1;
     }
 
     delay_val = IS_LOW_BANDWIDTH() ? 0 : 1;
     if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
-        red_printf("setsockopt failed, %s", strerror(errno));
+        red_warn("setsockopt failed, %s", strerror(errno));
     }
 
     ASSERT(size >= sizeof(*channel));
@@ -9343,7 +9343,7 @@ static RedChannel *__new_channel(RedWorker *worker, int size, uint32_t channel_i
     event.events = EPOLLIN | EPOLLOUT | EPOLLET;
     event.data.ptr = channel;
     if (epoll_ctl(worker->epoll, EPOLL_CTL_ADD, stream->socket, &event) == -1) {
-        red_printf("epoll_ctl failed, %s", strerror(errno));
+        red_warn("epoll_ctl failed, %s", strerror(errno));
         goto error2;
     }
 
@@ -9476,8 +9476,8 @@ static void handle_new_display_channel(RedWorker *worker, RedsStream *stream, in
                                                  SPICE_WAN_COMPRESSION_ALWAYS);
     }
 
-    red_printf("jpeg %s", display_channel->enable_jpeg ? "enabled" : "disabled");
-    red_printf("zlib-over-glz %s", display_channel->enable_zlib_glz_wrap ? "enabled" : "disabled");
+    red_log(2, "jpeg %s", display_channel->enable_jpeg ? "enabled" : "disabled");
+    red_log(2, "zlib-over-glz %s", display_channel->enable_zlib_glz_wrap ? "enabled" : "disabled");
 
     // todo: tune level according to bandwidth
     display_channel->zlib_level = ZLIB_DEFAULT_COMPRESSION_LEVEL;
@@ -9584,7 +9584,7 @@ static void red_wait_outgoing_item(RedChannel *channel)
     red_ref_channel(channel);
 
     end_time = red_now() + DETACH_TIMEOUT;
-    red_printf("blocked");
+    red_log(2, "blocked");
 
     do {
         usleep(DETACH_SLEEP_DURATION);
@@ -9593,7 +9593,7 @@ static void red_wait_outgoing_item(RedChannel *channel)
     } while ((blocked = channel->send_data.blocked) && red_now() < end_time);
 
     if (blocked) {
-        red_printf("timeout");
+        red_warn("timeout");
         channel->disconnect(channel);
     }
     red_unref_channel(channel);
@@ -9608,7 +9608,7 @@ static void red_wait_pipe_item_sent(RedChannel *channel, PipeItem *item)
         return;
     }
 
-    red_printf("");
+    red_log(2, "");
     red_ref_channel(channel);
     channel->hold_item(item);
 
@@ -9629,7 +9629,7 @@ static void red_wait_pipe_item_sent(RedChannel *channel, PipeItem *item)
     }
 
     if (item_in_pipe) {
-        red_printf("timeout");
+        red_warn("timeout");
         channel->disconnect(channel);
     } else {
         if (channel->send_data.item == item) {
@@ -9991,7 +9991,7 @@ static void handle_dev_input(EventListener *listener, uint32_t events)
             display_channel_push(worker);
         }
         if (worker->qxl->st->qif->flush_resources(worker->qxl) == 0) {
-            red_printf("oom current %u pipe %u", worker->current_size, worker->display_channel ?
+            red_warn("oom current %u pipe %u", worker->current_size, worker->display_channel ?
                        worker->display_channel->base.pipe_size : 0);
             red_free_some(worker);
             worker->qxl->st->qif->flush_resources(worker->qxl);
@@ -10023,7 +10023,7 @@ static void handle_dev_input(EventListener *listener, uint32_t events)
     case RED_WORKER_MESSAGE_DISPLAY_CONNECT: {
         RedsStream *stream;
         int migrate;
-        red_printf("connect");
+        red_log(2, "connect");
 
         receive_data(worker->channel, &stream, sizeof(RedsStream *));
         receive_data(worker->channel, &migrate, sizeof(int));
@@ -10031,38 +10031,38 @@ static void handle_dev_input(EventListener *listener, uint32_t events)
         break;
     }
     case RED_WORKER_MESSAGE_DISPLAY_DISCONNECT:
-        red_printf("disconnect");
+        red_log(2, "disconnect");
         red_disconnect_display((RedChannel *)worker->display_channel);
         break;
     case RED_WORKER_MESSAGE_STOP: {
-        red_printf("stop");
+        red_log(2, "stop");
         handle_dev_stop(worker);
         break;
     }
     case RED_WORKER_MESSAGE_START:
-        red_printf("start");
+        red_log(2, "start");
         handle_dev_start(worker);
         break;
     case RED_WORKER_MESSAGE_DISPLAY_MIGRATE:
-        red_printf("migrate");
+        red_log(2, "migrate");
         red_migrate_display(worker);
         break;
     case RED_WORKER_MESSAGE_CURSOR_CONNECT: {
         RedsStream *stream;
         int migrate;
 
-        red_printf("cursor connect");
+        red_log(2, "cursor connect");
         receive_data(worker->channel, &stream, sizeof(RedsStream *));
         receive_data(worker->channel, &migrate, sizeof(int));
         red_connect_cursor(worker, stream, migrate);
         break;
     }
     case RED_WORKER_MESSAGE_CURSOR_DISCONNECT:
-        red_printf("cursor disconnect");
+        red_log(2, "cursor disconnect");
         red_disconnect_cursor((RedChannel *)worker->cursor_channel);
         break;
     case RED_WORKER_MESSAGE_CURSOR_MIGRATE:
-        red_printf("cursor migrate");
+        red_log(2, "cursor migrate");
         red_migrate_cursor(worker);
         break;
     case RED_WORKER_MESSAGE_SET_COMPRESSION:
@@ -10070,25 +10070,25 @@ static void handle_dev_input(EventListener *listener, uint32_t events)
                      sizeof(spice_image_compression_t));
         switch (worker->image_compression) {
         case SPICE_IMAGE_COMPRESS_AUTO_LZ:
-            red_printf("ic auto_lz");
+            red_log(2, "ic auto_lz");
             break;
         case SPICE_IMAGE_COMPRESS_AUTO_GLZ:
-            red_printf("ic auto_glz");
+            red_log(2, "ic auto_glz");
             break;
         case SPICE_IMAGE_COMPRESS_QUIC:
-            red_printf("ic quic");
+            red_log(2, "ic quic");
             break;
         case SPICE_IMAGE_COMPRESS_LZ:
-            red_printf("ic lz");
+            red_log(2, "ic lz");
             break;
         case SPICE_IMAGE_COMPRESS_GLZ:
-            red_printf("ic glz");
+            red_log(2, "ic glz");
             break;
         case SPICE_IMAGE_COMPRESS_OFF:
-            red_printf("ic off");
+            red_log(2, "ic off");
             break;
         default:
-            red_printf("ic invalid");
+            red_warn("ic invalid");
         }
 #ifdef COMPRESS_STAT
         print_compress_stats(worker->display_channel);
@@ -10107,21 +10107,21 @@ static void handle_dev_input(EventListener *listener, uint32_t events)
         ASSERT(worker->streaming_video != STREAM_VIDEO_INVALID);
         switch(worker->streaming_video) {
             case STREAM_VIDEO_ALL:
-                red_printf("sv all");
+                red_log(2, "sv all");
                 break;
             case STREAM_VIDEO_FILTER:
-                red_printf("sv filter");
+                red_log(2, "sv filter");
                 break;
             case STREAM_VIDEO_OFF:
-                red_printf("sv off");
+                red_log(2, "sv off");
                 break;
             default:
-                red_printf("sv invalid");
+                red_warn("sv invalid");
         }
         break;
     case RED_WORKER_MESSAGE_SET_MOUSE_MODE:
         receive_data(worker->channel, &worker->mouse_mode, sizeof(uint32_t));
-        red_printf("mouse mode %u", worker->mouse_mode);
+        red_log(2, "mouse mode %u", worker->mouse_mode);
         break;
     case RED_WORKER_MESSAGE_ADD_MEMSLOT_ASYNC:
     case RED_WORKER_MESSAGE_ADD_MEMSLOT:
@@ -10139,7 +10139,7 @@ static void handle_dev_input(EventListener *listener, uint32_t events)
         RedCursorCmd *cursor_cmd;
         RedSurfaceCmd *surface_cmd;
 
-        red_printf("loadvm_commands");
+        red_log(2, "loadvm_commands");
         receive_data(worker->channel, &count, sizeof(uint32_t));
         while (count > 0) {
             receive_data(worker->channel, &ext, sizeof(QXLCommandExt));
@@ -10157,7 +10157,7 @@ static void handle_dev_input(EventListener *listener, uint32_t events)
                 red_process_surface(worker, surface_cmd, ext.group_id, TRUE);
                 break;
             default:
-                red_printf("unhandled loadvm command type (%d)", ext.cmd.type);
+                red_warn("unhandled loadvm command type (%d)", ext.cmd.type);
                 break;
             }
             count--;
@@ -10251,7 +10251,7 @@ void *red_worker_main(void *arg)
 {
     RedWorker worker;
 
-    red_printf("begin");
+    red_log(2, "begin");
     ASSERT(MAX_PIPE_SIZE > WIDE_CLIENT_ACK_WINDOW &&
            MAX_PIPE_SIZE > NARROW_CLIENT_ACK_WINDOW); //ensure wakeup by ack message
 
@@ -10316,7 +10316,7 @@ void *red_worker_main(void *arg)
         }
         red_push(&worker);
     }
-    red_printf("exit");
+    red_log(2, "exit");
     return 0;
 }
 
diff --git a/server/reds.c b/server/reds.c
index 8e83b99..ed6bd34 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -637,7 +637,7 @@ void reds_unregister_channel(Channel *channel)
         }
         now = &(*now)->next;
     }
-    red_printf("not found");
+    red_warn("not found");
 }
 
 static Channel *reds_find_channel(uint32_t type, uint32_t id)
@@ -732,7 +732,7 @@ static void reds_disconnect()
         return;
     }
 
-    red_printf("");
+    red_log(2, "");
     reds->disconnecting = TRUE;
     reds_reset_outgoing();
     /* Reset write filter to start with clean state on client reconnect */
@@ -801,7 +801,7 @@ static int handle_incoming(RedsStream *stream, IncomingHandler *handler)
             case EPIPE:
                 return -1;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 return -1;
             }
         } else {
@@ -819,7 +819,7 @@ static int handle_incoming(RedsStream *stream, IncomingHandler *handler)
                 parsed = handler->parser(data, data + header->size, header->type,
                                          SPICE_VERSION_MINOR, &parsed_size, &parsed_free);
                 if (parsed == NULL) {
-                    red_printf("failed to parse message type %d", header->type);
+                    red_warn("failed to parse message type %d", header->type);
                     return -1;
                 }
                 handler->handle_message(handler->opaque, parsed_size, header->type, parsed);
@@ -855,7 +855,7 @@ static int handle_outgoing(RedsStream *stream, OutgoingHandler *handler)
             case EPIPE:
                 return -1;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 return -1;
             }
         } else {
@@ -895,7 +895,7 @@ static int outgoing_write(RedsStream *stream, OutgoingHandler *handler, void *in
             case EPIPE:
                 return OUTGOING_FAILED;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 return OUTGOING_FAILED;
             }
         } else {
@@ -945,7 +945,7 @@ static void reds_send_channels()
     int i;
 
     if (reds->mig_target) {
-        red_printf("warning: unexpected SPICE_MSGC_MAIN_ATTACH_CHANNELS during migration");
+        red_warn("warning: unexpected SPICE_MSGC_MAIN_ATTACH_CHANNELS during migration");
         return;
     }
 
@@ -996,7 +996,7 @@ static int send_ping(int size)
 static void do_ping_client(const char *opt, int has_interval, int interval)
 {
     if (!reds->stream) {
-        red_printf("not connected to stream");
+        red_warn("not connected to stream");
         return;
     }
 
@@ -1017,7 +1017,7 @@ static void do_ping_client(const char *opt, int has_interval, int interval)
 static void ping_timer_cb()
 {
     if (!reds->stream) {
-        red_printf("not connected to stream, ping off");
+        red_warn("not connected to stream, ping off");
         core->timer_cancel(reds->ping_timer);
         return;
     }
@@ -1247,7 +1247,7 @@ static void dispatch_vdi_port_data(int port, VDIReadBuf *buf)
         break;
     default:
         ring_add(&state->read_bufs, &buf->link);
-        red_printf("invalid port");
+        red_warn("invalid port");
         reds_agent_remove();
     }
 }
@@ -1488,7 +1488,7 @@ static int main_channel_restore_vdi_read_state(MainMigrateData *data, uint8_t **
     switch (state->read_state) {
     case VDI_PORT_READ_STATE_READ_HADER:
         if (data->read_buf_len) {
-            red_printf("unexpected receive buf");
+            red_warn("unexpected receive buf");
             reds_disconnect();
             return FALSE;
         }
@@ -1496,13 +1496,13 @@ static int main_channel_restore_vdi_read_state(MainMigrateData *data, uint8_t **
         break;
     case VDI_PORT_READ_STATE_GET_BUFF:
         if (state->message_recive_len > state->vdi_chunk_header.size) {
-            red_printf("invalid message receive len");
+            red_warn("invalid message receive len");
             reds_disconnect();
             return FALSE;
         }
 
         if (data->read_buf_len) {
-            red_printf("unexpected receive buf");
+            red_warn("unexpected receive buf");
             reds_disconnect();
             return FALSE;
         }
@@ -1512,20 +1512,20 @@ static int main_channel_restore_vdi_read_state(MainMigrateData *data, uint8_t **
         uint32_t n;
 
         if (!data->read_buf_len) {
-            red_printf("read state and read_buf_len == 0");
+            red_warn("read state and read_buf_len == 0");
             reds_disconnect();
             return FALSE;
         }
 
         if (state->message_recive_len > state->vdi_chunk_header.size) {
-            red_printf("invalid message receive len");
+            red_warn("invalid message receive len");
             reds_disconnect();
             return FALSE;
         }
 
 
         if (!(ring_item = ring_get_head(&state->read_bufs))) {
-            red_printf("get read buf failed");
+            red_warn("get read buf failed");
             reds_disconnect();
             return FALSE;
         }
@@ -1535,7 +1535,7 @@ static int main_channel_restore_vdi_read_state(MainMigrateData *data, uint8_t **
         buff->len = data->read_buf_len;
         n = buff->len - state->recive_len;
         if (buff->len > SPICE_AGENT_MAX_DATA_SIZE || n > SPICE_AGENT_MAX_DATA_SIZE) {
-            red_printf("bad read position");
+            red_warn("bad read position");
             reds_disconnect();
             return FALSE;
         }
@@ -1545,7 +1545,7 @@ static int main_channel_restore_vdi_read_state(MainMigrateData *data, uint8_t **
         break;
     }
     default:
-        red_printf("invalid read state");
+        red_warn("invalid read state");
         reds_disconnect();
         return FALSE;
     }
@@ -1573,14 +1573,14 @@ static int main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *pos,
     inf_end = inf + data->write_queue_size;
     pos = (uint8_t *)inf_end;
     if (pos > end) {
-        red_printf("access violation");
+        red_warn("access violation");
         reds_disconnect();
         return FALSE;
     }
 
     for (; inf < inf_end; inf++) {
         if (pos + inf->len > end) {
-            red_printf("access violation");
+            red_warn("access violation");
             reds_disconnect();
             return FALSE;
         }
@@ -1588,7 +1588,7 @@ static int main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *pos,
             VDInternalBuf *buf;
 
             if (inf->len > sizeof(*buf) - SPICE_OFFSETOF(VDInternalBuf, header)) {
-                red_printf("bad buffer len");
+                red_warn("bad buffer len");
                 reds_disconnect();
                 return FALSE;
             }
@@ -1604,12 +1604,12 @@ static int main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *pos,
 
             state->num_tokens--;
             if (inf->len > sizeof(*buf) - SPICE_OFFSETOF(VDAgentExtBuf, buf)) {
-                red_printf("bad buffer len");
+                red_warn("bad buffer len");
                 reds_disconnect();
                 return FALSE;
             }
             if (!(ring_item = ring_get_head(&reds->agent_state.external_bufs))) {
-                red_printf("no external buff");
+                red_warn("no external buff");
                 reds_disconnect();
                 return FALSE;
             }
@@ -1620,7 +1620,7 @@ static int main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *pos,
             buf->base.write_len = inf->len;
             ring_add(&reds->agent_state.write_queue, &buf->base.link);
         } else {
-            red_printf("invalid data");
+            red_warn("invalid data");
             reds_disconnect();
             return FALSE;
         }
@@ -1635,7 +1635,7 @@ static void main_channel_recive_migrate_data(MainMigrateData *data, uint8_t *end
     uint8_t *pos;
 
     if (data->version != MAIN_CHANNEL_MIG_DATA_VERSION) {
-        red_printf("version mismatch");
+        red_warn("version mismatch");
         reds_disconnect();
         return;
     }
@@ -1684,7 +1684,7 @@ static void reds_main_handle_message(void *opaque, size_t size, uint32_t type, v
 
     switch (type) {
     case SPICE_MSGC_MAIN_AGENT_START:
-        red_printf("agent start");
+        red_log(2, "agent start");
         if (!reds->stream || !vdagent) {
             return;
         }
@@ -1695,7 +1695,7 @@ static void reds_main_handle_message(void *opaque, size_t size, uint32_t type, v
         VDAgentExtBuf *buf;
 
         if (!reds->agent_state.num_client_tokens) {
-            red_printf("token violation");
+            red_warn("token violation");
             reds_disconnect();
             break;
         }
@@ -1715,7 +1715,7 @@ static void reds_main_handle_message(void *opaque, size_t size, uint32_t type, v
         }
 
         if (!(ring_item = ring_get_head(&reds->agent_state.external_bufs))) {
-            red_printf("no agent free bufs");
+            red_warn("no agent free bufs");
             reds_disconnect();
             break;
         }
@@ -1735,14 +1735,14 @@ static void reds_main_handle_message(void *opaque, size_t size, uint32_t type, v
         reds_send_channels();
         break;
     case SPICE_MSGC_MAIN_MIGRATE_CONNECTED:
-        red_printf("client connected to migration target");
+        red_log(2, "client connected to migration target");
         if (reds->mig_wait_connect) {
             reds->mig_connect_ok = TRUE;
             reds_mig_cleanup();
         }
         break;
     case SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR:
-        red_printf("mig connect error");
+        red_log(2, "mig connect error");
         if (reds->mig_wait_connect) {
             reds->mig_connect_ok = FALSE;
             reds_mig_cleanup();
@@ -1754,14 +1754,14 @@ static void reds_main_handle_message(void *opaque, size_t size, uint32_t type, v
             if (reds->is_client_mouse_allowed) {
                 reds_set_mouse_mode(SPICE_MOUSE_MODE_CLIENT);
             } else {
-                red_printf("client mouse is disabled");
+                red_log(2, "client mouse is disabled");
             }
             break;
         case SPICE_MOUSE_MODE_SERVER:
             reds_set_mouse_mode(SPICE_MOUSE_MODE_SERVER);
             break;
         default:
-            red_printf("unsupported mouse mode");
+            red_warn("unsupported mouse mode");
         }
         break;
     }
@@ -1789,12 +1789,12 @@ static void reds_main_handle_message(void *opaque, size_t size, uint32_t type, v
                 if (roundtrip <= latency) {
                     // probably high load on client or server result with incorrect values
                     latency = 0;
-                    red_printf("net test: invalid values, latency %lu roundtrip %lu. assuming high"
-                               "bandwidth", latency, roundtrip);
+                    red_warn("net test: invalid values, latency %lu roundtrip %lu. assuming high"
+                             "bandwidth", latency, roundtrip);
                     break;
                 }
                 bitrate_per_sec = (uint64_t)(NET_TEST_BYTES * 8) * 1000000 / (roundtrip - latency);
-                red_printf("net test: latency %f ms, bitrate %lu bps (%f Mbps)%s",
+                red_log(2, "net test: latency %f ms, bitrate %lu bps (%f Mbps)%s",
                            (double)latency / 1000,
                            bitrate_per_sec,
                            (double)bitrate_per_sec / 1024 / 1024,
@@ -1802,10 +1802,10 @@ static void reds_main_handle_message(void *opaque, size_t size, uint32_t type, v
                 reds->net_test_stage = NET_TEST_STAGE_INVALID;
                 break;
             default:
-                red_printf("invalid net test stage, ping id %d test id %d stage %d",
-                           ping->id,
-                           reds->net_test_id,
-                           reds->net_test_stage);
+                red_warn("invalid net test stage, ping id %d test id %d stage %d",
+                         ping->id,
+                         reds->net_test_id,
+                         reds->net_test_stage);
             }
             break;
         }
@@ -1827,18 +1827,18 @@ static void reds_main_handle_message(void *opaque, size_t size, uint32_t type, v
         break;
     case SPICE_MSGC_MAIN_MIGRATE_END:
         if (!reds->mig_target) {
-            red_printf("unexpected SPICE_MSGC_MIGRATE_END, not target");
+            red_warn("unexpected SPICE_MSGC_MIGRATE_END, not target");
             return;
         }
         if (!reds->client_semi_mig_cap) {
-            red_printf("unexpected SPICE_MSGC_MIGRATE_END"
-                       ",client does not support semi-seamless migration");
+            red_warn("unexpected SPICE_MSGC_MIGRATE_END"
+                     ",client does not support semi-seamless migration");
             return;
         }
         reds_handle_client_migrate_complete();
         break;
     default:
-        red_printf("unexpected type %d", type);
+        red_warn("unexpected type %d", type);
     }
 }
 
@@ -1865,7 +1865,7 @@ static int reds_send_data()
                 reds_disconnect();
                 return FALSE;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 reds_disconnect();
                 return FALSE;
             }
@@ -2025,12 +2025,12 @@ static int reds_send_link_ack(RedLinkInfo *link)
     ack.caps_offset = sizeof(SpiceLinkReply);
 
     if (!(link->tiTicketing.rsa = RSA_new())) {
-        red_printf("RSA nes failed");
+        red_warn("RSA nes failed");
         return FALSE;
     }
 
     if (!(bio = BIO_new(BIO_s_mem()))) {
-        red_printf("BIO new failed");
+        red_warn("BIO new failed");
         return FALSE;
     }
 
@@ -2076,7 +2076,7 @@ static int reds_send_link_error(RedLinkInfo *link, uint32_t error)
 
 static void reds_show_new_channel(RedLinkInfo *link, int connection_id)
 {
-    red_printf("channel %d:%d, connected successfully, over %s link",
+    red_log(2, "channel %d:%d, connected successfully, over %s link",
                link->link_mess->channel_type,
                link->link_mess->channel_id,
                link->stream->ssl == NULL ? "Non Secure" : "Secure");
@@ -2153,7 +2153,7 @@ static void reds_handle_main_link(RedLinkInfo *link)
     uint32_t *channel_caps;
     uint32_t num_channel_caps;
 
-    red_printf("");
+    red_log(2, "");
 
     reds_disconnect();
 
@@ -2184,8 +2184,8 @@ static void reds_handle_main_link(RedLinkInfo *link)
                                       NULL;
     reds->client_semi_mig_cap = test_capability(channel_caps, num_channel_caps, SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
     if (reds->client_semi_mig_cap && (SPICE_VERSION_MAJOR == 2) && (reds->peer_minor_version < 1)) {
-        red_printf("warning: client claims to support semi seamless migration,"
-                   "but its version is incompatible");
+        red_warn("warning: client claims to support semi seamless migration,"
+                 "but its version is incompatible");
         reds->client_semi_mig_cap = FALSE;
     }
 
@@ -2323,7 +2323,7 @@ static void inputs_handle_input(void *opaque, size_t size, uint32_t type, void *
         if (++state->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0) {
             m = marshaller_new_for_outgoing(state, SPICE_MSG_INPUTS_MOUSE_MOTION_ACK);
             if (!marshaller_outgoing_write(m, state)) {
-                red_printf("motion ack failed");
+                red_warn("motion ack failed");
                 reds_disconnect();
             }
             spice_marshaller_destroy(m);
@@ -2343,7 +2343,7 @@ static void inputs_handle_input(void *opaque, size_t size, uint32_t type, void *
         if (++state->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0) {
             m = marshaller_new_for_outgoing(state, SPICE_MSG_INPUTS_MOUSE_MOTION_ACK);
             if (!marshaller_outgoing_write(m, state)) {
-                red_printf("position ack failed");
+                red_warn("position ack failed");
                 reds_disconnect();
             }
             spice_marshaller_destroy(m);
@@ -2443,7 +2443,7 @@ static void inputs_handle_input(void *opaque, size_t size, uint32_t type, void *
     case SPICE_MSGC_DISCONNECTING:
         break;
     default:
-        red_printf("unexpected type %d", type);
+        red_warn("unexpected type %d", type);
     }
 }
 
@@ -2517,7 +2517,7 @@ static void inputs_migrate(Channel *channel)
     spice_marshall_msg_migrate(m, &migrate);
 
     if (!marshaller_outgoing_write(m, state)) {
-        red_printf("write failed");
+        red_warn("write failed");
     }
     spice_marshaller_destroy(m);
 }
@@ -2526,8 +2526,8 @@ static void inputs_select(void *opaque, int select)
 {
     InputsState *inputs_state;
     int eventmask = SPICE_WATCH_EVENT_READ;
-    red_printf("");
 
+    red_log(2, "");
     inputs_state = (InputsState *)opaque;
     if (select) {
         eventmask |= SPICE_WATCH_EVENT_WRITE;
@@ -2537,7 +2537,7 @@ static void inputs_select(void *opaque, int select)
 
 static void inputs_may_write(void *opaque)
 {
-    red_printf("");
+    red_log(2, "");
 }
 
 static void inputs_link(Channel *channel, RedsStream *stream, int migration,
@@ -2548,19 +2548,19 @@ static void inputs_link(Channel *channel, RedsStream *stream, int migration,
     int delay_val;
     int flags;
 
-    red_printf("");
+    red_log(2, "");
     ASSERT(channel->data == NULL);
 
     inputs_state = spice_new0(InputsState, 1);
 
     delay_val = 1;
-    if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
-        red_printf("setsockopt failed, %s", strerror(errno));
+    if (setsockopt(stream->socket, IPPROTO_TCP,TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
+        red_warn("setsockopt failed, %s", strerror(errno));
     }
 
     if ((flags = fcntl(stream->socket, F_GETFL)) == -1 ||
                                             fcntl(stream->socket, F_SETFL, flags | O_ASYNC) == -1) {
-        red_printf("fcntl failed, %s", strerror(errno));
+        red_warn("fcntl failed, %s", strerror(errno));
     }
 
     inputs_state->stream = stream;
@@ -2584,7 +2584,7 @@ static void inputs_link(Channel *channel, RedsStream *stream, int migration,
     inputs_init.keyboard_modifiers = kbd_get_leds(keyboard);
     spice_marshall_msg_inputs_init(m, &inputs_init);
     if (!marshaller_outgoing_write(m, inputs_state)) {
-        red_printf("failed to send modifiers state");
+        red_warn("failed to send modifiers state");
         reds_disconnect();
     }
     spice_marshaller_destroy(m);
@@ -2608,7 +2608,7 @@ static void reds_send_keyboard_modifiers(uint8_t modifiers)
     spice_marshall_msg_inputs_key_modifiers(m, &key_modifiers);
 
     if (!marshaller_outgoing_write(m, state)) {
-        red_printf("failed to send modifiers state");
+        red_warn("failed to send modifiers state");
         reds_disconnect();
     }
     spice_marshaller_destroy(m);
@@ -2665,7 +2665,7 @@ static void reds_mig_pending_link_add(SpiceLinkMess *link_msg, RedsStream *strea
 
 static void reds_mig_pending_links_free(void)
 {
-    red_printf("");
+    red_log(2, "");
     while(reds->mig_pending_links) {
         RedsMigPendingLink *tmp = reds->mig_pending_links;
         reds->mig_pending_links = tmp->next;
@@ -2717,7 +2717,7 @@ static void reds_handle_client_migrate_complete(void)
 {
     RedsMigPendingLink *cur_link;
 
-    red_printf("");
+    red_log(2, "");
     // TODO: not doing net test. consider doing it on client_migrate_info
     reds_main_channel_init(FALSE);
 
@@ -2725,8 +2725,8 @@ static void reds_handle_client_migrate_complete(void)
         Channel *channel = reds_find_channel(cur_link->link_msg->channel_type,
                                              cur_link->link_msg->channel_id);
         if (!channel) {
-            red_printf("warning: channel (%d, %d) (type,id) wasn't found",
-                       cur_link->link_msg->channel_type, cur_link->link_msg->channel_id);
+            red_warn("warning: channel (%d, %d) (type,id) wasn't found",
+                     cur_link->link_msg->channel_type, cur_link->link_msg->channel_id);
             continue;
        }
        reds_channel_do_link(channel, cur_link->link_msg, cur_link->stream);
@@ -2804,8 +2804,8 @@ static void reds_handle_ticket(void *opaque)
 
         if (strlen(taTicket.password) == 0) {
             reds_send_link_result(link, SPICE_LINK_ERR_PERMISSION_DENIED);
-            red_printf("Ticketing is enabled, but no password is set. "
-                       "please set a ticket first");
+            red_warn("Ticketing is enabled, but no password is set. "
+                     "please set a ticket first");
             reds_link_free(link);
             return;
         }
@@ -2849,7 +2849,7 @@ ssize_t reds_stream_sasl_write(RedsStream *s, const void *buf, size_t nbyte)
                           (const char **)&s->sasl.encoded,
                           &s->sasl.encodedLength);
         if (err != SASL_OK) {
-            red_printf("sasl_encode error: %d", err);
+            red_warn("sasl_encode error: %d", err);
             return -1;
         }
 
@@ -2858,7 +2858,7 @@ ssize_t reds_stream_sasl_write(RedsStream *s, const void *buf, size_t nbyte)
         }
 
         if (!s->sasl.encoded) {
-            red_printf("sasl_encode didn't return a buffer!");
+            red_warn("sasl_encode didn't return a buffer!");
             return 0;
         }
 
@@ -2910,7 +2910,7 @@ static ssize_t reds_stream_sasl_read(RedsStream *s, void *buf, size_t nbyte)
                       (char *)encoded, n,
                       &decoded, &decodedlen);
     if (err != SASL_OK) {
-        red_printf("sasl_decode error: %d", err);
+        red_warn("sasl_decode error: %d", err);
         return -1;
     }
 
@@ -2992,8 +2992,8 @@ static char *addr_to_string(const char *format,
                            host, sizeof(host),
                            serv, sizeof(serv),
                            NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
-        red_printf("Cannot resolve address %d: %s",
-                   err, gai_strerror(err));
+        red_warn("Cannot resolve address %d: %s",
+                 err, gai_strerror(err));
         return NULL;
     }
 
@@ -3023,7 +3023,7 @@ static int auth_sasl_check_ssf(RedsSASL *sasl, int *runSSF)
     }
 
     ssf = *(const int *)val;
-    red_printf("negotiated an SSF of %d", ssf);
+    red_log(2, "negotiated an SSF of %d", ssf);
     if (ssf < 56) {
         return 0; /* 56 is good for Kerberos */
     }
@@ -3070,7 +3070,7 @@ static void reds_handle_auth_sasl_step(void *opaque)
         datalen--; /* Don't count NULL byte when passing to _start() */
     }
 
-    red_printf("Step using SASL Data %p (%d bytes)",
+    red_log(2, "Step using SASL Data %p (%d bytes)",
                clientdata, datalen);
     err = sasl_server_step(sasl->conn,
                            clientdata,
@@ -3079,18 +3079,18 @@ static void reds_handle_auth_sasl_step(void *opaque)
                            &serveroutlen);
     if (err != SASL_OK &&
         err != SASL_CONTINUE) {
-        red_printf("sasl step failed %d (%s)",
-                   err, sasl_errdetail(sasl->conn));
+        red_warn("sasl step failed %d (%s)",
+                 err, sasl_errdetail(sasl->conn));
         goto authabort;
     }
 
     if (serveroutlen > SASL_DATA_MAX_LEN) {
-        red_printf("sasl step reply data too long %d",
-                   serveroutlen);
+        red_warn("sasl step reply data too long %d",
+                 serveroutlen);
         goto authabort;
     }
 
-    red_printf("SASL return data %d bytes, %p", serveroutlen, serverout);
+    red_log(2, "SASL return data %d bytes, %p", serveroutlen, serverout);
 
     if (serveroutlen) {
         serveroutlen += 1;
@@ -3104,7 +3104,7 @@ static void reds_handle_auth_sasl_step(void *opaque)
     sync_write_u8(link->stream, err == SASL_CONTINUE ? 0 : 1);
 
     if (err == SASL_CONTINUE) {
-        red_printf("%s", "Authentication must continue (step)");
+        red_log(2, "%s", "Authentication must continue (step)");
         /* Wait for step length */
         obj->now = (uint8_t *)&sasl->len;
         obj->end = obj->now + sizeof(uint32_t);
@@ -3114,11 +3114,11 @@ static void reds_handle_auth_sasl_step(void *opaque)
         int ssf;
 
         if (auth_sasl_check_ssf(sasl, &ssf) == 0) {
-            red_printf("Authentication rejected for weak SSF");
+            red_warn("Authentication rejected for weak SSF");
             goto authreject;
         }
 
-        red_printf("Authentication successful");
+        red_log(2, "Authentication successful");
         sync_write_u32(link->stream, SPICE_LINK_ERR_OK); /* Accept auth */
 
         /*
@@ -3148,9 +3148,9 @@ static void reds_handle_auth_sasl_steplen(void *opaque)
     AsyncRead *obj = &link->asyc_read;
     RedsSASL *sasl = &link->stream->sasl;
 
-    red_printf("Got steplen %d", sasl->len);
+    red_log(2, "Got steplen %d", sasl->len);
     if (sasl->len > SASL_DATA_MAX_LEN) {
-        red_printf("Too much SASL data %d", sasl->len);
+        red_warn("Too much SASL data %d", sasl->len);
         reds_link_free(link);
         return;
     }
@@ -3200,7 +3200,7 @@ static void reds_handle_auth_sasl_start(void *opaque)
         datalen--; /* Don't count NULL byte when passing to _start() */
     }
 
-    red_printf("Start SASL auth with mechanism %s. Data %p (%d bytes)",
+    red_log(2, "Start SASL auth with mechanism %s. Data %p (%d bytes)",
               sasl->mechlist, clientdata, datalen);
     err = sasl_server_start(sasl->conn,
                             sasl->mechlist,
@@ -3210,18 +3210,18 @@ static void reds_handle_auth_sasl_start(void *opaque)
                             &serveroutlen);
     if (err != SASL_OK &&
         err != SASL_CONTINUE) {
-        red_printf("sasl start failed %d (%s)",
-                   err, sasl_errdetail(sasl->conn));
+        red_warn("sasl start failed %d (%s)",
+                 err, sasl_errdetail(sasl->conn));
         goto authabort;
     }
 
     if (serveroutlen > SASL_DATA_MAX_LEN) {
-        red_printf("sasl start reply data too long %d",
-                   serveroutlen);
+        red_warn("sasl start reply data too long %d",
+                 serveroutlen);
         goto authabort;
     }
 
-    red_printf("SASL return data %d bytes, %p", serveroutlen, serverout);
+    red_log(2, "SASL return data %d bytes, %p", serveroutlen, serverout);
 
     if (serveroutlen) {
         serveroutlen += 1;
@@ -3235,7 +3235,7 @@ static void reds_handle_auth_sasl_start(void *opaque)
     sync_write_u8(link->stream, err == SASL_CONTINUE ? 0 : 1);
 
     if (err == SASL_CONTINUE) {
-        red_printf("%s", "Authentication must continue (start)");
+        red_log(2, "%s", "Authentication must continue (start)");
         /* Wait for step length */
         obj->now = (uint8_t *)&sasl->len;
         obj->end = obj->now + sizeof(uint32_t);
@@ -3245,11 +3245,11 @@ static void reds_handle_auth_sasl_start(void *opaque)
         int ssf;
 
         if (auth_sasl_check_ssf(sasl, &ssf) == 0) {
-            red_printf("Authentication rejected for weak SSF");
+            red_warn("Authentication rejected for weak SSF");
             goto authreject;
         }
 
-        red_printf("Authentication successful");
+        red_log(2, "Authentication successful");
         sync_write_u32(link->stream, SPICE_LINK_ERR_OK); /* Accept auth */
 
         /*
@@ -3279,9 +3279,9 @@ static void reds_handle_auth_startlen(void *opaque)
     AsyncRead *obj = &link->asyc_read;
     RedsSASL *sasl = &link->stream->sasl;
 
-    red_printf("Got client start len %d", sasl->len);
+    red_log(2, "Got client start len %d", sasl->len);
     if (sasl->len > SASL_DATA_MAX_LEN) {
-        red_printf("Too much SASL data %d", sasl->len);
+        red_log(2, "Too much SASL data %d", sasl->len);
         reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
         reds_link_free(link);
         return;
@@ -3306,24 +3306,24 @@ static void reds_handle_auth_mechname(void *opaque)
     RedsSASL *sasl = &link->stream->sasl;
 
     sasl->mechname[sasl->len] = '\0';
-    red_printf("Got client mechname '%s' check against '%s'",
+    red_log(2, "Got client mechname '%s' check against '%s'",
                sasl->mechname, sasl->mechlist);
 
     if (strncmp(sasl->mechlist, sasl->mechname, sasl->len) == 0) {
         if (sasl->mechlist[sasl->len] != '\0' &&
             sasl->mechlist[sasl->len] != ',') {
-            red_printf("One %d", sasl->mechlist[sasl->len]);
+            red_log(2, "One %d", sasl->mechlist[sasl->len]);
             reds_link_free(link);
             return;
         }
     } else {
         char *offset = strstr(sasl->mechlist, sasl->mechname);
-        red_printf("Two %p", offset);
+        red_log(2, "Two %p", offset);
         if (!offset) {
             reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
             return;
         }
-        red_printf("Two '%s'", offset);
+        red_log(2, "Two '%s'", offset);
         if (offset[-1] != ',' ||
             (offset[sasl->len] != '\0'&&
              offset[sasl->len] != ',')) {
@@ -3335,7 +3335,7 @@ static void reds_handle_auth_mechname(void *opaque)
     free(sasl->mechlist);
     sasl->mechlist = strdup(sasl->mechname);
 
-    red_printf("Validated mechname '%s'", sasl->mechname);
+    red_log(2, "Validated mechname '%s'", sasl->mechname);
 
     obj->now = (uint8_t *)&sasl->len;
     obj->end = obj->now + sizeof(uint32_t);
@@ -3352,14 +3352,14 @@ static void reds_handle_auth_mechlen(void *opaque)
     RedsSASL *sasl = &link->stream->sasl;
 
     if (sasl->len < 1 || sasl->len > 100) {
-        red_printf("Got bad client mechname len %d", sasl->len);
+        red_log(2, "Got bad client mechname len %d", sasl->len);
         reds_link_free(link);
         return;
     }
 
     sasl->mechname = spice_malloc(sasl->len + 1);
 
-    red_printf("Wait for client mechname");
+    red_log(2, "Wait for client mechname");
     obj->now = (uint8_t *)sasl->mechname;
     obj->end = obj->now + sasl->len;
     obj->done = reds_handle_auth_mechname;
@@ -3399,8 +3399,8 @@ static void reds_start_auth_sasl(RedLinkInfo *link)
     localAddr = remoteAddr = NULL;
 
     if (err != SASL_OK) {
-        red_printf("sasl context setup failed %d (%s)",
-                   err, sasl_errstring(err, NULL, NULL));
+        red_warn("sasl context setup failed %d (%s)",
+                 err, sasl_errstring(err, NULL, NULL));
         sasl->conn = NULL;
         goto error;
     }
@@ -3412,8 +3412,8 @@ static void reds_start_auth_sasl(RedLinkInfo *link)
         ssf = SSL_get_cipher_bits(link->stream->ssl, NULL);
         err = sasl_setprop(sasl->conn, SASL_SSF_EXTERNAL, &ssf);
         if (err != SASL_OK) {
-            red_printf("cannot set SASL external SSF %d (%s)",
-                       err, sasl_errstring(err, NULL, NULL));
+            red_warn("cannot set SASL external SSF %d (%s)",
+                     err, sasl_errstring(err, NULL, NULL));
             sasl_dispose(&sasl->conn);
             sasl->conn = NULL;
             goto error;
@@ -3442,8 +3442,8 @@ static void reds_start_auth_sasl(RedLinkInfo *link)
 
     err = sasl_setprop(sasl->conn, SASL_SEC_PROPS, &secprops);
     if (err != SASL_OK) {
-        red_printf("cannot set SASL security props %d (%s)",
-                   err, sasl_errstring(err, NULL, NULL));
+        red_warn("cannot set SASL security props %d (%s)",
+                 err, sasl_errstring(err, NULL, NULL));
         sasl_dispose(&sasl->conn);
         sasl->conn = NULL;
         goto error;
@@ -3458,24 +3458,24 @@ static void reds_start_auth_sasl(RedLinkInfo *link)
                         NULL,
                         NULL);
     if (err != SASL_OK) {
-        red_printf("cannot list SASL mechanisms %d (%s)",
-                   err, sasl_errdetail(sasl->conn));
+        red_warn("cannot list SASL mechanisms %d (%s)",
+                 err, sasl_errdetail(sasl->conn));
         sasl_dispose(&sasl->conn);
         sasl->conn = NULL;
         goto error;
     }
-    red_printf("Available mechanisms for client: '%s'", mechlist);
+    red_log(2, "Available mechanisms for client: '%s'", mechlist);
 
     sasl->mechlist = strdup(mechlist);
 
     mechlistlen = strlen(mechlist);
     if (!sync_write(link->stream, &mechlistlen, sizeof(uint32_t))
         || !sync_write(link->stream, sasl->mechlist, mechlistlen)) {
-        red_printf("SASL mechanisms write error");
+        red_warn("SASL mechanisms write error");
         goto error;
     }
 
-    red_printf("Wait for client mechname length");
+    red_log(2, "Wait for client mechname length");
     obj->now = (uint8_t *)&sasl->len;
     obj->end = obj->now + sizeof(uint32_t);
     obj->done = reds_handle_auth_mechlen;
@@ -3493,7 +3493,7 @@ static void reds_handle_auth_mechanism(void *opaque)
 {
     RedLinkInfo *link = (RedLinkInfo *)opaque;
 
-    red_printf("Auth method: %d", link->auth_mechanism.auth_mechanism);
+    red_log(2, "Auth method: %d", link->auth_mechanism.auth_mechanism);
 
     if (link->auth_mechanism.auth_mechanism == SPICE_COMMON_CAP_AUTH_SPICE
         && !sasl_enabled
@@ -3501,13 +3501,13 @@ static void reds_handle_auth_mechanism(void *opaque)
         reds_get_spice_ticket(link);
 #if HAVE_SASL
     } else if (link->auth_mechanism.auth_mechanism == SPICE_COMMON_CAP_AUTH_SASL) {
-        red_printf("Starting SASL");
+        red_log(2, "Starting SASL");
         reds_start_auth_sasl(link);
 #endif
     } else {
-        red_printf("Unknown auth method, disconnecting");
+        red_warn("Unknown auth method, disconnecting");
         if (sasl_enabled) {
-            red_printf("Your client doesn't handle SASL?");
+            red_warn("Your client doesn't handle SASL?");
         }
         reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
         reds_link_free(link);
@@ -3544,10 +3544,10 @@ static void reds_handle_read_link_done(void *opaque)
 
     if (!reds_security_check(link)) {
         if (link->stream->ssl) {
-            red_printf("spice channels %d should not be encrypted", link_mess->channel_type);
+            red_warn("spice channels %d should not be encrypted", link_mess->channel_type);
             reds_send_link_error(link, SPICE_LINK_ERR_NEED_UNSECURED);
         } else {
-            red_printf("spice channels %d should be encrypted", link_mess->channel_type);
+            red_warn("spice channels %d should be encrypted", link_mess->channel_type);
             reds_send_link_error(link, SPICE_LINK_ERR_NEED_SECURED);
         }
         reds_link_free(link);
@@ -3561,11 +3561,11 @@ static void reds_handle_read_link_done(void *opaque)
 
     if (!auth_selection) {
         if (sasl_enabled) {
-            red_printf("SASL enabled, but peer supports only spice authentication");
+            red_warn("SASL enabled, but peer supports only spice authentication");
             reds_send_link_error(link, SPICE_LINK_ERR_VERSION_MISMATCH);
             return;
         }
-        red_printf("Peer doesn't support AUTH selection");
+        red_warn("Peer doesn't support AUTH selection");
         reds_get_spice_ticket(link);
     } else {
         obj->now = (uint8_t *)&link->auth_mechanism;
@@ -3583,7 +3583,7 @@ static void reds_handle_link_error(void *opaque, int err)
     case EPIPE:
         break;
     default:
-        red_printf("%s", strerror(errno));
+        red_warn("%s", strerror(errno));
         break;
     }
     reds_link_free(link);
@@ -3606,7 +3606,7 @@ static void reds_handle_read_header_done(void *opaque)
             reds_send_link_error(link, SPICE_LINK_ERR_VERSION_MISMATCH);
         }
 
-        red_printf("version mismatch");
+        red_warn("version mismatch");
         reds_link_free(link);
         return;
     }
@@ -3615,7 +3615,7 @@ static void reds_handle_read_header_done(void *opaque)
 
     if (header->size < sizeof(SpiceLinkMess)) {
         reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
-        red_printf("bad size %u", header->size);
+        red_warn("bad size %u", header->size);
         reds_link_free(link);
         return;
     }
@@ -3648,7 +3648,7 @@ static void reds_handle_ssl_accept(int fd, int event, void *data)
     if ((return_code = SSL_accept(link->stream->ssl)) != 1) {
         int ssl_error = SSL_get_error(link->stream->ssl, return_code);
         if (ssl_error != SSL_ERROR_WANT_READ && ssl_error != SSL_ERROR_WANT_WRITE) {
-            red_printf("SSL_accept failed, error=%d", ssl_error);
+            red_warn("SSL_accept failed, error=%d", ssl_error);
             reds_link_free(link);
         } else {
             if (ssl_error == SSL_ERROR_WANT_READ) {
@@ -3672,22 +3672,22 @@ static RedLinkInfo *__reds_accept_connection(int listen_socket)
     int socket;
 
     if ((socket = accept(listen_socket, NULL, 0)) == -1) {
-        red_printf("accept failed, %s", strerror(errno));
+        red_warn("accept failed, %s", strerror(errno));
         return NULL;
     }
 
     if ((flags = fcntl(socket, F_GETFL)) == -1) {
-        red_printf("accept failed, %s", strerror(errno));
+        red_warn("accept failed, %s", strerror(errno));
         goto error;
     }
 
     if (fcntl(socket, F_SETFL, flags | O_NONBLOCK) == -1) {
-        red_printf("accept failed, %s", strerror(errno));
+        red_warn("accept failed, %s", strerror(errno));
         goto error;
     }
 
     if (setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
-        red_printf("setsockopt failed, %s", strerror(errno));
+        red_warn("setsockopt failed, %s", strerror(errno));
     }
 
     link = spice_new0(RedLinkInfo, 1);
@@ -3743,13 +3743,13 @@ static void reds_accept_ssl_connection(int fd, int event, void *data)
 
     // Handle SSL handshaking
     if (!(sbio = BIO_new_socket(link->stream->socket, BIO_NOCLOSE))) {
-        red_printf("could not allocate ssl bio socket");
+        red_warn("could not allocate ssl bio socket");
         goto error;
     }
 
     link->stream->ssl = SSL_new(reds->ctx);
     if (!link->stream->ssl) {
-        red_printf("could not allocate ssl context");
+        red_warn("could not allocate ssl context");
         BIO_free(sbio);
         goto error;
     }
@@ -3777,7 +3777,7 @@ static void reds_accept_ssl_connection(int fd, int event, void *data)
     }
 
     ERR_print_errors_fp(stderr);
-    red_printf("SSL_accept failed, error=%d", ssl_error);
+    red_warn("SSL_accept failed, error=%d", ssl_error);
     SSL_free(link->stream->ssl);
 
 error:
@@ -3793,7 +3793,7 @@ static void reds_accept(int fd, int event, void *data)
 
     link = reds_accept_connection(reds->listen_socket);
     if (link == NULL) {
-        red_printf("accept failed");
+        red_warn("accept failed");
         return;
     }
     reds_handle_new_link(link);
@@ -3842,8 +3842,8 @@ static int reds_init_socket(const char *addr, int portnr, int family)
         }
         close(slisten);
     }
-    red_printf("%s: binding socket to %s:%d failed", __FUNCTION__,
-               addr, portnr);
+    red_warn("%s: binding socket to %s:%d failed", __FUNCTION__,
+             addr, portnr);
     freeaddrinfo(res);
     return -1;
 
@@ -4070,7 +4070,7 @@ enum {
 static inline void on_activating_ticketing()
 {
     if (!ticketing_enabled && reds->stream) {
-        red_printf("disconnecting");
+        red_warn("disconnecting");
         reds_disconnect();
     }
 }
@@ -4134,7 +4134,7 @@ static void reds_mig_connect(void)
     SpiceMsgMainMigrationBegin migrate;
     RedsOutItem *item;
 
-    red_printf("");
+    red_log(2, "");
     ASSERT(reds->client_semi_mig_cap);
     item = new_out_item(SPICE_MSG_MAIN_MIGRATE_BEGIN);
 
@@ -4185,7 +4185,7 @@ static void reds_mig_started(void)
 {
     SpiceMigrateInterface *sif = NULL;
 
-    red_printf("");
+    red_log(2, "");
     ASSERT(reds->mig_spice);
 
     if (!migration_interface) {
@@ -4197,7 +4197,7 @@ static void reds_mig_started(void)
     reds->mig_connect_ok = FALSE;
 
     if (reds->stream == NULL) {
-        red_printf("not connected to stream");
+        red_warn("not connected to stream");
         reds_mig_release();
         sif->migrate_connect_complete(migration_interface);
         return;
@@ -4207,7 +4207,7 @@ static void reds_mig_started(void)
     if (reds->client_semi_mig_cap) {
         reds->mig_inprogress = TRUE;
         if (reds->mig_target) {
-            red_printf("previous spice migration hasn't completed yet. Waiting for client");
+            red_log(2, "previous spice migration hasn't completed yet. Waiting for client");
             reds->mig_wait_prev_complete = TRUE;
             core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
         } else {
@@ -4225,10 +4225,10 @@ static void reds_mig_finished(int completed)
 {
     RedsOutItem *item;
 
-    red_printf("");
+    red_log(2, "");
     reds_mig_release();
     if (reds->stream == NULL) {
-        red_printf("no stream connected");
+        red_warn("no stream connected");
         return;
     }
     reds->mig_inprogress = TRUE;
@@ -4267,12 +4267,12 @@ static void reds_mig_switch(void)
     RedsOutItem *item;
 
     if (s == NULL) {
-        red_printf("warning: migration target was not set. disconnecting client");
+        red_warn("warning: migration target was not set. disconnecting client");
         reds_disconnect();
         return;
     }
 
-    red_printf("");
+    red_log(2, "");
     item = new_out_item(SPICE_MSG_MAIN_MIGRATE_SWITCH_HOST);
 
     migrate.port = s->port;
@@ -4295,7 +4295,7 @@ static void reds_mig_switch(void)
 
 static void migrate_timeout(void *opaque)
 {
-    red_printf("");
+    red_log(2, "");
     ASSERT(reds->mig_wait_connect || reds->mig_wait_disconnect || reds->mig_wait_prev_complete);
     if (reds->mig_wait_connect) {
         reds->mig_connect_ok = FALSE;
@@ -4401,10 +4401,10 @@ static int spice_server_char_device_add_interface(SpiceServer *s,
     SpiceCharDeviceInstance* char_device =
             SPICE_CONTAINEROF(sin, SpiceCharDeviceInstance, base);
 
-    red_printf("CHAR_DEVICE %s", char_device->subtype);
+    red_log(2, "CHAR_DEVICE %s", char_device->subtype);
     if (strcmp(char_device->subtype, SUBTYPE_VDAGENT) == 0) {
         if (vdagent) {
-            red_printf("vdagent already attached");
+            red_warn("vdagent already attached");
             return -1;
         }
         char_device->st = &vdagent_char_device_state;
@@ -4425,7 +4425,7 @@ static void spice_server_char_device_remove_interface(SpiceBaseInstance *sin)
     SpiceCharDeviceInstance* char_device =
             SPICE_CONTAINEROF(sin, SpiceCharDeviceInstance, base);
 
-    red_printf("remove CHAR_DEVICE %s", char_device->subtype);
+    red_log(2, "remove CHAR_DEVICE %s", char_device->subtype);
     if (strcmp(char_device->subtype, SUBTYPE_VDAGENT) == 0) {
         if (vdagent) {
             reds_agent_remove();
@@ -4446,28 +4446,28 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
     ASSERT(reds == s);
 
     if (strcmp(interface->type, SPICE_INTERFACE_KEYBOARD) == 0) {
-        red_printf("SPICE_INTERFACE_KEYBOARD");
+        red_log(2, "SPICE_INTERFACE_KEYBOARD");
         if (keyboard) {
-            red_printf("already have keyboard");
+            red_warn("already have keyboard");
             return -1;
         }
         if (interface->major_version != SPICE_INTERFACE_KEYBOARD_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_KEYBOARD_MINOR) {
-            red_printf("unsupported keyboard interface");
+            red_warn("unsupported keyboard interface");
             return -1;
         }
         keyboard = SPICE_CONTAINEROF(sin, SpiceKbdInstance, base);
         keyboard->st = spice_new0(SpiceKbdState, 1);
 
     } else if (strcmp(interface->type, SPICE_INTERFACE_MOUSE) == 0) {
-        red_printf("SPICE_INTERFACE_MOUSE");
+        red_log(2, "SPICE_INTERFACE_MOUSE");
         if (mouse) {
-            red_printf("already have mouse");
+            red_warn("already have mouse");
             return -1;
         }
         if (interface->major_version != SPICE_INTERFACE_MOUSE_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_MOUSE_MINOR) {
-            red_printf("unsupported mouse interface");
+            red_warn("unsupported mouse interface");
             return -1;
         }
         mouse = SPICE_CONTAINEROF(sin, SpiceMouseInstance, base);
@@ -4476,10 +4476,10 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
     } else if (strcmp(interface->type, SPICE_INTERFACE_QXL) == 0) {
         QXLInstance *qxl;
 
-        red_printf("SPICE_INTERFACE_QXL");
+        red_log(2, "SPICE_INTERFACE_QXL");
         if (interface->major_version != SPICE_INTERFACE_QXL_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_QXL_MINOR) {
-            red_printf("unsupported qxl interface");
+            red_warn("unsupported qxl interface");
             return -1;
         }
 
@@ -4489,14 +4489,14 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
         qxl->st->dispatcher = red_dispatcher_init(qxl);
 
     } else if (strcmp(interface->type, SPICE_INTERFACE_TABLET) == 0) {
-        red_printf("SPICE_INTERFACE_TABLET");
+        red_log(2, "SPICE_INTERFACE_TABLET");
         if (tablet) {
-            red_printf("already have tablet");
+            red_warn("already have tablet");
             return -1;
         }
         if (interface->major_version != SPICE_INTERFACE_TABLET_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_TABLET_MINOR) {
-            red_printf("unsupported tablet interface");
+            red_warn("unsupported tablet interface");
             return -1;
         }
         tablet = SPICE_CONTAINEROF(sin, SpiceTabletInstance, base);
@@ -4510,19 +4510,19 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
         }
 
     } else if (strcmp(interface->type, SPICE_INTERFACE_PLAYBACK) == 0) {
-        red_printf("SPICE_INTERFACE_PLAYBACK");
+        red_log(2, "SPICE_INTERFACE_PLAYBACK");
         if (interface->major_version != SPICE_INTERFACE_PLAYBACK_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_PLAYBACK_MINOR) {
-            red_printf("unsupported playback interface");
+            red_warn("unsupported playback interface");
             return -1;
         }
         snd_attach_playback(SPICE_CONTAINEROF(sin, SpicePlaybackInstance, base));
 
     } else if (strcmp(interface->type, SPICE_INTERFACE_RECORD) == 0) {
-        red_printf("SPICE_INTERFACE_RECORD");
+        red_log(2, "SPICE_INTERFACE_RECORD");
         if (interface->major_version != SPICE_INTERFACE_RECORD_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_RECORD_MINOR) {
-            red_printf("unsupported record interface");
+            red_warn("unsupported record interface");
             return -1;
         }
         snd_attach_record(SPICE_CONTAINEROF(sin, SpiceRecordInstance, base));
@@ -4530,7 +4530,7 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
     } else if (strcmp(interface->type, SPICE_INTERFACE_CHAR_DEVICE) == 0) {
         if (interface->major_version != SPICE_INTERFACE_CHAR_DEVICE_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_CHAR_DEVICE_MINOR) {
-            red_printf("unsupported char device interface");
+            red_warn("unsupported char device interface");
             return -1;
         }
         spice_server_char_device_add_interface(s, sin);
@@ -4538,33 +4538,33 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
     } else if (strcmp(interface->type, SPICE_INTERFACE_NET_WIRE) == 0) {
 #ifdef USE_TUNNEL
         SpiceNetWireInstance *net;
-        red_printf("SPICE_INTERFACE_NET_WIRE");
+        red_log(2, "SPICE_INTERFACE_NET_WIRE");
         if (red_tunnel) {
-            red_printf("net wire already attached");
+            red_warn("net wire already attached");
             return -1;
         }
         if (interface->major_version != SPICE_INTERFACE_NET_WIRE_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_NET_WIRE_MINOR) {
-            red_printf("unsupported net wire interface");
+            red_warn("unsupported net wire interface");
             return -1;
         }
         net = SPICE_CONTAINEROF(sin, SpiceNetWireInstance, base);
         net->st = spice_new0(SpiceNetWireState, 1);
         red_tunnel = red_tunnel_attach(core, net);
 #else
-        red_printf("unsupported net wire interface");
+        red_warn("unsupported net wire interface");
         return -1;
 #endif
     } else if (strcmp(interface->type, SPICE_INTERFACE_MIGRATION) == 0) {
-        red_printf("SPICE_INTERFACE_MIGRATION");
+        red_log(2, "SPICE_INTERFACE_MIGRATION");
         if (migration_interface) {
-            red_printf("already have migration");
+            red_warn("already have migration");
             return -1;
         }
 
         if (interface->major_version != SPICE_INTERFACE_MIGRATION_MAJOR ||
             interface->minor_version > SPICE_INTERFACE_MIGRATION_MINOR) {
-            red_printf("unsupported migration interface");
+            red_warn("unsupported migration interface");
             return -1;
         }
         migration_interface = SPICE_CONTAINEROF(sin, SpiceMigrateInstance, base);
@@ -4579,18 +4579,18 @@ SPICE_GNUC_VISIBLE int spice_server_remove_interface(SpiceBaseInstance *sin)
     const SpiceBaseInterface *interface = sin->sif;
 
     if (strcmp(interface->type, SPICE_INTERFACE_TABLET) == 0) {
-        red_printf("remove SPICE_INTERFACE_TABLET");
+        red_log(2, "remove SPICE_INTERFACE_TABLET");
         if (sin == &tablet->base) {
             tablet = NULL;
             reds_update_mouse_mode();
         }
 
     } else if (strcmp(interface->type, SPICE_INTERFACE_PLAYBACK) == 0) {
-        red_printf("remove SPICE_INTERFACE_PLAYBACK");
+        red_log(2, "remove SPICE_INTERFACE_PLAYBACK");
         snd_detach_playback(SPICE_CONTAINEROF(sin, SpicePlaybackInstance, base));
 
     } else if (strcmp(interface->type, SPICE_INTERFACE_RECORD) == 0) {
-        red_printf("remove SPICE_INTERFACE_RECORD");
+        red_log(2, "remove SPICE_INTERFACE_RECORD");
         snd_detach_record(SPICE_CONTAINEROF(sin, SpiceRecordInstance, base));
 
     } else if (strcmp(interface->type, SPICE_INTERFACE_CHAR_DEVICE) == 0) {
@@ -4669,10 +4669,10 @@ const char *version_string = VERSION;
 
 static int do_spice_init(SpiceCoreInterface *core_interface)
 {
-    red_printf("starting %s", version_string);
+    red_log(2, "starting %s", version_string);
 
     if (core_interface->base.major_version != SPICE_INTERFACE_CORE_MAJOR) {
-        red_printf("bad core interface version");
+        red_warn("bad core interface version");
         goto err;
     }
     core = core_interface;
@@ -4950,7 +4950,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_jpeg_compression(SpiceServer *s, spice_w
 {
     ASSERT(reds == s);
     if (comp == SPICE_WAN_COMPRESSION_INVALID) {
-        red_printf("invalid jpeg state");
+        red_warn("invalid jpeg state");
         return -1;
     }
     // todo: support dynamically changing the state
@@ -4962,7 +4962,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_zlib_glz_compression(SpiceServer *s, spi
 {
     ASSERT(reds == s);
     if (comp == SPICE_WAN_COMPRESSION_INVALID) {
-        red_printf("invalid zlib_glz state");
+        red_warn("invalid zlib_glz state");
         return -1;
     }
     // todo: support dynamically changing the state
@@ -5110,12 +5110,12 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_connect(SpiceServer *s, const char*
                                                     int port, int secure_port,
                                                     const char* cert_subject)
 {
-    red_printf("");
+    red_log(2, "");
     ASSERT(migration_interface);
     ASSERT(reds == s);
 
     if (reds->expect_migrate && reds->client_semi_mig_cap) {
-        red_printf("warning: consecutive calls without migration. Canceling previous call");
+        red_warn("warning: consecutive calls without migration. Canceling previous call");
         reds_mig_finished(FALSE);
     }
 
@@ -5134,7 +5134,7 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_info(SpiceServer *s, const char* des
                                           int port, int secure_port,
                                           const char* cert_subject)
 {
-    red_printf("");
+    red_log(2, "");
     ASSERT(!migration_interface);
     ASSERT(reds == s);
 
@@ -5147,7 +5147,7 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_info(SpiceServer *s, const char* des
 SPICE_GNUC_VISIBLE int spice_server_migrate_start(SpiceServer *s)
 {
     ASSERT(reds == s);
-    red_printf("");
+    red_log(2, "");
     if (!reds->mig_spice) {
         return -1;
     }
@@ -5173,7 +5173,7 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_end(SpiceServer *s, int completed)
     SpiceMigrateInterface *sif;
     int ret = 0;
 
-    red_printf("completed=%d", completed);
+    red_log(2, "completed=%d", completed);
     ASSERT(migration_interface);
     ASSERT(reds == s);
 
@@ -5186,7 +5186,7 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_end(SpiceServer *s, int completed)
     }
 
     if (!reds->expect_migrate) {
-        red_printf("spice_server_migrate_info failed or was not called, disconnecting client");
+        red_warn("spice_server_migrate_info failed or was not called, disconnecting client");
         reds_disconnect("");
         ret = -1;
         goto complete;
@@ -5211,7 +5211,7 @@ complete:
 SPICE_GNUC_VISIBLE int spice_server_migrate_switch(SpiceServer *s)
 {
     ASSERT(reds == s);
-    red_printf("");
+    red_log(2, "");
     if (!reds->stream) {
        return 0;
     }
diff --git a/server/smartcard.c b/server/smartcard.c
index 58c58c6..43ddfc0 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -133,7 +133,7 @@ void smartcard_char_device_on_message_from_device(
     }
     /* We pass any VSC_Error right now - might need to ignore some? */
     if (state->reader_id == VSCARD_UNDEFINED_READER_ID && vheader->type != VSC_Init) {
-        red_printf("error: reader_id not assigned for message of type %d", vheader->type);
+        red_warn("warning: reader_id not assigned for message of type %d", vheader->type);
     }
     ASSERT(g_smartcard_channel != NULL);
     sent_header = spice_memdup(vheader, sizeof(*vheader) + vheader->length);
@@ -265,14 +265,14 @@ static int smartcard_channel_config_socket(RedChannel *channel)
 
 static uint8_t *smartcard_channel_alloc_msg_rcv_buf(RedChannel *channel, SpiceDataHeader *msg_header)
 {
-    //red_printf("allocing %d bytes", msg_header->size);
+    red_log(2, "allocing %d bytes", msg_header->size);
     return spice_malloc(msg_header->size);
 }
 
 static void smartcard_channel_release_msg_rcv_buf(RedChannel *channel, SpiceDataHeader *msg_header,
                                                uint8_t *msg)
 {
-    red_printf("freeing %d bytes", msg_header->size);
+    red_log(2, "freeing %d bytes", msg_header->size);
     free(msg);
 }
 
@@ -458,13 +458,13 @@ static int smartcard_channel_handle_message(RedChannel *channel, SpiceDataHeader
         case VSC_APDU:
             break; // passed on to device
         default:
-            printf("ERROR: unexpected message on smartcard channel\n");
+            red_warn("unexpected message on smartcard channel\n");
             return TRUE;
     }
 
     if (vheader->reader_id >= g_smartcard_readers.num) {
-        red_printf("ERROR: received message for non existent reader: %d, %d, %d", vheader->reader_id,
-            vheader->type, vheader->length);
+        red_warn("received message for non existent reader: %d, %d, %d", vheader->reader_id,
+                 vheader->type, vheader->length);
         return FALSE;
     }
     smartcard_channel_write_to_reader(smartcard_channel, vheader);
@@ -512,7 +512,7 @@ static void smartcard_register_channel(void)
     if (registered) {
         return;
     }
-    red_printf("registering smartcard channel");
+    red_log(2, "registering smartcard channel");
     registered = 1;
     channel = spice_new0(Channel, 1);
     channel->type = SPICE_CHANNEL_SMARTCARD;
diff --git a/server/snd_worker.c b/server/snd_worker.c
index f88cf3a..f79fcf5 100644
--- a/server/snd_worker.c
+++ b/server/snd_worker.c
@@ -257,7 +257,7 @@ static int snd_send_data(SndChannel *channel)
                 snd_disconnect_channel(channel);
                 return FALSE;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 snd_disconnect_channel(channel);
                 return FALSE;
             }
@@ -288,7 +288,7 @@ static int snd_record_handle_write(RecordChannel *record_channel, size_t size, v
         int celt_err = celt051_decode(record_channel->celt_decoder, packet->data, size,
                                       (celt_int16_t *)record_channel->celt_buf);
         if (celt_err != CELT_OK) {
-            red_printf("celt decode failed (%d)", celt_err);
+            red_warn("celt decode failed (%d)", celt_err);
             return FALSE;
         }
         data = record_channel->celt_buf;
@@ -328,7 +328,7 @@ static int snd_playback_handle_message(SndChannel *channel, size_t size, uint32_
     case SPICE_MSGC_DISCONNECTING:
         break;
     default:
-        red_printf("invalid message type %u", type);
+        red_warn("invalid message type %u", type);
         return FALSE;
     }
     return TRUE;
@@ -350,7 +350,7 @@ static int snd_record_handle_message(SndChannel *channel, size_t size, uint32_t
         record_channel->mode_time = mode->time;
         if (record_channel->mode != SPICE_AUDIO_DATA_MODE_CELT_0_5_1 &&
                                                   record_channel->mode != SPICE_AUDIO_DATA_MODE_RAW) {
-            red_printf("unsupported mode");
+            red_warn("unsupported mode");
         }
         break;
     }
@@ -364,7 +364,7 @@ static int snd_record_handle_message(SndChannel *channel, size_t size, uint32_t
     case SPICE_MSGC_MIGRATE_DATA: {
         RecordMigrateData* mig_data = (RecordMigrateData *)message;
         if (mig_data->version != RECORD_MIG_VERSION) {
-            red_printf("invalid mig version");
+            red_warn("invalid mig version");
             break;
         }
         record_channel->mode = mig_data->mode;
@@ -373,7 +373,7 @@ static int snd_record_handle_message(SndChannel *channel, size_t size, uint32_t
         break;
     }
     default:
-        red_printf("invalid message type %u", type);
+        red_warn("invalid message type %u", type);
         return FALSE;
     }
     return TRUE;
@@ -406,7 +406,7 @@ static void snd_receive(void* data)
                 snd_disconnect_channel(channel);
                 return;
             default:
-                red_printf("%s", strerror(errno));
+                red_warn("%s", strerror(errno));
                 snd_disconnect_channel(channel);
                 return;
             }
@@ -426,7 +426,7 @@ static void snd_receive(void* data)
                 parsed = channel->parser((void *)data, data + header->size, header->type,
                                          SPICE_VERSION_MINOR, &parsed_size, &parsed_free);
                 if (parsed == NULL) {
-                    red_printf("failed to parse message type %d", header->type);
+                    red_warn("failed to parse message type %d", header->type);
                     snd_disconnect_channel(channel);
                     return;
                 }
@@ -640,7 +640,7 @@ static int snd_playback_send_write(PlaybackChannel *playback_channel)
         int n = celt051_encode(playback_channel->celt_encoder, (celt_int16_t *)frame->samples, NULL,
                                playback_channel->send_data.celt_buf, CELT_COMPRESSED_FRAME_BYTES);
         if (n < 0) {
-            red_printf("celt encode failed");
+            red_warn("celt encode failed");
             snd_disconnect_channel(channel);
             return FALSE;
         }
@@ -691,7 +691,7 @@ static void snd_playback_send(void* data)
             playback_channel->pending_frame = NULL;
             channel->command &= ~SND_PLAYBACK_PCM_MASK;
             if (!snd_playback_send_write(playback_channel)) {
-                red_printf("snd_send_playback_write failed");
+                red_warn("snd_send_playback_write failed");
                 return;
             }
         }
@@ -749,28 +749,28 @@ static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_i
     int tos;
 
     if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
-        red_printf("accept failed, %s", strerror(errno));
+        red_warn("accept failed, %s", strerror(errno));
         goto error1;
     }
 
     priority = 6;
     if (setsockopt(stream->socket, SOL_SOCKET, SO_PRIORITY, (void*)&priority,
                    sizeof(priority)) == -1) {
-        red_printf("setsockopt failed, %s", strerror(errno));
+        red_warn("setsockopt failed, %s", strerror(errno));
     }
 
     tos = IPTOS_LOWDELAY;
     if (setsockopt(stream->socket, IPPROTO_IP, IP_TOS, (void*)&tos, sizeof(tos)) == -1) {
-        red_printf("setsockopt failed, %s", strerror(errno));
+        red_warn("setsockopt failed, %s", strerror(errno));
     }
 
     delay_val = IS_LOW_BANDWIDTH() ? 0 : 1;
     if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
-        red_printf("setsockopt failed, %s", strerror(errno));
+        red_warn("setsockopt failed, %s", strerror(errno));
     }
 
     if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
-        red_printf("accept failed, %s", strerror(errno));
+        red_warn("accept failed, %s", strerror(errno));
         goto error1;
     }
 
@@ -787,7 +787,7 @@ static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_i
     stream->watch = core->watch_add(stream->socket, SPICE_WATCH_EVENT_READ,
                                   snd_event, channel);
     if (stream->watch == NULL) {
-        red_printf("watch_add failed, %s", strerror(errno));
+        red_warn("watch_add failed, %s", strerror(errno));
         goto error2;
     }
 
@@ -949,12 +949,12 @@ static void snd_set_playback_peer(Channel *channel, RedsStream *stream, int migr
     if (!(celt_mode = celt051_mode_create(SPICE_INTERFACE_PLAYBACK_FREQ,
                                           SPICE_INTERFACE_PLAYBACK_CHAN,
                                           FRAME_SIZE, &celt_error))) {
-        red_printf("create celt mode failed %d", celt_error);
+        red_warn("create celt mode failed %d", celt_error);
         return;
     }
 
     if (!(celt_encoder = celt051_encoder_create(celt_mode))) {
-        red_printf("create celt encoder failed");
+        red_warn("create celt encoder failed");
         goto error_1;
     }
 
@@ -1115,12 +1115,12 @@ static void snd_set_record_peer(Channel *channel, RedsStream *stream, int migrat
     if (!(celt_mode = celt051_mode_create(SPICE_INTERFACE_RECORD_FREQ,
                                           SPICE_INTERFACE_RECORD_CHAN,
                                           FRAME_SIZE, &celt_error))) {
-        red_printf("create celt mode failed %d", celt_error);
+        red_warn("create celt mode failed %d", celt_error);
         return;
     }
 
     if (!(celt_decoder = celt051_decoder_create(celt_mode))) {
-        red_printf("create celt decoder failed");
+        red_warn("create celt decoder failed");
         goto error_1;
     }
 
@@ -1181,7 +1181,7 @@ static void remove_worker(SndWorker *worker)
         }
         now = &(*now)->next;
     }
-    red_printf("not found");
+    red_warn("not found");
 }
 
 void snd_attach_playback(SpicePlaybackInstance *sin)
diff --git a/server/tests/basic_event_loop.c b/server/tests/basic_event_loop.c
index 1d54ed0..e755edc 100644
--- a/server/tests/basic_event_loop.c
+++ b/server/tests/basic_event_loop.c
@@ -1,6 +1,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <sys/time.h>
+#include <strings.h>
 
 #include "test_util.h"
 #include "basic_event_loop.h"
diff --git a/server/zlib_encoder.c b/server/zlib_encoder.c
index 214180e..784ddc4 100644
--- a/server/zlib_encoder.c
+++ b/server/zlib_encoder.c
@@ -46,7 +46,7 @@ ZlibEncoder* zlib_encoder_create(ZlibEncoderUsrContext *usr, int level)
     z_ret = deflateInit(&enc->strm, level);
     enc->last_level = level;
     if (z_ret != Z_OK) {
-        red_printf("zlib error");
+        red_warn("zlib error");
         free(enc);
         return NULL;
     }
-- 
1.7.6.4



More information about the Spice-devel mailing list