[Spice-devel] [PATCH 2/5] Use new spice/common logging functions

Alon Levy alevy at redhat.com
Thu Mar 15 02:29:52 PDT 2012


On Thu, Mar 15, 2012 at 02:13:32AM +0100, Marc-André Lureau wrote:
> And now we actually can find interesting issues that were hidden:
> 
> Spice-Warning **: quic.c:1242:quic_encode: should not be reached

I'm a little confused by this comment. It is nice to have consistent
naming, but how is the above produced? there is no change to quic.c in
this patch - maybe this warning is actually a result of the previous patch (which
hasn't reached my mailbox yet).

> ---
>  .gitignore                       |    1 +
>  server/agent-msg-filter.c        |    8 +-
>  server/dispatcher.c              |   33 +-
>  server/inputs_channel.c          |   34 +-
>  server/jpeg_encoder.c            |   14 +-
>  server/main_channel.c            |   66 ++--
>  server/mjpeg_encoder.c           |    2 +-
>  server/red_channel.c             |   96 +++---
>  server/red_client_cache.h        |    4 +-
>  server/red_client_shared_cache.h |    8 +-
>  server/red_dispatcher.c          |   37 +--
>  server/red_memslots.c            |   28 +-
>  server/red_parse_qxl.c           |   45 ++--
>  server/red_tunnel_worker.c       |  240 ++++++++--------
>  server/red_worker.c              |  602 +++++++++++++++++++-------------------
>  server/red_worker.h              |    4 +-
>  server/reds.c                    |  448 ++++++++++++++--------------
>  server/smartcard.c               |   24 +-
>  server/snd_worker.c              |   98 +++---
>  server/spicevmc.c                |    6 +-
>  server/zlib_encoder.c            |   16 +-
>  21 files changed, 907 insertions(+), 907 deletions(-)
> 
> diff --git a/.gitignore b/.gitignore
> index 6c15c13..e66f617 100644
> --- a/.gitignore
> +++ b/.gitignore
> @@ -23,3 +23,4 @@ Makefile
>  Makefile.in
>  spice-server.pc
>  stamp-h1
> +INSTALL
> diff --git a/server/agent-msg-filter.c b/server/agent-msg-filter.c
> index 71ff49b..7584b52 100644
> --- a/server/agent-msg-filter.c
> +++ b/server/agent-msg-filter.c
> @@ -39,7 +39,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");
> +        spice_printerr("invalid agent message: too large");
>          return AGENT_MSG_FILTER_PROTO_ERROR;
>      }
>  
> @@ -47,7 +47,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");
> +            spice_printerr("invalid agent message: data exceeds size from header");
>              return AGENT_MSG_FILTER_PROTO_ERROR;
>          }
>          filter->msg_data_to_read -= len;
> @@ -55,14 +55,14 @@ data_to_read:
>      }
>  
>      if (len < sizeof(msg_header)) {
> -        red_printf("invalid agent message: incomplete header");
> +        spice_printerr("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);
> +        spice_printerr("invalid agent protocol: %u", msg_header.protocol);
>          return AGENT_MSG_FILTER_PROTO_ERROR;
>      }
>  
> diff --git a/server/dispatcher.c b/server/dispatcher.c
> index 94ae556..13e2aad 100644
> --- a/server/dispatcher.c
> +++ b/server/dispatcher.c
> @@ -7,13 +7,12 @@
>  #include <fcntl.h>
>  #include <poll.h>
>  
> +#define SPICE_LOG_DOMAIN "SpiceDispatcher"
> +
>  #include "mem.h"
>  #include "spice_common.h"
>  #include "dispatcher.h"
>  
> -#define DISPATCHER_DEBUG_PRINTF(level, ...) \
> -    red_printf_debug(level, "DISP", ##__VA_ARGS__)
> -
>  //#define DEBUG_DISPATCHER
>  
>  #ifdef DEBUG_DISPATCHER
> @@ -43,10 +42,10 @@ static int read_safe(int fd, void *buf, size_t size, int block)
>      if (!block) {
>          while ((ret = poll(&pollfd, 1, 0)) == -1) {
>              if (errno == EINTR) {
> -                DISPATCHER_DEBUG_PRINTF(3, "EINTR in poll");
> +                spice_debug("EINTR in poll");
>                  continue;
>              }
> -            red_error("poll failed");
> +            spice_error("poll failed");
>              return -1;
>          }
>          if (!(pollfd.revents & POLLIN)) {
> @@ -57,13 +56,13 @@ static int read_safe(int fd, void *buf, size_t size, int block)
>          ret = read(fd, buf + read_size, size - read_size);
>          if (ret == -1) {
>              if (errno == EINTR) {
> -                DISPATCHER_DEBUG_PRINTF(3, "EINTR in read");
> +                spice_debug("EINTR in read");
>                  continue;
>              }
>              return -1;
>          }
>          if (ret == 0) {
> -            red_error("broken pipe on read");
> +            spice_error("broken pipe on read");
>              return -1;
>          }
>          read_size += ret;
> @@ -84,7 +83,7 @@ static int write_safe(int fd, void *buf, size_t size)
>          ret = write(fd, buf + written_size, size - written_size);
>          if (ret == -1) {
>              if (errno != EINTR) {
> -                DISPATCHER_DEBUG_PRINTF(3, "EINTR in write\n");
> +                spice_debug("EINTR in write");
>                  return -1;
>              }
>              continue;
> @@ -103,7 +102,7 @@ static int dispatcher_handle_single_read(Dispatcher *dispatcher)
>      uint32_t ack = ACK;
>  
>      if ((ret = read_safe(dispatcher->recv_fd, &type, sizeof(type), 0)) == -1) {
> -        red_printf("error reading from dispatcher: %d", errno);
> +        spice_printerr("error reading from dispatcher: %d", errno);
>          return 0;
>      }
>      if (ret == 0) {
> @@ -112,19 +111,19 @@ static int dispatcher_handle_single_read(Dispatcher *dispatcher)
>      }
>      msg = &dispatcher->messages[type];
>      if (read_safe(dispatcher->recv_fd, payload, msg->size, 1) == -1) {
> -        red_printf("error reading from dispatcher: %d", errno);
> +        spice_printerr("error reading from dispatcher: %d", errno);
>          /* TODO: close socketpair? */
>          return 0;
>      }
>      if (msg->handler) {
>          msg->handler(dispatcher->opaque, (void *)payload);
>      } else {
> -        red_printf("error: no handler for message type %d", type);
> +        spice_printerr("error: no handler for message type %d", type);
>      }
>      if (msg->ack == DISPATCHER_ACK) {
>          if (write_safe(dispatcher->recv_fd,
>                         &ack, sizeof(ack)) == -1) {
> -            red_printf("error writing ack for message %d", type);
> +            spice_printerr("error writing ack for message %d", type);
>              /* TODO: close socketpair? */
>          }
>      } else if (msg->ack == DISPATCHER_ASYNC && dispatcher->handle_async_done) {
> @@ -156,20 +155,20 @@ void dispatcher_send_message(Dispatcher *dispatcher, uint32_t message_type,
>      msg = &dispatcher->messages[message_type];
>      pthread_mutex_lock(&dispatcher->lock);
>      if (write_safe(send_fd, &message_type, sizeof(message_type)) == -1) {
> -        red_printf("error: failed to send message type for message %d",
> +        spice_printerr("error: failed to send message type for message %d",
>                     message_type);
>          goto unlock;
>      }
>      if (write_safe(send_fd, payload, msg->size) == -1) {
> -        red_printf("error: failed to send message body for message %d",
> +        spice_printerr("error: failed to send message body for message %d",
>                     message_type);
>          goto unlock;
>      }
>      if (msg->ack == DISPATCHER_ACK) {
>          if (read_safe(send_fd, &ack, sizeof(ack), 1) == -1) {
> -            red_printf("error: failed to read ack");
> +            spice_printerr("error: failed to read ack");
>          } else if (ack != ACK) {
> -            red_printf("error: got wrong ack value in dispatcher "
> +            spice_printerr("error: got wrong ack value in dispatcher "
>                         "for message %d\n", message_type);
>              /* TODO handling error? */
>          }
> @@ -238,7 +237,7 @@ void dispatcher_init(Dispatcher *dispatcher, size_t max_message_type,
>  #endif
>      dispatcher->opaque = opaque;
>      if (socketpair(AF_LOCAL, SOCK_STREAM, 0, channels) == -1) {
> -        red_error("socketpair failed %s", strerror(errno));
> +        spice_error("socketpair failed %s", strerror(errno));
>          return;
>      }
>      pthread_mutex_init(&dispatcher->lock, NULL);
> diff --git a/server/inputs_channel.c b/server/inputs_channel.c
> index 4224761..6bfbfa8 100644
> --- a/server/inputs_channel.c
> +++ b/server/inputs_channel.c
> @@ -113,7 +113,7 @@ int inputs_inited(void)
>  int inputs_set_keyboard(SpiceKbdInstance *_keyboard)
>  {
>      if (keyboard) {
> -        red_printf("already have keyboard");
> +        spice_printerr("already have keyboard");
>          return -1;
>      }
>      keyboard = _keyboard;
> @@ -124,7 +124,7 @@ int inputs_set_keyboard(SpiceKbdInstance *_keyboard)
>  int inputs_set_mouse(SpiceMouseInstance *_mouse)
>  {
>      if (mouse) {
> -        red_printf("already have mouse");
> +        spice_printerr("already have mouse");
>          return -1;
>      }
>      mouse = _mouse;
> @@ -135,7 +135,7 @@ int inputs_set_mouse(SpiceMouseInstance *_mouse)
>  int inputs_set_tablet(SpiceTabletInstance *_tablet)
>  {
>      if (tablet) {
> -        red_printf("already have tablet");
> +        spice_printerr("already have tablet");
>          return -1;
>      }
>      tablet = _tablet;
> @@ -150,7 +150,7 @@ int inputs_has_tablet(void)
>  
>  void inputs_detach_tablet(SpiceTabletInstance *_tablet)
>  {
> -    red_printf("");
> +    spice_printerr("");
>      tablet = NULL;
>  }
>  
> @@ -164,7 +164,7 @@ void inputs_set_tablet_logical_size(int x_res, int y_res)
>  
>  const VDAgentMouseState *inputs_get_mouse_state(void)
>  {
> -    ASSERT(g_inputs_channel);
> +    spice_assert(g_inputs_channel);
>      return &g_inputs_channel->mouse_state;
>  }
>  
> @@ -175,7 +175,7 @@ static uint8_t *inputs_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
>      InputsChannel *inputs_channel = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
>  
>      if (size > RECEIVE_BUF_SIZE) {
> -        red_printf("error: too large incoming message");
> +        spice_printerr("error: too large incoming message");
>          return NULL;
>      }
>      return inputs_channel->recv_buf;
> @@ -289,7 +289,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
>      InputsChannelClient *icc = (InputsChannelClient *)rcc;
>      uint8_t *buf = (uint8_t *)message;
>  
> -    ASSERT(g_inputs_channel == inputs_channel);
> +    spice_assert(g_inputs_channel == inputs_channel);
>      switch (type) {
>      case SPICE_MSGC_INPUTS_KEY_DOWN: {
>          SpiceMsgcKeyDown *key_up = (SpiceMsgcKeyDown *)buf;
> @@ -331,7 +331,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
>          if (reds_get_mouse_mode() != SPICE_MOUSE_MODE_CLIENT) {
>              break;
>          }
> -        ASSERT((reds_get_agent_mouse() && reds_has_vdagent()) || tablet);
> +        spice_assert((reds_get_agent_mouse() && reds_has_vdagent()) || tablet);
>          if (!reds_get_agent_mouse() || !reds_has_vdagent()) {
>              SpiceTabletInterface *sif;
>              sif = SPICE_CONTAINEROF(tablet->base.sif, SpiceTabletInterface, base);
> @@ -423,7 +423,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
>      case SPICE_MSGC_DISCONNECTING:
>          break;
>      default:
> -        red_printf("unexpected type %d", type);
> +        spice_printerr("unexpected type %d", type);
>          return FALSE;
>      }
>      return TRUE;
> @@ -449,7 +449,7 @@ static void inputs_channel_on_disconnect(RedChannelClient *rcc)
>  
>  static void inputs_migrate(RedChannelClient *rcc)
>  {
> -    ASSERT(g_inputs_channel == (InputsChannel *)rcc->channel);
> +    spice_assert(g_inputs_channel == (InputsChannel *)rcc->channel);
>      red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MIGRATE);
>  }
>  
> @@ -471,7 +471,7 @@ static int inputs_channel_config_socket(RedChannelClient *rcc)
>      if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY,
>              &delay_val, sizeof(delay_val)) == -1) {
>          if (errno != ENOTSUP && errno != ENOPROTOOPT) {
> -            red_printf("setsockopt failed, %s", strerror(errno));
> +            spice_printerr("setsockopt failed, %s", strerror(errno));
>              return FALSE;
>          }
>      }
> @@ -490,10 +490,10 @@ static void inputs_connect(RedChannel *channel, RedClient *client,
>  {
>      InputsChannelClient *icc;
>  
> -    ASSERT(g_inputs_channel);
> -    ASSERT(channel == &g_inputs_channel->base);
> +    spice_assert(g_inputs_channel);
> +    spice_assert(channel == &g_inputs_channel->base);
>  
> -    red_printf("inputs channel client create");
> +    spice_printerr("inputs channel client create");
>      icc = (InputsChannelClient*)red_channel_client_create(sizeof(InputsChannelClient),
>                                                            channel,
>                                                            client,
> @@ -528,7 +528,7 @@ void inputs_init(void)
>      ChannelCbs channel_cbs = { NULL, };
>      ClientCbs client_cbs = { NULL, };
>  
> -    ASSERT(!g_inputs_channel);
> +    spice_assert(!g_inputs_channel);
>  
>      channel_cbs.config_socket = inputs_channel_config_socket;
>      channel_cbs.on_disconnect = inputs_channel_on_disconnect;
> @@ -549,7 +549,7 @@ void inputs_init(void)
>                                      &channel_cbs);
>  
>      if (!g_inputs_channel) {
> -        red_error("failed to allocate Inputs Channel");
> +        spice_error("failed to allocate Inputs Channel");
>      }
>  
>      client_cbs.connect = inputs_connect;
> @@ -559,6 +559,6 @@ void inputs_init(void)
>      reds_register_channel(&g_inputs_channel->base);
>  
>      if (!(key_modifiers_timer = core->timer_add(key_modifiers_sender, NULL))) {
> -        red_error("key modifiers timer create failed");
> +        spice_error("key modifiers timer create failed");
>      }
>  }
> diff --git a/server/jpeg_encoder.c b/server/jpeg_encoder.c
> index d0e2fc1..01732ff 100644
> --- a/server/jpeg_encoder.c
> +++ b/server/jpeg_encoder.c
> @@ -49,7 +49,7 @@ static void dest_mgr_init_destination(j_compress_ptr cinfo)
>                                                              &enc->dest_mgr.next_output_byte);
>  
>          if (enc->dest_mgr.free_in_buffer == 0) {
> -            red_error("not enough space");
> +            spice_error("not enough space");
>          }
>      }
>  
> @@ -63,7 +63,7 @@ static boolean dest_mgr_empty_output_buffer(j_compress_ptr cinfo)
>                                                          &enc->dest_mgr.next_output_byte);
>  
>      if (enc->dest_mgr.free_in_buffer == 0) {
> -        red_error("not enough space");
> +        spice_error("not enough space");
>      }
>      enc->cur_image.out_size += enc->dest_mgr.free_in_buffer;
>      return TRUE;
> @@ -110,7 +110,7 @@ static void convert_RGB16_to_RGB24(uint8_t *line, int width, uint8_t **out_line)
>      uint8_t *out_pix;
>      int x;
>  
> -    ASSERT(out_line && *out_line);
> +    spice_assert(out_line && *out_line);
>  
>      out_pix = *out_line;
>  
> @@ -127,7 +127,7 @@ static void convert_BGR24_to_RGB24(uint8_t *line, int width, uint8_t **out_line)
>      int x;
>      uint8_t *out_pix;
>  
> -    ASSERT(out_line && *out_line);
> +    spice_assert(out_line && *out_line);
>  
>      out_pix = *out_line;
>  
> @@ -145,7 +145,7 @@ static void convert_BGRX32_to_RGB24(uint8_t *line, int width, uint8_t **out_line
>      uint8_t *out_pix;
>      int x;
>  
> -    ASSERT(out_line && *out_line);
> +    spice_assert(out_line && *out_line);
>  
>      out_pix = *out_line;
>  
> @@ -167,7 +167,7 @@ static void convert_RGB24_to_RGB24(uint8_t *line, int width, uint8_t **out_line)
>      if (lines == lines_end) {                                           \
>          int n = jpeg->usr->more_lines(jpeg->usr, &lines);               \
>          if (n <= 0) {                                                   \
> -            red_error("more lines failed\n");                           \
> +            spice_error("more lines failed");                           \
>          }                                                               \
>          lines_end = lines + n * stride;                                 \
>      }                                                                   \
> @@ -226,7 +226,7 @@ int jpeg_encode(JpegEncoderContext *jpeg, int quality, JpegEncoderImageType type
>          enc->cur_image.convert_line_to_RGB24 = convert_BGRX32_to_RGB24;
>          break;
>      default:
> -        red_error("bad image type");
> +        spice_error("bad image type");
>      }
>  
>      enc->cinfo.image_width = width;
> diff --git a/server/main_channel.c b/server/main_channel.c
> index a9fd24e..0846869 100644
> --- a/server/main_channel.c
> +++ b/server/main_channel.c
> @@ -161,7 +161,7 @@ int main_channel_is_connected(MainChannel *main_chan)
>  // real disconnection of main channel
>  static void main_channel_client_on_disconnect(RedChannelClient *rcc)
>  {
> -    red_printf("rcc=%p", rcc);
> +    spice_printerr("rcc=%p", rcc);
>      reds_client_disconnect(rcc->client);
>  //    red_channel_client_disconnect(rcc);
>  }
> @@ -332,7 +332,7 @@ static PipeItem *main_multi_media_time_item_new(
>  static void main_channel_push_channels(MainChannelClient *mcc)
>  {
>      if (red_client_during_migrate_at_target(mcc->base.client)) {
> -        red_printf("warning: ignoring unexpected SPICE_MSGC_MAIN_ATTACH_CHANNELS"
> +        spice_printerr("warning: ignoring unexpected SPICE_MSGC_MAIN_ATTACH_CHANNELS"
>                     "during migration");
>          return;
>      }
> @@ -481,7 +481,7 @@ static uint64_t main_channel_handle_migrate_data_get_serial(RedChannelClient *ba
>      MainMigrateData *data = message;
>  
>      if (size < sizeof(*data)) {
> -        red_printf("bad message size");
> +        spice_printerr("bad message size");
>          return 0;
>      }
>      return data->serial;
> @@ -494,7 +494,7 @@ static uint64_t main_channel_handle_migrate_data(RedChannelClient *base,
>      MainMigrateData *data = message;
>  
>      if (size < sizeof(*data)) {
> -        red_printf("bad message size");
> +        spice_printerr("bad message size");
>          return FALSE;
>      }
>      mcc->ping_id = data->ping_id;
> @@ -635,7 +635,7 @@ void main_channel_push_multi_media_time(MainChannel *main_chan, int time)
>  
>  static void main_channel_fill_mig_target(MainChannel *main_channel, RedsMigSpice *mig_target)
>  {
> -    ASSERT(mig_target);
> +    spice_assert(mig_target);
>      free(main_channel->mig_target.host);
>      main_channel->mig_target.host = strdup(mig_target->host);
>      free(main_channel->mig_target.cert_subject);
> @@ -657,7 +657,7 @@ static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelC
>      SpiceMsgMainMigrationSwitchHost migrate;
>      MainChannel *main_ch;
>  
> -    red_printf("");
> +    spice_printerr("");
>      main_ch = SPICE_CONTAINEROF(rcc->channel, MainChannel, base);
>      migrate.port = main_ch->mig_target.port;
>      migrate.sport = main_ch->mig_target.sport;
> @@ -688,7 +688,7 @@ static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base)
>      SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
>  
>      if (!mcc->init_sent && base->type != SPICE_MSG_MAIN_INIT) {
> -        red_printf("Init msg for client %p was not sent yet "
> +        spice_printerr("Init msg for client %p was not sent yet "
>                     "(client is probably during migration). Ignoring msg type %d",
>                     rcc->client, base->type);
>          main_channel_release_pipe_item(rcc, base, FALSE);
> @@ -768,8 +768,8 @@ static void main_channel_release_pipe_item(RedChannelClient *rcc,
>          case SPICE_MSG_MAIN_AGENT_DATA: {
>              AgentDataPipeItem *data = (AgentDataPipeItem*)base;
>              if (!--data->refs->refs) {
> -                red_printf_debug(1, "MAIN", "SPICE_MSG_MAIN_AGENT_DATA %p %p, %d",
> -                                 data, data->refs, data->refs->refs);
> +                spice_debug("SPICE_MSG_MAIN_AGENT_DATA %p %p, %d",
> +                            data, data->refs, data->refs->refs);
>                  free(data->refs);
>                  data->free_data(data->data, data->opaque);
>              }
> @@ -783,19 +783,19 @@ static void main_channel_release_pipe_item(RedChannelClient *rcc,
>  
>  void main_channel_client_handle_migrate_connected(MainChannelClient *mcc, int success)
>  {
> -    red_printf("client %p connected: %d", mcc->base.client, success);
> +    spice_printerr("client %p connected: %d", mcc->base.client, success);
>      if (mcc->mig_wait_connect) {
>          MainChannel *main_channel = SPICE_CONTAINEROF(mcc->base.channel, MainChannel, base);
>  
>          mcc->mig_wait_connect = FALSE;
>          mcc->mig_connect_ok = success;
> -        ASSERT(main_channel->num_clients_mig_wait);
> +        spice_assert(main_channel->num_clients_mig_wait);
>          if (!--main_channel->num_clients_mig_wait) {
>              reds_on_main_migrate_connected();
>          }
>      } else {
>          if (success) {
> -            red_printf("client %p MIGRATE_CANCEL", mcc->base.client);
> +            spice_printerr("client %p MIGRATE_CANCEL", mcc->base.client);
>              red_channel_client_pipe_add_type(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL);
>          }
>      }
> @@ -804,12 +804,12 @@ void main_channel_client_handle_migrate_connected(MainChannelClient *mcc, int su
>  void main_channel_client_handle_migrate_end(MainChannelClient *mcc)
>  {
>      if (!red_client_during_migrate_at_target(mcc->base.client)) {
> -        red_printf("unexpected SPICE_MSGC_MIGRATE_END");
> +        spice_printerr("unexpected SPICE_MSGC_MIGRATE_END");
>          return;
>      }
>      if (!red_channel_client_test_remote_cap(&mcc->base,
>                                              SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
> -        red_printf("unexpected SPICE_MSGC_MIGRATE_END, "
> +        spice_printerr("unexpected SPICE_MSGC_MIGRATE_END, "
>                     "client does not support semi-seamless migration");
>              return;
>      }
> @@ -828,7 +828,7 @@ static int main_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint
>  
>      switch (type) {
>      case SPICE_MSGC_MAIN_AGENT_START:
> -        red_printf("agent start");
> +        spice_printerr("agent start");
>          if (!main_chan) {
>              return FALSE;
>          }
> @@ -876,14 +876,14 @@ static int main_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint
>                  if (roundtrip <= mcc->latency) {
>                      // probably high load on client or server result with incorrect values
>                      mcc->latency = 0;
> -                    red_printf("net test: invalid values, latency %" PRIu64
> +                    spice_printerr("net test: invalid values, latency %" PRIu64
>                                 " roundtrip %" PRIu64 ". assuming high"
>                                 "bandwidth", mcc->latency, roundtrip);
>                      break;
>                  }
>                  mcc->bitrate_per_sec = (uint64_t)(NET_TEST_BYTES * 8) * 1000000
>                                          / (roundtrip - mcc->latency);
> -                red_printf("net test: latency %f ms, bitrate %"PRIu64" bps (%f Mbps)%s",
> +                spice_printerr("net test: latency %f ms, bitrate %"PRIu64" bps (%f Mbps)%s",
>                             (double)mcc->latency / 1000,
>                             mcc->bitrate_per_sec,
>                             (double)mcc->bitrate_per_sec / 1024 / 1024,
> @@ -891,7 +891,7 @@ static int main_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint
>                  mcc->net_test_stage = NET_TEST_STAGE_INVALID;
>                  break;
>              default:
> -                red_printf("invalid net test stage, ping id %d test id %d stage %d",
> +                spice_printerr("invalid net test stage, ping id %d test id %d stage %d",
>                             ping->id,
>                             mcc->net_test_id,
>                             mcc->net_test_stage);
> @@ -913,7 +913,7 @@ static int main_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, uint
>          main_channel_client_handle_migrate_end(mcc);
>          break;
>      default:
> -        red_printf("unexpected type %d", type);
> +        spice_printerr("unexpected type %d", type);
>      }
>      return TRUE;
>  }
> @@ -954,7 +954,7 @@ static int main_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
>  static void do_ping_client(MainChannelClient *mcc,
>      const char *opt, int has_interval, int interval)
>  {
> -    red_printf("");
> +    spice_printerr("");
>      if (!opt) {
>          main_channel_client_push_ping(mcc, 0);
>      } else if (!strcmp(opt, "on")) {
> @@ -974,7 +974,7 @@ static void ping_timer_cb(void *opaque)
>      MainChannelClient *mcc = opaque;
>  
>      if (!red_channel_client_is_connected(&mcc->base)) {
> -        red_printf("not connected to peer, ping off");
> +        spice_printerr("not connected to peer, ping off");
>          core->timer_cancel(mcc->ping_timer);
>          return;
>      }
> @@ -1002,7 +1002,7 @@ static MainChannelClient *main_channel_client_create(MainChannel *main_chan, Red
>      mcc->bitrate_per_sec = ~0;
>  #ifdef RED_STATISTICS
>      if (!(mcc->ping_timer = core->timer_add(ping_timer_cb, NULL))) {
> -        red_error("ping timer create failed");
> +        spice_error("ping timer create failed");
>      }
>      mcc->ping_interval = PING_INTERVAL;
>  #endif
> @@ -1016,12 +1016,12 @@ MainChannelClient *main_channel_link(MainChannel *channel, RedClient *client,
>  {
>      MainChannelClient *mcc;
>  
> -    ASSERT(channel);
> +    spice_assert(channel);
>  
>      // TODO - migration - I removed it from channel creation, now put it
>      // into usage somewhere (not an issue until we return migration to it's
>      // former glory)
> -    red_printf("add main channel client");
> +    spice_printerr("add main channel client");
>      mcc = main_channel_client_create(channel, client, stream, connection_id,
>                                       num_common_caps, common_caps,
>                                       num_caps, caps);
> @@ -1082,14 +1082,14 @@ MainChannel* main_channel_init(void)
>                                          spice_get_client_channel_parser(SPICE_CHANNEL_MAIN, NULL),
>                                          main_channel_handle_parsed,
>                                          &channel_cbs);
> -    ASSERT(channel);
> +    spice_assert(channel);
>      red_channel_set_cap(channel, SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
>      return (MainChannel *)channel;
>  }
>  
>  RedChannelClient* main_channel_client_get_base(MainChannelClient* mcc)
>  {
> -    ASSERT(mcc);
> +    spice_assert(mcc);
>      return &mcc->base;
>  }
>  
> @@ -1106,7 +1106,7 @@ int main_channel_migrate_connect(MainChannel *main_channel, RedsMigSpice *mig_ta
>          if (red_channel_client_test_remote_cap(&mcc->base,
>                                                 SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
>              if (red_client_during_migrate_at_target(mcc->base.client)) {
> -                red_printf("client %p: wait till previous migration completes", mcc->base.client);
> +                spice_printerr("client %p: wait till previous migration completes", mcc->base.client);
>                  mcc->mig_wait_prev_complete = TRUE;
>              } else {
>                  red_channel_client_pipe_add_type(&mcc->base, SPICE_MSG_MAIN_MIGRATE_BEGIN);
> @@ -1128,7 +1128,7 @@ void main_channel_migrate_cancel_wait(MainChannel *main_chan)
>  
>          mcc = SPICE_CONTAINEROF(client_link, MainChannelClient, base.channel_link);
>          if (mcc->mig_wait_connect) {
> -            red_printf("client %p cancel wait connect", mcc->base.client);
> +            spice_printerr("client %p cancel wait connect", mcc->base.client);
>              mcc->mig_wait_connect = FALSE;
>              mcc->mig_connect_ok = FALSE;
>          }
> @@ -1142,10 +1142,10 @@ int main_channel_migrate_complete(MainChannel *main_chan, int success)
>      RingItem *client_link;
>      int semi_seamless_count = 0;
>  
> -    red_printf("");
> +    spice_printerr("");
>  
>      if (ring_is_empty(&main_chan->base.clients)) {
> -        red_printf("no peer connected");
> +        spice_printerr("no peer connected");
>          return 0;
>      }
>  
> @@ -1158,16 +1158,16 @@ int main_channel_migrate_complete(MainChannel *main_chan, int success)
>                                                     SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
>          if (semi_seamless_support && mcc->mig_connect_ok) {
>              if (success) {
> -                red_printf("client %p MIGRATE_END", mcc->base.client);
> +                spice_printerr("client %p MIGRATE_END", mcc->base.client);
>                  red_channel_client_pipe_add_type(&mcc->base, SPICE_MSG_MAIN_MIGRATE_END);
>                  semi_seamless_count++;
>              } else {
> -                red_printf("client %p MIGRATE_CANCEL", mcc->base.client);
> +                spice_printerr("client %p MIGRATE_CANCEL", mcc->base.client);
>                  red_channel_client_pipe_add_type(&mcc->base, SPICE_MSG_MAIN_MIGRATE_CANCEL);
>              }
>          } else {
>              if (success) {
> -                red_printf("client %p SWITCH_HOST", mcc->base.client);
> +                spice_printerr("client %p SWITCH_HOST", mcc->base.client);
>                  red_channel_client_pipe_add_type(&mcc->base, SPICE_MSG_MAIN_MIGRATE_SWITCH_HOST);
>              }
>          }
> diff --git a/server/mjpeg_encoder.c b/server/mjpeg_encoder.c
> index 6b68549..4692315 100644
> --- a/server/mjpeg_encoder.c
> +++ b/server/mjpeg_encoder.c
> @@ -228,7 +228,7 @@ int mjpeg_encoder_start_frame(MJpegEncoder *encoder, SpiceBitmapFmt format,
>  #endif
>          break;
>      default:
> -        red_printf_some(1000, "unsupported format %d", format);
> +        spice_warning("unsupported format %d", format);
>          return FALSE;
>      }
>  
> diff --git a/server/red_channel.c b/server/red_channel.c
> index ecb512d..e185057 100644
> --- a/server/red_channel.c
> +++ b/server/red_channel.c
> @@ -87,7 +87,7 @@ static void full_header_set_msg_serial(SpiceDataHeaderOpaque *header, uint64_t s
>  
>  static void mini_header_set_msg_serial(SpiceDataHeaderOpaque *header, uint64_t serial)
>  {
> -    red_error("attempt to set header serial on mini header");
> +    spice_error("attempt to set header serial on mini header");
>  }
>  
>  static void full_header_set_msg_sub_list(SpiceDataHeaderOpaque *header, uint32_t sub_list)
> @@ -97,7 +97,7 @@ static void full_header_set_msg_sub_list(SpiceDataHeaderOpaque *header, uint32_t
>  
>  static void mini_header_set_msg_sub_list(SpiceDataHeaderOpaque *header, uint32_t sub_list)
>  {
> -    red_error("attempt to set header sub list on mini header");
> +    spice_error("attempt to set header sub list on mini header");
>  }
>  
>  static SpiceDataHeaderOpaque full_header_wrapper = {NULL, sizeof(SpiceDataHeader),
> @@ -130,7 +130,7 @@ static int red_peer_receive(RedsStream *stream, uint8_t *buf, uint32_t size)
>              if (now == 0) {
>                  return -1;
>              }
> -            ASSERT(now == -1);
> +            spice_assert(now == -1);
>              if (errno == EAGAIN) {
>                  break;
>              } else if (errno == EINTR) {
> @@ -138,7 +138,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));
> +                spice_printerr("%s", strerror(errno));
>                  return -1;
>              }
>          } else {
> @@ -191,7 +191,7 @@ static void red_peer_handle_incoming(RedsStream *stream, IncomingHandler *handle
>              if (!handler->msg) {
>                  handler->msg = handler->cb->alloc_msg_buf(handler->opaque, msg_type, msg_size);
>                  if (handler->msg == NULL) {
> -                    red_printf("ERROR: channel refused to allocate buffer.");
> +                    spice_printerr("ERROR: channel refused to allocate buffer.");
>                      handler->cb->on_error(handler->opaque);
>                      return;
>                  }
> @@ -216,7 +216,7 @@ static void red_peer_handle_incoming(RedsStream *stream, IncomingHandler *handle
>                  handler->msg + msg_size, msg_type,
>                  SPICE_VERSION_MINOR, &parsed_size, &parsed_free);
>              if (parsed == NULL) {
> -                red_printf("failed to parse message type %d", msg_type);
> +                spice_printerr("failed to parse message type %d", msg_type);
>                  handler->cb->release_msg_buf(handler->opaque, msg_type, msg_size, handler->msg);
>                  handler->cb->on_error(handler->opaque);
>                  return;
> @@ -283,7 +283,7 @@ static void red_peer_handle_outgoing(RedsStream *stream, OutgoingHandler *handle
>                  handler->cb->on_error(handler->opaque);
>                  return;
>              default:
> -                red_printf("%s", strerror(errno));
> +                spice_printerr("%s", strerror(errno));
>                  handler->cb->on_error(handler->opaque);
>                  return;
>              }
> @@ -360,7 +360,7 @@ static void red_channel_client_reset_send_data(RedChannelClient *rcc)
>       * has been called before, but no message has been sent since then.
>       */
>      if (rcc->send_data.last_sent_serial != rcc->send_data.serial) {
> -        ASSERT(rcc->send_data.serial - rcc->send_data.last_sent_serial == 1);
> +        spice_assert(rcc->send_data.serial - rcc->send_data.last_sent_serial == 1);
>          /*  When the urgent marshaller is active, the serial was incremented by
>           *  the call to reset_send_data that was made for the main marshaller.
>           *  The urgent msg receives this serial, and the main msg serial is
> @@ -373,7 +373,7 @@ static void red_channel_client_reset_send_data(RedChannelClient *rcc)
>      rcc->send_data.serial++;
>  
>      if (!rcc->is_mini_header) {
> -        ASSERT(rcc->send_data.marshaller != rcc->send_data.urgent.marshaller);
> +        spice_assert(rcc->send_data.marshaller != rcc->send_data.urgent.marshaller);
>          rcc->send_data.header.set_msg_sub_list(&rcc->send_data.header, 0);
>          rcc->send_data.header.set_msg_serial(&rcc->send_data.header, rcc->send_data.serial);
>      }
> @@ -393,7 +393,7 @@ static void red_channel_client_send_set_ack(RedChannelClient *rcc)
>  {
>      SpiceMsgSetAck ack;
>  
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      red_channel_client_init_send_data(rcc, SPICE_MSG_SET_ACK, NULL);
>      ack.generation = ++rcc->ack_data.generation;
>      ack.window = rcc->ack_data.client_window;
> @@ -408,7 +408,7 @@ static void red_channel_client_send_item(RedChannelClient *rcc, PipeItem *item)
>  {
>      int handled = TRUE;
>  
> -    ASSERT(red_channel_client_no_item_being_sent(rcc));
> +    spice_assert(red_channel_client_no_item_being_sent(rcc));
>      red_channel_client_reset_send_data(rcc);
>      switch (item->type) {
>          case PIPE_ITEM_TYPE_SET_ACK:
> @@ -461,7 +461,7 @@ static void red_channel_peer_on_out_msg_done(void *opaque)
>  
>      if (red_channel_client_urgent_marshaller_is_active(rcc)) {
>          red_channel_client_restore_main_sender(rcc);
> -        ASSERT(rcc->send_data.header.data != NULL);
> +        spice_assert(rcc->send_data.header.data != NULL);
>          red_channel_client_begin_send_message(rcc);
>      }
>  }
> @@ -474,7 +474,7 @@ static void red_channel_client_pipe_remove(RedChannelClient *rcc, PipeItem *item
>  
>  static void red_channel_add_client(RedChannel *channel, RedChannelClient *rcc)
>  {
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      ring_add(&channel->clients, &rcc->channel_link);
>      channel->clients_num++;
>  }
> @@ -519,7 +519,7 @@ RedChannelClient *red_channel_client_create(int size, RedChannel *channel, RedCl
>  {
>      RedChannelClient *rcc;
>  
> -    ASSERT(stream && channel && size >= sizeof(RedChannelClient));
> +    spice_assert(stream && channel && size >= sizeof(RedChannelClient));
>      rcc = spice_malloc0(size);
>      rcc->stream = stream;
>      rcc->channel = channel;
> @@ -581,7 +581,7 @@ static void red_channel_client_default_connect(RedChannel *channel, RedClient *c
>                                                 int num_common_caps, uint32_t *common_caps,
>                                                 int num_caps, uint32_t *caps)
>  {
> -    red_error("not implemented");
> +    spice_error("not implemented");
>  }
>  
>  static void red_channel_client_default_disconnect(RedChannelClient *base)
> @@ -603,8 +603,8 @@ RedChannel *red_channel_create(int size,
>      RedChannel *channel;
>      ClientCbs client_cbs = { NULL, };
>  
> -    ASSERT(size >= sizeof(*channel));
> -    ASSERT(channel_cbs->config_socket && channel_cbs->on_disconnect && handle_message &&
> +    spice_assert(size >= sizeof(*channel));
> +    spice_assert(channel_cbs->config_socket && channel_cbs->on_disconnect && handle_message &&
>             channel_cbs->alloc_recv_buf && channel_cbs->release_item);
>      channel = spice_malloc0(size);
>      channel->type = type;
> @@ -670,7 +670,7 @@ RedChannel *red_channel_create_dummy(int size, uint32_t type, uint32_t id)
>      RedChannel *channel;
>      ClientCbs client_cbs = { NULL, };
>  
> -    ASSERT(size >= sizeof(*channel));
> +    spice_assert(size >= sizeof(*channel));
>      channel = spice_malloc0(size);
>      channel->type = type;
>      channel->id = id;
> @@ -721,7 +721,7 @@ RedChannel *red_channel_create_parser(int size,
>  
>  void red_channel_register_client_cbs(RedChannel *channel, ClientCbs *client_cbs)
>  {
> -    ASSERT(client_cbs->connect);
> +    spice_assert(client_cbs->connect);
>      channel->client_cbs.connect = client_cbs->connect;
>  
>      if (client_cbs->disconnect) {
> @@ -767,7 +767,7 @@ void red_channel_set_cap(RedChannel *channel, uint32_t cap)
>  
>  void red_channel_set_data(RedChannel *channel, void *data)
>  {
> -    ASSERT(channel);
> +    spice_assert(channel);
>      channel->data = data;
>  }
>  
> @@ -874,7 +874,7 @@ void red_channel_client_push(RedChannelClient *rcc)
>  
>      if (!red_channel_client_no_item_being_sent(rcc) && !rcc->send_data.blocked) {
>          rcc->send_data.blocked = TRUE;
> -        red_printf("ERROR: an item waiting to be sent and not blocked");
> +        spice_printerr("ERROR: an item waiting to be sent and not blocked");
>      }
>  
>      while ((pipe_item = red_channel_client_pipe_item_get(rcc))) {
> @@ -936,7 +936,7 @@ static void red_channel_handle_migrate_data(RedChannelClient *rcc, uint32_t size
>      if (!rcc->channel->channel_cbs.handle_migrate_data) {
>          return;
>      }
> -    ASSERT(red_channel_client_get_message_serial(rcc) == 0);
> +    spice_assert(red_channel_client_get_message_serial(rcc) == 0);
>      red_channel_client_set_message_serial(rcc,
>          rcc->channel->channel_cbs.handle_migrate_data_get_serial(rcc, size, message));
>      rcc->channel->channel_cbs.handle_migrate_data(rcc, size, message);
> @@ -948,7 +948,7 @@ int red_channel_client_handle_message(RedChannelClient *rcc, uint32_t size,
>      switch (type) {
>      case SPICE_MSGC_ACK_SYNC:
>          if (size != sizeof(uint32_t)) {
> -            red_printf("bad message size");
> +            spice_printerr("bad message size");
>              return FALSE;
>          }
>          rcc->ack_data.client_generation = *(uint32_t *)(message);
> @@ -968,7 +968,7 @@ int red_channel_client_handle_message(RedChannelClient *rcc, uint32_t size,
>          red_channel_handle_migrate_data(rcc, size, message);
>          break;
>      default:
> -        red_printf("invalid message type %u", type);
> +        spice_printerr("invalid message type %u", type);
>          return FALSE;
>      }
>      return TRUE;
> @@ -988,8 +988,8 @@ static void red_channel_client_event(int fd, int event, void *data)
>  
>  void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t msg_type, PipeItem *item)
>  {
> -    ASSERT(red_channel_client_no_item_being_sent(rcc));
> -    ASSERT(msg_type != 0);
> +    spice_assert(red_channel_client_no_item_being_sent(rcc));
> +    spice_assert(msg_type != 0);
>      rcc->send_data.header.set_msg_type(&rcc->send_data.header, msg_type);
>      rcc->send_data.item = item;
>      if (item) {
> @@ -1003,7 +1003,7 @@ void red_channel_client_begin_send_message(RedChannelClient *rcc)
>  
>      // TODO - better check: type in channel_allowed_types. Better: type in channel_allowed_types(channel_state)
>      if (rcc->send_data.header.get_msg_type(&rcc->send_data.header) == 0) {
> -        red_printf("BUG: header->type == 0");
> +        spice_printerr("BUG: header->type == 0");
>          return;
>      }
>      spice_marshaller_flush(m);
> @@ -1018,8 +1018,8 @@ void red_channel_client_begin_send_message(RedChannelClient *rcc)
>  
>  SpiceMarshaller *red_channel_client_switch_to_urgent_sender(RedChannelClient *rcc)
>  {
> -    ASSERT(red_channel_client_no_item_being_sent(rcc));
> -    ASSERT(rcc->send_data.header.data != NULL);
> +    spice_assert(red_channel_client_no_item_being_sent(rcc));
> +    spice_assert(rcc->send_data.header.data != NULL);
>      rcc->send_data.main.header_data = rcc->send_data.header.data;
>      rcc->send_data.main.item = rcc->send_data.item;
>  
> @@ -1058,7 +1058,7 @@ void red_channel_pipe_item_init(RedChannel *channel, PipeItem *item, int type)
>  
>  void red_channel_client_pipe_add(RedChannelClient *rcc, PipeItem *item)
>  {
> -    ASSERT(rcc && item);
> +    spice_assert(rcc && item);
>      rcc->pipe_size++;
>      ring_add(&rcc->pipe, &item->link);
>  }
> @@ -1072,9 +1072,9 @@ void red_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem *item)
>  void red_channel_client_pipe_add_after(RedChannelClient *rcc,
>                                         PipeItem *item, PipeItem *pos)
>  {
> -    ASSERT(rcc);
> -    ASSERT(pos);
> -    ASSERT(item);
> +    spice_assert(rcc);
> +    spice_assert(pos);
> +    spice_assert(item);
>  
>      rcc->pipe_size++;
>      ring_add_after(&item->link, &pos->link);
> @@ -1089,14 +1089,14 @@ int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc,
>  void red_channel_client_pipe_add_tail_no_push(RedChannelClient *rcc,
>                                                PipeItem *item)
>  {
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      rcc->pipe_size++;
>      ring_add_before(&item->link, &rcc->pipe);
>  }
>  
>  void red_channel_client_pipe_add_tail(RedChannelClient *rcc, PipeItem *item)
>  {
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      rcc->pipe_size++;
>      ring_add_before(&item->link, &rcc->pipe);
>      red_channel_client_push(rcc);
> @@ -1168,9 +1168,9 @@ void red_channel_client_ack_set_client_window(RedChannelClient *rcc, int client_
>  
>  static void red_channel_remove_client(RedChannelClient *rcc)
>  {
> -    ASSERT(pthread_equal(pthread_self(), rcc->channel->thread_id));
> +    spice_assert(pthread_equal(pthread_self(), rcc->channel->thread_id));
>      ring_remove(&rcc->channel_link);
> -    ASSERT(rcc->channel->clients_num > 0);
> +    spice_assert(rcc->channel->clients_num > 0);
>      rcc->channel->clients_num--;
>      // TODO: should we set rcc->channel to NULL???
>  }
> @@ -1185,7 +1185,7 @@ static void red_client_remove_channel(RedChannelClient *rcc)
>  
>  void red_channel_client_disconnect(RedChannelClient *rcc)
>  {
> -    red_printf("%p (channel %p type %d id %d)", rcc, rcc->channel,
> +    spice_printerr("%p (channel %p type %d id %d)", rcc, rcc->channel,
>                                                  rcc->channel->type, rcc->channel->id);
>      if (!red_channel_client_is_connected(rcc)) {
>          return;
> @@ -1220,7 +1220,7 @@ RedChannelClient *red_channel_client_create_dummy(int size,
>  {
>      RedChannelClient *rcc;
>  
> -    ASSERT(size >= sizeof(RedChannelClient));
> +    spice_assert(size >= sizeof(RedChannelClient));
>      rcc = spice_malloc0(size);
>      rcc->client = client;
>      rcc->channel = channel;
> @@ -1414,8 +1414,8 @@ void red_client_migrate(RedClient *client)
>      RingItem *link, *next;
>      RedChannelClient *rcc;
>  
> -    red_printf("migrate client with #channels %d", client->channels_num);
> -    ASSERT(pthread_equal(pthread_self(), client->thread_id));
> +    spice_printerr("migrate client with #channels %d", client->channels_num);
> +    spice_assert(pthread_equal(pthread_self(), client->thread_id));
>      RING_FOREACH_SAFE(link, next, &client->channels) {
>          rcc = SPICE_CONTAINEROF(link, RedChannelClient, client_link);
>          if (red_channel_client_is_connected(rcc)) {
> @@ -1429,8 +1429,8 @@ void red_client_destroy(RedClient *client)
>      RingItem *link, *next;
>      RedChannelClient *rcc;
>  
> -    red_printf("destroy client with #channels %d", client->channels_num);
> -    ASSERT(pthread_equal(pthread_self(), client->thread_id));
> +    spice_printerr("destroy client with #channels %d", client->channels_num);
> +    spice_assert(pthread_equal(pthread_self(), client->thread_id));
>      RING_FOREACH_SAFE(link, next, &client->channels) {
>          // some channels may be in other threads, so disconnection
>          // is not synchronous.
> @@ -1442,9 +1442,9 @@ void red_client_destroy(RedClient *client)
>          // TODO: should we go back to async. For this we need to use
>          // ref count for channel clients.
>          rcc->channel->client_cbs.disconnect(rcc);
> -        ASSERT(ring_is_empty(&rcc->pipe));
> -        ASSERT(rcc->pipe_size == 0);
> -        ASSERT(rcc->send_data.size == 0);
> +        spice_assert(ring_is_empty(&rcc->pipe));
> +        spice_assert(rcc->pipe_size == 0);
> +        spice_assert(rcc->send_data.size == 0);
>          red_channel_client_destroy(rcc);
>      }
>  
> @@ -1454,7 +1454,7 @@ void red_client_destroy(RedClient *client)
>  
>  static void red_client_add_channel(RedClient *client, RedChannelClient *rcc)
>  {
> -    ASSERT(rcc && client);
> +    spice_assert(rcc && client);
>      pthread_mutex_lock(&client->lock);
>      ring_add(&client->channels, &rcc->client_link);
>      client->channels_num++;
> @@ -1471,7 +1471,7 @@ void red_client_set_main(RedClient *client, MainChannelClient *mcc) {
>  
>  void red_client_migrate_complete(RedClient *client)
>  {
> -    ASSERT(client->migrated);
> +    spice_assert(client->migrated);
>      client->migrated = FALSE;
>      reds_on_client_migrate_complete(client);
>  }
> diff --git a/server/red_client_cache.h b/server/red_client_cache.h
> index 0da11a6..dc314c0 100644
> --- a/server/red_client_cache.h
> +++ b/server/red_client_cache.h
> @@ -63,11 +63,11 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
>  {
>      CacheItem **now;
>      CHANNEL *channel = CHANNEL_FROM_RCC(&channel_client->common.base);
> -    ASSERT(item);
> +    spice_assert(item);
>  
>      now = &channel_client->CACHE_NAME[CACHE_HASH_KEY(item->id)];
>      for (;;) {
> -        ASSERT(*now);
> +        spice_assert(*now);
>          if (*now == item) {
>              *now = item->u.cache_data.next;
>              break;
> diff --git a/server/red_client_shared_cache.h b/server/red_client_shared_cache.h
> index fb405c3..821ee18 100644
> --- a/server/red_client_shared_cache.h
> +++ b/server/red_client_shared_cache.h
> @@ -49,7 +49,7 @@ static int FUNC_NAME(hit)(CACHE *cache, uint64_t id, int *lossy, DisplayChannelC
>          if (item->id == id) {
>              ring_remove(&item->lru_link);
>              ring_add(&cache->lru, &item->lru_link);
> -            ASSERT(dcc->common.id < MAX_CACHE_CLIENTS)
> +            spice_assert(dcc->common.id < MAX_CACHE_CLIENTS);
>              item->sync[dcc->common.id] = serial;
>              cache->sync[dcc->common.id] = serial;
>              *lossy = item->lossy;
> @@ -86,7 +86,7 @@ static int FUNC_NAME(add)(CACHE *cache, uint64_t id, uint32_t size, int lossy, D
>      uint64_t serial;
>      int key;
>  
> -    ASSERT(size > 0);
> +    spice_assert(size > 0);
>  
>      item = spice_new(NewCacheItem, 1);
>      serial = red_channel_client_get_message_serial(&dcc->common.base);
> @@ -119,7 +119,7 @@ static int FUNC_NAME(add)(CACHE *cache, uint64_t id, uint32_t size, int lossy, D
>  
>          now = &cache->hash_table[CACHE_HASH_KEY(tail->id)];
>          for (;;) {
> -            ASSERT(*now);
> +            spice_assert(*now);
>              if (*now == tail) {
>                  *now = tail->next;
>                  break;
> @@ -217,7 +217,7 @@ static int FUNC_NAME(freeze)(CACHE *cache)
>  
>  static void FUNC_NAME(destroy)(CACHE *cache)
>  {
> -    ASSERT(cache);
> +    spice_assert(cache);
>  
>      pthread_mutex_lock(&cache->lock);
>      PRIVATE_FUNC_NAME(clear)(cache);
> diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
> index 1aa619c..0d16156 100644
> --- a/server/red_dispatcher.c
> +++ b/server/red_dispatcher.c
> @@ -43,13 +43,6 @@
>  
>  static int num_active_workers = 0;
>  
> -//volatile
> -
> -#define DBG_ASYNC(s, ...)   \
> -    do {                    \
> -        red_printf_debug(2, "ASYNC", s, ##__VA_ARGS__);   \
> -    } while (0)
> -
>  struct AsyncCommand {
>      RingItem link;
>      RedWorkerMessage message;
> @@ -97,7 +90,7 @@ static void red_dispatcher_set_display_peer(RedChannel *channel, RedClient *clie
>      RedWorkerMessageDisplayConnect payload;
>      RedDispatcher *dispatcher;
>  
> -    red_printf("");
> +    spice_printerr("");
>      dispatcher = (RedDispatcher *)channel->data;
>      payload.client = client;
>      payload.stream = stream;
> @@ -126,7 +119,7 @@ static void red_dispatcher_disconnect_display_peer(RedChannelClient *rcc)
>  
>      dispatcher = (RedDispatcher *)rcc->channel->data;
>  
> -    red_printf("");
> +    spice_printerr("");
>      payload.rcc = rcc;
>  
>      // TODO: we turned it to be sync, due to client_destroy . Should we support async? - for this we will need ref count
> @@ -144,7 +137,7 @@ static void red_dispatcher_display_migrate(RedChannelClient *rcc)
>          return;
>      }
>      dispatcher = (RedDispatcher *)rcc->channel->data;
> -    red_printf("channel type %u id %u", rcc->channel->type, rcc->channel->id);
> +    spice_printerr("channel type %u id %u", rcc->channel->type, rcc->channel->id);
>      payload.rcc = rcc;
>      dispatcher_send_message(&dispatcher->dispatcher,
>                              RED_WORKER_MESSAGE_DISPLAY_MIGRATE,
> @@ -158,7 +151,7 @@ static void red_dispatcher_set_cursor_peer(RedChannel *channel, RedClient *clien
>  {
>      RedWorkerMessageCursorConnect payload;
>      RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
> -    red_printf("");
> +    spice_printerr("");
>      payload.client = client;
>      payload.stream = stream;
>      payload.migration = migration;
> @@ -185,7 +178,7 @@ static void red_dispatcher_disconnect_cursor_peer(RedChannelClient *rcc)
>      }
>  
>      dispatcher = (RedDispatcher *)rcc->channel->data;
> -    red_printf("");
> +    spice_printerr("");
>      payload.rcc = rcc;
>  
>      dispatcher_send_message(&dispatcher->dispatcher,
> @@ -202,7 +195,7 @@ static void red_dispatcher_cursor_migrate(RedChannelClient *rcc)
>          return;
>      }
>      dispatcher = (RedDispatcher *)rcc->channel->data;
> -    red_printf("channel type %u id %u", rcc->channel->type, rcc->channel->id);
> +    spice_printerr("channel type %u id %u", rcc->channel->type, rcc->channel->id);
>      payload.rcc = rcc;
>      dispatcher_send_message(&dispatcher->dispatcher,
>                              RED_WORKER_MESSAGE_CURSOR_MIGRATE,
> @@ -312,7 +305,7 @@ static AsyncCommand *async_command_alloc(RedDispatcher *dispatcher,
>      async_command->message = message;
>      ring_add(&dispatcher->async_commands, &async_command->link);
>      pthread_mutex_unlock(&dispatcher->async_lock);
> -    DBG_ASYNC("%p", async_command);
> +    spice_debug("%p", async_command);
>      return async_command;
>  }
>  
> @@ -674,7 +667,7 @@ static void red_dispatcher_loadvm_commands(RedDispatcher *dispatcher,
>  {
>      RedWorkerMessageLoadvmCommands payload;
>  
> -    red_printf("");
> +    spice_printerr("");
>      payload.count = count;
>      payload.ext = ext;
>      dispatcher_send_message(&dispatcher->dispatcher,
> @@ -700,7 +693,7 @@ void red_dispatcher_set_mm_time(uint32_t mm_time)
>  
>  static inline int calc_compression_level(void)
>  {
> -    ASSERT(streaming_video != STREAM_VIDEO_INVALID);
> +    spice_assert(streaming_video != STREAM_VIDEO_INVALID);
>      if ((streaming_video != STREAM_VIDEO_OFF) ||
>          (image_compression != SPICE_IMAGE_COMPRESS_QUIC)) {
>          return 0;
> @@ -919,9 +912,9 @@ void red_dispatcher_async_complete(struct RedDispatcher *dispatcher,
>  {
>      pthread_mutex_lock(&dispatcher->async_lock);
>      ring_remove(&async_command->link);
> -    DBG_ASYNC("%p: cookie %" PRId64, async_command, async_command->cookie);
> +    spice_debug("%p: cookie %" PRId64, async_command, async_command->cookie);
>      if (ring_is_empty(&dispatcher->async_commands)) {
> -        red_printf_debug(2, "ASYNC", "no more async commands");
> +        spice_debug("no more async commands");
>      }
>      pthread_mutex_unlock(&dispatcher->async_lock);
>      switch (async_command->message) {
> @@ -942,7 +935,7 @@ void red_dispatcher_async_complete(struct RedDispatcher *dispatcher,
>      case RED_WORKER_MESSAGE_FLUSH_SURFACES_ASYNC:
>          break;
>      default:
> -        WARN("unexpected message");
> +        spice_warning("unexpected message %d", async_command->message);
>      }
>      dispatcher->qxl->st->qif->async_complete(dispatcher->qxl,
>                                               async_command->cookie);
> @@ -994,7 +987,7 @@ RedDispatcher *red_dispatcher_init(QXLInstance *qxl)
>  
>      red_dispatcher = spice_new0(RedDispatcher, 1);
>      ring_init(&red_dispatcher->async_commands);
> -    DBG_ASYNC("red_dispatcher->async_commands.next %p", red_dispatcher->async_commands.next);
> +    spice_debug("red_dispatcher->async_commands.next %p", red_dispatcher->async_commands.next);
>      dispatcher_init(&red_dispatcher->dispatcher, RED_WORKER_MESSAGE_COUNT, NULL);
>      init_data.qxl = red_dispatcher->qxl = qxl;
>      init_data.id = qxl->id;
> @@ -1045,12 +1038,12 @@ RedDispatcher *red_dispatcher_init(QXLInstance *qxl)
>      sigdelset(&thread_sig_mask, SIGSEGV);
>      pthread_sigmask(SIG_SETMASK, &thread_sig_mask, &curr_sig_mask);
>      if ((r = pthread_create(&red_dispatcher->worker_thread, NULL, red_worker_main, &init_data))) {
> -        red_error("create thread failed %d", r);
> +        spice_error("create thread failed %d", r);
>      }
>      pthread_sigmask(SIG_SETMASK, &curr_sig_mask, NULL);
>  
>      read_message(red_dispatcher->dispatcher.send_fd, &message);
> -    ASSERT(message == RED_WORKER_MESSAGE_READY);
> +    spice_assert(message == RED_WORKER_MESSAGE_READY);
>  
>      display_channel = red_dispatcher_display_channel_create(red_dispatcher);
>  
> diff --git a/server/red_memslots.c b/server/red_memslots.c
> index d98f38c..d727a09 100644
> --- a/server/red_memslots.c
> +++ b/server/red_memslots.c
> @@ -53,19 +53,19 @@ unsigned long get_virt_delta(RedMemSlotInfo *info, unsigned long addr, int group
>      int generation;
>  
>      if (group_id > info->num_memslots_groups) {
> -        PANIC("group_id %d too big", group_id);
> +        spice_critical("group_id %d too big", group_id);
>      }
>  
>      slot_id = get_memslot_id(info, addr);
>      if (slot_id > info->num_memslots) {
> -        PANIC("slot_id %d too big", slot_id);
> +        spice_critical("slot_id %d too big", slot_id);
>      }
>  
>      slot = &info->mem_slots[group_id][slot_id];
>  
>      generation = get_generation(info, addr);
>      if (generation != slot->generation) {
> -        PANIC("address generation is not valid");
> +        spice_critical("address generation is not valid");
>      }
>  
>      return (slot->address_delta - (addr - __get_clean_virt(info, addr)));
> @@ -78,12 +78,12 @@ void validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
>  
>      slot = &info->mem_slots[group_id][slot_id];
>      if ((virt + add_size) < virt) {
> -        PANIC("virtual address overlap");
> +        spice_critical("virtual address overlap");
>      }
>  
>      if (virt < slot->virt_start_addr || (virt + add_size) > slot->virt_end_addr) {
>          print_memslots(info);
> -        PANIC("virtual address out of range\n"
> +        spice_critical("virtual address out of range\n"
>                "    virt=0x%lx+0x%x slot_id=%d group_id=%d\n"
>                "    slot=0x%lx-0x%lx delta=0x%lx",
>                virt, add_size, slot_id, group_id,
> @@ -101,13 +101,13 @@ unsigned long get_virt(RedMemSlotInfo *info, unsigned long addr, uint32_t add_si
>      MemSlot *slot;
>  
>      if (group_id > info->num_memslots_groups) {
> -        PANIC("group_id too big");
> +        spice_critical("group_id too big");
>      }
>  
>      slot_id = get_memslot_id(info, addr);
>      if (slot_id > info->num_memslots) {
>          print_memslots(info);
> -        PANIC("slot_id too big, addr=%lx", addr);
> +        spice_critical("slot_id too big, addr=%lx", addr);
>      }
>  
>      slot = &info->mem_slots[group_id][slot_id];
> @@ -115,7 +115,7 @@ unsigned long get_virt(RedMemSlotInfo *info, unsigned long addr, uint32_t add_si
>      generation = get_generation(info, addr);
>      if (generation != slot->generation) {
>          print_memslots(info);
> -        PANIC("address generation is not valid, group_id %d, slot_id %d, gen %d, slot_gen %d\n",
> +        spice_critical("address generation is not valid, group_id %d, slot_id %d, gen %d, slot_gen %d\n",
>                group_id, slot_id, generation, slot->generation);
>      }
>  
> @@ -164,8 +164,8 @@ void red_memslot_info_init(RedMemSlotInfo *info,
>  {
>      uint32_t i;
>  
> -    ASSERT(num_slots > 0);
> -    ASSERT(num_groups > 0);
> +    spice_assert(num_slots > 0);
> +    spice_assert(num_groups > 0);
>  
>      info->num_memslots_groups = num_groups;
>      info->num_memslots = num_slots;
> @@ -190,8 +190,8 @@ void red_memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uin
>                                 uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
>                                 uint32_t generation)
>  {
> -    ASSERT(info->num_memslots_groups > slot_group_id);
> -    ASSERT(info->num_memslots > slot_id);
> +    spice_assert(info->num_memslots_groups > slot_group_id);
> +    spice_assert(info->num_memslots > slot_id);
>  
>      info->mem_slots[slot_group_id][slot_id].address_delta = addr_delta;
>      info->mem_slots[slot_group_id][slot_id].virt_start_addr = virt_start;
> @@ -201,8 +201,8 @@ void red_memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uin
>  
>  void red_memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id)
>  {
> -    ASSERT(info->num_memslots_groups > slot_group_id);
> -    ASSERT(info->num_memslots > slot_id);
> +    spice_assert(info->num_memslots_groups > slot_group_id);
> +    spice_assert(info->num_memslots > slot_id);
>  
>      info->mem_slots[slot_group_id][slot_id].virt_start_addr = 0;
>      info->mem_slots[slot_group_id][slot_id].virt_end_addr = 0;
> diff --git a/server/red_parse_qxl.c b/server/red_parse_qxl.c
> index 201e683..811e427 100644
> --- a/server/red_parse_qxl.c
> +++ b/server/red_parse_qxl.c
> @@ -66,7 +66,7 @@ static uint8_t *red_linearize_chunk(RedDataChunk *head, size_t size, bool *free_
>      uint32_t copy;
>  
>      if (head->next_chunk == NULL) {
> -        ASSERT(size <= head->data_size);
> +        spice_assert(size <= head->data_size);
>          *free_chunk = false;
>          return head->data;
>      }
> @@ -79,7 +79,7 @@ static uint8_t *red_linearize_chunk(RedDataChunk *head, size_t size, bool *free_
>          ptr += copy;
>          size -= copy;
>      }
> -    ASSERT(size == 0);
> +    spice_assert(size == 0);
>      return data;
>  }
>  
> @@ -205,15 +205,15 @@ static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
>  
>          /* Protect against overflow in size calculations before
>             writing to memory */
> -        ASSERT(mem_size2 + sizeof(SpicePathSeg) > mem_size2);
> +        spice_assert(mem_size2 + sizeof(SpicePathSeg) > mem_size2);
>          mem_size2  += sizeof(SpicePathSeg);
> -        ASSERT(count < UINT32_MAX / sizeof(SpicePointFix));
> +        spice_assert(count < UINT32_MAX / sizeof(SpicePointFix));
>          dsize = count * sizeof(SpicePointFix);
> -        ASSERT(mem_size2 + dsize > mem_size2);
> +        spice_assert(mem_size2 + dsize > mem_size2);
>          mem_size2  += dsize;
>  
>          /* Verify that we didn't overflow due to guest changing data */
> -        ASSERT(mem_size2 <= mem_size);
> +        spice_assert(mem_size2 <= mem_size);
>  
>          seg->flags = start->flags;
>          seg->count = count;
> @@ -225,7 +225,7 @@ static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
>          seg = (SpicePathSeg*)(&seg->points[i]);
>      }
>      /* Ensure guest didn't tamper with segment count */
> -    ASSERT(n_segments == red->num_segments);
> +    spice_assert(n_segments == red->num_segments);
>  
>      if (free_data) {
>          free(data);
> @@ -252,7 +252,7 @@ static SpiceClipRects *red_get_clip_rects(RedMemSlotInfo *slots, int group_id,
>      data = red_linearize_chunk(&chunks, size, &free_data);
>      red_put_data_chunks(&chunks);
>  
> -    ASSERT(qxl->num_rects * sizeof(QXLRect) == size);
> +    spice_assert(qxl->num_rects * sizeof(QXLRect) == size);
>      red = spice_malloc(sizeof(*red) + qxl->num_rects * sizeof(SpiceRect));
>      red->num_rects = qxl->num_rects;
>  
> @@ -299,7 +299,7 @@ static SpiceChunks *red_get_image_data_chunked(RedMemSlotInfo *slots, int group_
>          data->chunk[i].len   = chunk->data_size;
>          data->data_size     += chunk->data_size;
>      }
> -    ASSERT(i == data->num_chunks);
> +    spice_assert(i == data->num_chunks);
>      return data;
>  }
>  
> @@ -373,7 +373,7 @@ static SpiceImage *red_get_image(RedMemSlotInfo *slots, int group_id,
>          } else {
>              size = red_get_data_chunks(slots, group_id,
>                                         &chunks, qxl->bitmap.data);
> -            ASSERT(size == bitmap_size);
> +            spice_assert(size == bitmap_size);
>              red->u.bitmap.data = red_get_image_data_chunked(slots, group_id,
>                                                              &chunks);
>              red_put_data_chunks(&chunks);
> @@ -390,14 +390,13 @@ static SpiceImage *red_get_image(RedMemSlotInfo *slots, int group_id,
>          size = red_get_data_chunks_ptr(slots, group_id,
>                                         get_memslot_id(slots, addr),
>                                         &chunks, (QXLDataChunk *)qxl->quic.data);
> -        ASSERT(size == red->u.quic.data_size);
> +        spice_assert(size == red->u.quic.data_size);
>          red->u.quic.data = red_get_image_data_chunked(slots, group_id,
>                                                        &chunks);
>          red_put_data_chunks(&chunks);
>          break;
>      default:
> -        red_error("%s: unknown type %d", __FUNCTION__, red->descriptor.type);
> -        abort();
> +        spice_error("unknown type %d", red->descriptor.type);
>      }
>      return red;
>  }
> @@ -593,7 +592,7 @@ static void red_get_stroke_ptr(RedMemSlotInfo *slots, int group_id,
>          style_nseg = qxl->attr.style_nseg;
>          red->attr.style = spice_malloc_n(style_nseg, sizeof(SPICE_FIXED28_4));
>          red->attr.style_nseg  = style_nseg;
> -        ASSERT(qxl->attr.style);
> +        spice_assert(qxl->attr.style);
>          buf = (uint8_t *)get_virt(slots, qxl->attr.style,
>                                    style_nseg * sizeof(QXLFIXED), group_id);
>          memcpy(red->attr.style, buf, style_nseg * sizeof(QXLFIXED));
> @@ -636,7 +635,7 @@ static SpiceString *red_get_string(RedMemSlotInfo *slots, int group_id,
>      red_put_data_chunks(&chunks);
>  
>      qxl_size = qxl->data_size;
> -    ASSERT(chunk_size == qxl_size);
> +    spice_assert(chunk_size == qxl_size);
>  
>      if (qxl->flags & SPICE_STRING_FLAGS_RASTER_A1) {
>          bpp = 1;
> @@ -645,21 +644,21 @@ static SpiceString *red_get_string(RedMemSlotInfo *slots, int group_id,
>      } else if (qxl->flags & SPICE_STRING_FLAGS_RASTER_A8) {
>          bpp = 8;
>      }
> -    ASSERT(bpp != 0);
> +    spice_assert(bpp != 0);
>  
>      start = (QXLRasterGlyph*)data;
>      end = (QXLRasterGlyph*)(data + chunk_size);
>      red_size = sizeof(SpiceString);
>      glyphs = 0;
>      while (start < end) {
> -        ASSERT((QXLRasterGlyph*)(&start->data[0]) <= end);
> +        spice_assert((QXLRasterGlyph*)(&start->data[0]) <= end);
>          glyphs++;
>          glyph_size = start->height * ((start->width * bpp + 7) / 8);
>          red_size += sizeof(SpiceRasterGlyph *) + SPICE_ALIGN(sizeof(SpiceRasterGlyph) + glyph_size, 4);
>          start = (QXLRasterGlyph*)(&start->data[glyph_size]);
>      }
> -    ASSERT(start <= end);
> -    ASSERT(glyphs == qxl->length);
> +    spice_assert(start <= end);
> +    spice_assert(glyphs == qxl->length);
>  
>      red = spice_malloc(red_size);
>      red->length = qxl->length;
> @@ -669,14 +668,14 @@ static SpiceString *red_get_string(RedMemSlotInfo *slots, int group_id,
>      end = (QXLRasterGlyph*)(data + chunk_size);
>      glyph = (SpiceRasterGlyph *)&red->glyphs[red->length];
>      for (i = 0; i < red->length; i++) {
> -        ASSERT((QXLRasterGlyph*)(&start->data[0]) <= end);
> +        spice_assert((QXLRasterGlyph*)(&start->data[0]) <= end);
>          red->glyphs[i] = glyph;
>          glyph->width = start->width;
>          glyph->height = start->height;
>          red_get_point_ptr(&glyph->render_pos, &start->render_pos);
>          red_get_point_ptr(&glyph->glyph_origin, &start->glyph_origin);
>          glyph_size = glyph->height * ((glyph->width * bpp + 7) / 8);
> -        ASSERT((QXLRasterGlyph*)(&start->data[glyph_size]) <= end);
> +        spice_assert((QXLRasterGlyph*)(&start->data[glyph_size]) <= end);
>          memcpy(glyph->data, start->data, glyph_size);
>          start = (QXLRasterGlyph*)(&start->data[glyph_size]);
>          glyph = (SpiceRasterGlyph*)
> @@ -831,7 +830,7 @@ static void red_get_native_drawable(RedMemSlotInfo *slots, int group_id,
>                                &red->u.whiteness, &qxl->u.whiteness, flags);
>          break;
>      default:
> -        red_error("%s: unknown type %d", __FUNCTION__, red->type);
> +        spice_error("unknown type %d", red->type);
>          break;
>      };
>  }
> @@ -911,7 +910,7 @@ static void red_get_compat_drawable(RedMemSlotInfo *slots, int group_id,
>                                &red->u.whiteness, &qxl->u.whiteness, flags);
>          break;
>      default:
> -        red_error("%s: unknown type %d", __FUNCTION__, red->type);
> +        spice_error("unknown type %d", red->type);
>          break;
>      };
>  }
> diff --git a/server/red_tunnel_worker.c b/server/red_tunnel_worker.c
> index 80e0721..ac6296f 100644
> --- a/server/red_tunnel_worker.c
> +++ b/server/red_tunnel_worker.c
> @@ -44,7 +44,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) spice_printerr("TUNNEL_DBG SOCKET(connection_id=%d port=%d, service=%d)",\
>                                      sckt->connection_id, ntohs(sckt->local_port),             \
>                                      sckt->far_service->id)
>  #endif
> @@ -479,7 +479,7 @@ static inline void tunnel_channel_activate_migrated_sockets(TunnelChannelClient
>     failed (which triggered from a call to slirp) */
>  #define SET_TUNNEL_ERROR(channel,format, ...) {   \
>      channel->tunnel_error = TRUE;                 \
> -    red_printf(format, ## __VA_ARGS__);           \
> +    spice_printerr(format, ## __VA_ARGS__);           \
>  }
>  
>  /* should be checked after each subroutine that may cause error or after calls to slirp routines */
> @@ -614,7 +614,7 @@ static void red_tunnel_channel_create(TunnelWorker *worker);
>  static void tunnel_shutdown(TunnelWorker *worker)
>  {
>      int i;
> -    red_printf("");
> +    spice_printerr("");
>      /* shutdown input from channel */
>      if (worker->channel_client) {
>          red_channel_client_shutdown(&worker->channel_client->base);
> @@ -695,7 +695,7 @@ static void snd_tunnled_buffer_release(RawTunneledBuffer *buf)
>  static inline void tunnel_socket_assign_rcv_buf(RedSocket *sckt,
>                                                  RedSocketRawRcvBuf *recv_buf, int buf_size)
>  {
> -    ASSERT(!recv_buf->base.usr_opaque);
> +    spice_assert(!recv_buf->base.usr_opaque);
>      // the rcv buffer was allocated by tunnel_channel_alloc_msg_rcv_buf
>      // before we could know which of the sockets it belongs to, so the
>      // assignment to the socket is performed now
> @@ -824,7 +824,7 @@ static void process_queue_append(TunneledBufferProcessQueue *queue, uint8_t *dat
>  static void process_queue_pop(TunneledBufferProcessQueue *queue)
>  {
>      RawTunneledBuffer *prev_head;
> -    ASSERT(queue->head && queue->tail);
> +    spice_assert(queue->head && queue->tail);
>      prev_head = queue->head;
>      queue->head = queue->head->next;
>      if (!queue->head) {
> @@ -868,7 +868,7 @@ static void ready_queue_add_orig_chunk(ReadyTunneledChunkQueue *queue, RawTunnel
>  static void ready_queue_pop_chunk(ReadyTunneledChunkQueue *queue)
>  {
>      ReadyTunneledChunk *chunk = queue->head;
> -    ASSERT(queue->head);
> +    spice_assert(queue->head);
>      queue->head = queue->head->next;
>  
>      if (!queue->head) {
> @@ -892,8 +892,8 @@ static void ready_queue_clear(ReadyTunneledChunkQueue *queue)
>  static void process_queue_simple_analysis(TunneledBufferProcessQueue *queue,
>                                            RawTunneledBuffer *start_last_added, int offset, int len)
>  {
> -    ASSERT(offset == 0);
> -    ASSERT(start_last_added == queue->head);
> +    spice_assert(offset == 0);
> +    spice_assert(start_last_added == queue->head);
>  
>      while (queue->head) {
>          ready_queue_add_orig_chunk(queue->ready_chunks_queue, queue->head, queue->head->data,
> @@ -912,7 +912,7 @@ static int process_queue_simple_get_migrate_data(TunneledBufferProcessQueue *que
>  static void process_queue_simple_release_migrate_data(TunneledBufferProcessQueue *queue,
>                                                        void *migrate_data)
>  {
> -    ASSERT(!migrate_data);
> +    spice_assert(!migrate_data);
>  }
>  
>  static void process_queue_simple_restore(TunneledBufferProcessQueue *queue, uint8_t *migrate_data)
> @@ -971,7 +971,7 @@ SPICE_GNUC_VISIBLE void spice_server_net_wire_recv_packet(SpiceNetWireInstance *
>                                                            const uint8_t *pkt, int pkt_len)
>  {
>      TunnelWorker *worker = sin->st->worker;
> -    ASSERT(worker);
> +    spice_assert(worker);
>  
>      if (worker->channel_client && worker->channel_client->base.channel->migrate) {
>          return; // during migration and the tunnel state hasn't been restored yet.
> @@ -1054,7 +1054,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");
> +                spice_printerr("failed to allocate virtual ip");
>                  free(new_service);
>                  return NULL;
>              }
> @@ -1062,7 +1062,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);
> +                spice_printerr("inconsistent name for service group %d", group);
>                  free(new_service);
>                  return NULL;
>              }
> @@ -1084,7 +1084,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",
> +    spice_printerr("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 +1137,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);
> +        spice_printerr("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],
> +    spice_printerr("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 +1159,7 @@ static int tunnel_channel_handle_service_add(TunnelChannelClient *channel,
>          out_service = tunnel_worker_add_service(channel->worker, sizeof(TunnelService),
>                                                  service_msg);
>      } else {
> -        red_printf("invalid service type");
> +        spice_printerr("invalid service type");
>      }
>  
>      free(service_msg);
> @@ -1205,7 +1205,7 @@ static inline void tunnel_worker_clear_routed_network(TunnelWorker *worker)
>          } else if (service->type == SPICE_TUNNEL_SERVICE_TYPE_IPP) {
>              tunnel_worker_free_print_service(worker, (TunnelPrintService *)service);
>          } else {
> -            red_error("unexpected service type");
> +            spice_error("unexpected service type");
>          }
>      }
>  
> @@ -1229,13 +1229,13 @@ static inline RedSocket *__tunnel_worker_find_free_socket(TunnelWorker *worker)
>          }
>      }
>  
> -    ASSERT(ret);
> +    spice_assert(ret);
>      return ret;
>  }
>  
>  static inline void __tunnel_worker_add_socket(TunnelWorker *worker, RedSocket *sckt)
>  {
> -    ASSERT(!sckt->allocated);
> +    spice_assert(!sckt->allocated);
>      sckt->allocated = TRUE;
>      worker->num_sockets++;
>  }
> @@ -1244,7 +1244,7 @@ static inline void tunnel_worker_alloc_socket(TunnelWorker *worker, RedSocket *s
>                                                uint16_t local_port, TunnelService *far_service,
>                                                SlirpSocket *slirp_s)
>  {
> -    ASSERT(far_service);
> +    spice_assert(far_service);
>      sckt->worker = worker;
>      sckt->local_port = local_port;
>      sckt->far_service = far_service;
> @@ -1272,11 +1272,11 @@ static RedSocket *tunnel_worker_create_socket(TunnelWorker *worker, uint16_t loc
>                                                SlirpSocket *slirp_s)
>  {
>      RedSocket *new_socket;
> -    ASSERT(worker);
> +    spice_assert(worker);
>      new_socket = __tunnel_worker_find_free_socket(worker);
>  
>      if (!new_socket) {
> -        red_error("creation of RedSocket failed");
> +        spice_error("creation of RedSocket failed");
>      }
>  
>      tunnel_worker_alloc_socket(worker, new_socket, local_port, far_service, slirp_s);
> @@ -1341,17 +1341,17 @@ static inline RedSocket *tunnel_worker_find_socket(TunnelWorker *worker,
>  
>  static inline void __tunnel_socket_add_fin_to_pipe(TunnelChannelClient *channel, RedSocket *sckt)
>  {
> -    ASSERT(!red_channel_client_pipe_item_is_linked(&channel->base, &sckt->out_data.status_pipe_item));
> +    spice_assert(!red_channel_client_pipe_item_is_linked(&channel->base, &sckt->out_data.status_pipe_item));
>      sckt->out_data.status_pipe_item.type = PIPE_ITEM_TYPE_SOCKET_FIN;
>      red_channel_client_pipe_add(&channel->base, &sckt->out_data.status_pipe_item);
>  }
>  
>  static inline void __tunnel_socket_add_close_to_pipe(TunnelChannelClient *channel, RedSocket *sckt)
>  {
> -    ASSERT(!channel->mig_inprogress);
> +    spice_assert(!channel->mig_inprogress);
>  
>      if (red_channel_client_pipe_item_is_linked(&channel->base, &sckt->out_data.status_pipe_item)) {
> -        ASSERT(sckt->out_data.status_pipe_item.type == PIPE_ITEM_TYPE_SOCKET_FIN);
> +        spice_assert(sckt->out_data.status_pipe_item.type == PIPE_ITEM_TYPE_SOCKET_FIN);
>          // close is stronger than FIN
>          red_channel_client_pipe_remove_and_release(&channel->base,
>                                          &sckt->out_data.status_pipe_item);
> @@ -1363,10 +1363,10 @@ static inline void __tunnel_socket_add_close_to_pipe(TunnelChannelClient *channe
>  
>  static inline void __tunnel_socket_add_close_ack_to_pipe(TunnelChannelClient *channel, RedSocket *sckt)
>  {
> -    ASSERT(!channel->mig_inprogress);
> +    spice_assert(!channel->mig_inprogress);
>  
>      if (red_channel_client_pipe_item_is_linked(&channel->base, &sckt->out_data.status_pipe_item)) {
> -        ASSERT(sckt->out_data.status_pipe_item.type == PIPE_ITEM_TYPE_SOCKET_FIN);
> +        spice_assert(sckt->out_data.status_pipe_item.type == PIPE_ITEM_TYPE_SOCKET_FIN);
>          // close is stronger than FIN
>          red_channel_client_pipe_remove_and_release(&channel->base,
>                                      &sckt->out_data.status_pipe_item);
> @@ -1414,7 +1414,7 @@ static int tunnel_channel_handle_socket_connect_ack(TunnelChannelClient *channel
>                                                      uint32_t tokens)
>  {
>  #ifdef DEBUG_NETWORK
> -    red_printf("TUNNEL_DBG");
> +    spice_printerr("TUNNEL_DBG");
>  #endif
>      if (channel->mig_inprogress || channel->base.channel->migrate) {
>          sckt->mig_client_status_msg = SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK;
> @@ -1423,21 +1423,21 @@ static int tunnel_channel_handle_socket_connect_ack(TunnelChannelClient *channel
>      }
>  
>      if (sckt->client_status != CLIENT_SCKT_STATUS_WAIT_OPEN) {
> -        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK status=%d", sckt->client_status);
> +        spice_printerr("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK status=%d", sckt->client_status);
>          return FALSE;
>      }
>      sckt->client_status = CLIENT_SCKT_STATUS_OPEN;
>  
>      // SLIRP_SCKT_STATUS_CLOSED is possible after waiting for a connection has timed out
>      if (sckt->slirp_status == SLIRP_SCKT_STATUS_CLOSED) {
> -        ASSERT(!sckt->pushed_close);
> +        spice_assert(!sckt->pushed_close);
>          __tunnel_socket_add_close_to_pipe(channel, sckt);
>      } else if (sckt->slirp_status == SLIRP_SCKT_STATUS_OPEN) {
>          sckt->out_data.window_size = tokens;
>          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);
> +        spice_printerr("unexpected slirp status status=%d", sckt->slirp_status);
>          return FALSE;
>      }
>  
> @@ -1455,7 +1455,7 @@ static int tunnel_channel_handle_socket_connect_nack(TunnelChannelClient *channe
>      }
>  
>      if (sckt->client_status != CLIENT_SCKT_STATUS_WAIT_OPEN) {
> -        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK status=%d", sckt->client_status);
> +        spice_printerr("unexpected SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK status=%d", sckt->client_status);
>          return FALSE;
>      }
>      sckt->client_status = CLIENT_SCKT_STATUS_CLOSED;
> @@ -1480,7 +1480,7 @@ static int tunnel_channel_handle_socket_fin(TunnelChannelClient *channel, RedSoc
>      }
>  
>      if (sckt->client_status != CLIENT_SCKT_STATUS_OPEN) {
> -        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_FIN status=%d", sckt->client_status);
> +        spice_printerr("unexpected SPICE_MSGC_TUNNEL_SOCKET_FIN status=%d", sckt->client_status);
>          return FALSE;
>      }
>      sckt->client_status = CLIENT_SCKT_STATUS_SHUTDOWN_SEND;
> @@ -1497,7 +1497,7 @@ static int tunnel_channel_handle_socket_fin(TunnelChannelClient *channel, RedSoc
>          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);
> +        spice_printerr("unexpected slirp status=%d", sckt->slirp_status);
>          return FALSE;
>      }
>  
> @@ -1546,7 +1546,7 @@ static int tunnel_channel_handle_socket_closed(TunnelChannelClient *channel, Red
>          // 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);
> +        spice_printerr("unexpected slirp_status=%d", sckt->slirp_status);
>          return FALSE;
>      }
>  
> @@ -1571,7 +1571,7 @@ static int tunnel_channel_handle_socket_closed_ack(TunnelChannelClient *channel,
>      }
>  
>      if (sckt->slirp_status != SLIRP_SCKT_STATUS_CLOSED) {
> -        red_printf("unexpected SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK slirp_status=%d",
> +        spice_printerr("unexpected SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK slirp_status=%d",
>                     sckt->slirp_status);
>          return FALSE;
>      }
> @@ -1585,7 +1585,7 @@ static int tunnel_channel_handle_socket_receive_data(TunnelChannelClient *channe
>  {
>      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",
> +        spice_printerr("unexpected SPICE_MSGC_TUNNEL_SOCKET_DATA client_status=%d",
>                     sckt->client_status);
>          return FALSE;
>      }
> @@ -1597,7 +1597,7 @@ static int tunnel_channel_handle_socket_receive_data(TunnelChannelClient *channe
>          return (!CHECK_TUNNEL_ERROR(channel));
>      } else if ((sckt->in_data.num_buffers == MAX_SOCKET_IN_BUFFERS) &&
>                 !channel->mig_inprogress && !channel->base.channel->migrate) {
> -        red_printf("socket in buffers overflow, socket will be closed"
> +        spice_printerr("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);
> @@ -1607,7 +1607,7 @@ static int tunnel_channel_handle_socket_receive_data(TunnelChannelClient *channe
>  
>      tunnel_socket_assign_rcv_buf(sckt, recv_data, buf_size);
>      if (!sckt->in_data.client_total_num_tokens) {
> -        red_printf("token violation");
> +        spice_printerr("token violation");
>          return FALSE;
>      }
>  
> @@ -1665,7 +1665,7 @@ static void tunnel_channel_release_msg_rcv_buf(RedChannelClient *rcc, uint16_t t
>      TunnelChannelClient *tunnel_channel = (TunnelChannelClient *)rcc->channel;
>  
>      if (type == SPICE_MSGC_TUNNEL_SOCKET_DATA) {
> -        ASSERT(!(SPICE_CONTAINEROF(msg, RedSocketRawRcvBuf, buf)->base.usr_opaque));
> +        spice_assert(!(SPICE_CONTAINEROF(msg, RedSocketRawRcvBuf, buf)->base.usr_opaque));
>          __tunnel_worker_free_socket_rcv_buf(tunnel_channel->worker,
>                                              SPICE_CONTAINEROF(msg, RedSocketRawRcvBuf, buf));
>      }
> @@ -1683,7 +1683,8 @@ static void __tunnel_channel_fill_service_migrate_item(TunnelChannelClient *chan
>          general_data = &migrate_item->u.print_service.base;
>          memcpy(migrate_item->u.print_service.ip, ((TunnelPrintService *)service)->ip, 4);
>      } else {
> -        red_error("unexpected service type");
> +        spice_error("unexpected service type");
> +        abort();
>      }
>  
>      general_data->type = service->type;
> @@ -1755,7 +1756,7 @@ static int tunnel_channel_handle_migrate_mark(RedChannelClient *base)
>      RedSocket *sckt;
>  
>      if (!channel->expect_migrate_mark) {
> -        red_printf("unexpected");
> +        spice_printerr("unexpected");
>          return FALSE;
>      }
>      channel->expect_migrate_mark = FALSE;
> @@ -1764,7 +1765,7 @@ static int tunnel_channel_handle_migrate_mark(RedChannelClient *base)
>  
>      migrate_item->slirp_state_size = net_slirp_state_export(&migrate_item->slirp_state);
>      if (!migrate_item->slirp_state) {
> -        red_printf("failed export slirp state");
> +        spice_printerr("failed export slirp state");
>          goto error;
>      }
>  
> @@ -1897,7 +1898,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);
> +    spice_printerr("TUNNEL DBG: num_tokens=%d", num_tokens);
>  #endif
>      return &buf->base.base;
>  }
> @@ -1982,7 +1983,7 @@ static void tunnel_channel_restore_migrated_socket(TunnelChannelClient *channel,
>      TunnelService *service;
>      sckt = channel->worker->sockets + mig_socket->connection_id;
>      sckt->connection_id = mig_socket->connection_id;
> -    ASSERT(!sckt->allocated);
> +    spice_assert(!sckt->allocated);
>  
>      /* Services must be restored before sockets */
>      service = tunnel_worker_find_service_by_id(channel->worker, mig_socket->far_service_id);
> @@ -2061,7 +2062,7 @@ static void tunnel_channel_restore_migrated_socket(TunnelChannelClient *channel,
>  static void tunnel_channel_restore_socket_state(TunnelChannelClient *channel, RedSocket *sckt)
>  {
>      int ret = TRUE;
> -    red_printf("");
> +    spice_printerr("");
>      // handling client status msgs that were received during migration
>      switch (sckt->mig_client_status_msg) {
>      case 0:
> @@ -2183,18 +2184,18 @@ static uint64_t tunnel_channel_handle_migrate_data(RedChannelClient *base,
>      int i;
>  
>      if (size < sizeof(TunnelMigrateData)) {
> -        red_printf("bad message size");
> +        spice_printerr("bad message size");
>          goto error;
>      }
>      if (!channel->expect_migrate_data) {
> -        red_printf("unexpected");
> +        spice_printerr("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");
> +        spice_printerr("invalid content");
>          goto error;
>      }
>  
> @@ -2208,7 +2209,7 @@ static uint64_t tunnel_channel_handle_migrate_data(RedChannelClient *base,
>                                                                          services_list->services[i]),
>                                                  migrate_data->data);
>          if (CHECK_TUNNEL_ERROR(channel)) {
> -            red_printf("failed restoring service");
> +            spice_printerr("failed restoring service");
>              goto error;
>          }
>      }
> @@ -2221,7 +2222,7 @@ static uint64_t tunnel_channel_handle_migrate_data(RedChannelClient *base,
>                                                                         sockets_list->sockets[i]),
>                                                 migrate_data->data);
>          if (CHECK_TUNNEL_ERROR(channel)) {
> -            red_printf("failed restoring socket");
> +            spice_printerr("failed restoring socket");
>              goto error;
>          }
>      }
> @@ -2265,7 +2266,7 @@ static int tunnel_channel_handle_message(RedChannelClient *rcc, uint16_t type,
>          // 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");
> +            spice_printerr("red socket not found");
>              return FALSE;
>          }
>          break;
> @@ -2276,18 +2277,18 @@ static int tunnel_channel_handle_message(RedChannelClient *rcc, uint16_t type,
>      switch (type) {
>      case SPICE_MSGC_TUNNEL_SERVICE_ADD:
>          if (size < sizeof(SpiceMsgcTunnelAddGenericService)) {
> -            red_printf("bad message size");
> +            spice_printerr("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");
> +        spice_printerr("REDC_TUNNEL_REMOVE_SERVICE not supported yet");
>          return FALSE;
>      case SPICE_MSGC_TUNNEL_SOCKET_OPEN_ACK:
>          if (size != sizeof(SpiceMsgcTunnelSocketOpenAck)) {
> -            red_printf("bad message size");
> +            spice_printerr("bad message size");
>              return FALSE;
>          }
>  
> @@ -2296,7 +2297,7 @@ static int tunnel_channel_handle_message(RedChannelClient *rcc, uint16_t type,
>  
>      case SPICE_MSGC_TUNNEL_SOCKET_OPEN_NACK:
>          if (size != sizeof(SpiceMsgcTunnelSocketOpenNack)) {
> -            red_printf("bad message size");
> +            spice_printerr("bad message size");
>              return FALSE;
>          }
>  
> @@ -2304,7 +2305,7 @@ static int tunnel_channel_handle_message(RedChannelClient *rcc, uint16_t type,
>      case SPICE_MSGC_TUNNEL_SOCKET_DATA:
>      {
>          if (size < sizeof(SpiceMsgcTunnelSocketData)) {
> -            red_printf("bad message size");
> +            spice_printerr("bad message size");
>              return FALSE;
>          }
>  
> @@ -2314,25 +2315,25 @@ static int tunnel_channel_handle_message(RedChannelClient *rcc, uint16_t type,
>      }
>      case SPICE_MSGC_TUNNEL_SOCKET_FIN:
>          if (size != sizeof(SpiceMsgcTunnelSocketFin)) {
> -            red_printf("bad message size");
> +            spice_printerr("bad message size");
>              return FALSE;
>          }
>          return tunnel_channel_handle_socket_fin(tunnel_channel, sckt);
>      case SPICE_MSGC_TUNNEL_SOCKET_CLOSED:
>          if (size != sizeof(SpiceMsgcTunnelSocketClosed)) {
> -            red_printf("bad message size");
> +            spice_printerr("bad message size");
>              return FALSE;
>          }
>          return tunnel_channel_handle_socket_closed(tunnel_channel, sckt);
>      case SPICE_MSGC_TUNNEL_SOCKET_CLOSED_ACK:
>          if (size != sizeof(SpiceMsgcTunnelSocketClosedAck)) {
> -            red_printf("bad message size");
> +            spice_printerr("bad message size");
>              return FALSE;
>          }
>          return tunnel_channel_handle_socket_closed_ack(tunnel_channel, sckt);
>      case SPICE_MSGC_TUNNEL_SOCKET_TOKEN:
>          if (size != sizeof(SpiceMsgcTunnelSocketTokens)) {
> -            red_printf("bad message size");
> +            spice_printerr("bad message size");
>              return FALSE;
>          }
>  
> @@ -2352,7 +2353,7 @@ static void tunnel_channel_marshall_migrate(RedChannelClient *rcc, SpiceMarshall
>  {
>      TunnelChannelClient *tunnel_channel;
>  
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      tunnel_channel = SPICE_CONTAINEROF(rcc->channel, TunnelChannelClient, base);
>      tunnel_channel->send_data.u.migrate.flags =
>          SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER;
> @@ -2417,7 +2418,8 @@ static int __tunnel_channel_marshall_service_migrate_data(TunnelChannelClient *c
>                              sizeof(item->u.print_service));
>          cur_offset += sizeof(item->u.print_service);
>      } else {
> -        red_error("unexpected service type");
> +        spice_error("unexpected service type");
> +        abort();
>      }
>  
>      generic_data->name = cur_offset;
> @@ -2506,7 +2508,7 @@ static void tunnel_channel_marshall_migrate_data(RedChannelClient *rcc,
>      int i;
>  
>      uint32_t data_buf_offset = 0; // current location in data[0] field
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      tunnel_channel = SPICE_CONTAINEROF(rcc->channel, TunnelChannelClient, base);
>      migrate_data = &tunnel_channel->send_data.u.migrate_data;
>  
> @@ -2550,7 +2552,7 @@ static void tunnel_channel_marshall_init(RedChannelClient *rcc, SpiceMarshaller
>  {
>      TunnelChannelClient *channel;
>  
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      channel = SPICE_CONTAINEROF(rcc->channel, TunnelChannelClient, base);
>      channel->send_data.u.init.max_socket_data_size = MAX_SOCKET_DATA_SIZE;
>      channel->send_data.u.init.max_num_of_sockets = MAX_SOCKETS_NUM;
> @@ -2601,11 +2603,11 @@ static void tunnel_channel_marshall_socket_fin(RedChannelClient *rcc, SpiceMarsh
>      RedSocketOutData *sckt_out_data = SPICE_CONTAINEROF(item, RedSocketOutData, status_pipe_item);
>      RedSocket *sckt = SPICE_CONTAINEROF(sckt_out_data, RedSocket, out_data);
>  
> -    ASSERT(!sckt->out_data.ready_chunks_queue.head);
> +    spice_assert(!sckt->out_data.ready_chunks_queue.head);
>  
>      tunnel_channel = SPICE_CONTAINEROF(rcc->channel, TunnelChannelClient, base);
>      if (sckt->out_data.process_queue->head) {
> -        red_printf("socket sent FIN but there are still buffers in outgoing process queue"
> +        spice_printerr("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);
>      }
> @@ -2629,14 +2631,14 @@ static void tunnel_channel_marshall_socket_close(RedChannelClient *rcc, SpiceMar
>      tunnel_channel = SPICE_CONTAINEROF(rcc->channel, TunnelChannelClient, base);
>      // 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"
> +        spice_printerr("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"
> +        spice_printerr("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);
>      }
> @@ -2668,7 +2670,7 @@ static void tunnel_channel_marshall_socket_closed_ack(RedChannelClient *rcc, Spi
>      PRINT_SCKT(sckt);
>  #endif
>  
> -    ASSERT(sckt->client_waits_close_ack && (sckt->client_status == CLIENT_SCKT_STATUS_CLOSED));
> +    spice_assert(sckt->client_waits_close_ack && (sckt->client_status == CLIENT_SCKT_STATUS_CLOSED));
>      tunnel_worker_free_socket(tunnel_channel->worker, sckt);
>      if (CHECK_TUNNEL_ERROR(tunnel_channel)) {
>          tunnel_shutdown(tunnel_channel->worker);
> @@ -2690,12 +2692,12 @@ static void tunnel_channel_marshall_socket_token(RedChannelClient *rcc, SpiceMar
>      if (sckt->in_data.num_tokens > 0) {
>          tunnel_channel->send_data.u.socket_token.num_tokens = sckt->in_data.num_tokens;
>      } else {
> -        ASSERT(!sckt->in_data.client_total_num_tokens && !sckt->in_data.ready_chunks_queue.head);
> +        spice_assert(!sckt->in_data.client_total_num_tokens && !sckt->in_data.ready_chunks_queue.head);
>          tunnel_channel->send_data.u.socket_token.num_tokens = SOCKET_TOKENS_TO_SEND_FOR_PROCESS;
>      }
>      sckt->in_data.num_tokens -= tunnel_channel->send_data.u.socket_token.num_tokens;
>      sckt->in_data.client_total_num_tokens += tunnel_channel->send_data.u.socket_token.num_tokens;
> -    ASSERT(sckt->in_data.client_total_num_tokens <= SOCKET_WINDOW_SIZE);
> +    spice_assert(sckt->in_data.client_total_num_tokens <= SOCKET_WINDOW_SIZE);
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_TUNNEL_SOCKET_TOKEN, item);
>      spice_marshaller_add_ref(m, (uint8_t*)&tunnel_channel->send_data.u.socket_token,
> @@ -2712,7 +2714,7 @@ static void tunnel_channel_marshall_socket_out_data(RedChannelClient *rcc, Spice
>      uint32_t total_push_size = 0;
>      uint32_t pushed_bufs_num = 0;
>  
> -    ASSERT(!sckt->pushed_close);
> +    spice_assert(!sckt->pushed_close);
>      if (sckt->client_status == CLIENT_SCKT_STATUS_CLOSED) {
>          return;
>      }
> @@ -2721,9 +2723,9 @@ static void tunnel_channel_marshall_socket_out_data(RedChannelClient *rcc, Spice
>          return; // only when an we will receive tokens, data will be sent again.
>      }
>  
> -    ASSERT(sckt->out_data.ready_chunks_queue.head);
> -    ASSERT(!sckt->out_data.push_tail);
> -    ASSERT(sckt->out_data.ready_chunks_queue.head->size <= MAX_SOCKET_DATA_SIZE);
> +    spice_assert(sckt->out_data.ready_chunks_queue.head);
> +    spice_assert(!sckt->out_data.push_tail);
> +    spice_assert(sckt->out_data.ready_chunks_queue.head->size <= MAX_SOCKET_DATA_SIZE);
>  
>      tunnel_channel->send_data.u.socket_data.connection_id = sckt->connection_id;
>  
> @@ -2763,7 +2765,7 @@ static void tunnel_worker_release_socket_out_data(TunnelWorker *worker, PipeItem
>      RedSocketOutData *sckt_out_data = SPICE_CONTAINEROF(item, RedSocketOutData, data_pipe_item);
>      RedSocket *sckt = SPICE_CONTAINEROF(sckt_out_data, RedSocket, out_data);
>  
> -    ASSERT(sckt_out_data->ready_chunks_queue.head);
> +    spice_assert(sckt_out_data->ready_chunks_queue.head);
>  
>      while (sckt_out_data->ready_chunks_queue.head != sckt_out_data->push_tail) {
>          sckt_out_data->data_size -= sckt_out_data->ready_chunks_queue.head->size;
> @@ -2850,7 +2852,7 @@ static void tunnel_channel_send_item(RedChannelClient *rcc, PipeItem *item)
>          tunnel_channel_marshall_migrate_data(rcc, m, item);
>          break;
>      default:
> -        red_error("invalid pipe item type");
> +        spice_error("invalid pipe item type");
>      }
>      red_channel_client_begin_send_message(rcc);
>  }
> @@ -2886,7 +2888,7 @@ static void tunnel_channel_release_pipe_item(RedChannelClient *rcc, PipeItem *it
>          release_migrate_item((TunnelMigrateItem *)item);
>          break;
>      default:
> -        red_error("invalid pipe item type");
> +        spice_error("invalid pipe item type");
>      }
>  }
>  
> @@ -2924,14 +2926,14 @@ static int tunnel_socket_connect(SlirpUsrNetworkInterface *usr_interface,
>      RedSocket *sckt;
>      TunnelService *far_service;
>  
> -    ASSERT(usr_interface);
> +    spice_assert(usr_interface);
>  
>  #ifdef DEBUG_NETWORK
> -    red_printf("TUNNEL_DBG");
> +    spice_printerr("TUNNEL_DBG");
>  #endif
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
> -    ASSERT(worker->channel_client);
> -    ASSERT(!worker->channel_client->mig_inprogress);
> +    spice_assert(worker->channel_client);
> +    spice_assert(!worker->channel_client->mig_inprogress);
>  
>      far_service = tunnel_worker_find_service_by_addr(worker, &dst_addr, (uint32_t)ntohs(dst_port));
>  
> @@ -2941,13 +2943,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");
> +        spice_printerr("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");
> +        spice_printerr("number of tunneled sockets exceeds the limit");
>          errno = ENFILE;
>          return -1;
>      }
> @@ -2979,12 +2981,12 @@ static int tunnel_socket_send(SlirpUsrNetworkInterface *usr_interface, UserSocke
>      RedSocket *sckt;
>      size_t size_to_send;
>  
> -    ASSERT(usr_interface);
> -    ASSERT(opaque);
> +    spice_assert(usr_interface);
> +    spice_assert(opaque);
>  
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
>  
> -    ASSERT(!worker->channel_client->mig_inprogress);
> +    spice_assert(!worker->channel_client->mig_inprogress);
>  
>      sckt = (RedSocket *)opaque;
>  
> @@ -2995,7 +2997,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");
> +        spice_printerr("client socket is unable to receive data");
>          errno = ECONNRESET;
>          return -1;
>      }
> @@ -3003,7 +3005,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");
> +        spice_printerr("send was shutdown");
>          errno = EPIPE;
>          return -1;
>      }
> @@ -3026,10 +3028,10 @@ static int tunnel_socket_send(SlirpUsrNetworkInterface *usr_interface, UserSocke
>              // and buffers will be released, we will try to send again.
>              size_to_send = 0;
>          } else {
> -            ASSERT(sckt->out_data.process_queue->head);
> +            spice_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"
> +                spice_printerr("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_client, sckt);
> @@ -3084,11 +3086,11 @@ static int tunnel_socket_recv(SlirpUsrNetworkInterface *usr_interface, UserSocke
>      RedSocket *sckt;
>      int copied = 0;
>  
> -    ASSERT(usr_interface);
> -    ASSERT(opaque);
> +    spice_assert(usr_interface);
> +    spice_assert(opaque);
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
>  
> -    ASSERT(!worker->channel_client->mig_inprogress);
> +    spice_assert(!worker->channel_client->mig_inprogress);
>  
>      sckt = (RedSocket *)opaque;
>  
> @@ -3112,7 +3114,7 @@ static int tunnel_socket_recv(SlirpUsrNetworkInterface *usr_interface, UserSocke
>          return -1;
>      }
>  
> -    ASSERT((sckt->client_status == CLIENT_SCKT_STATUS_OPEN) ||
> +    spice_assert((sckt->client_status == CLIENT_SCKT_STATUS_OPEN) ||
>             (sckt->client_status == CLIENT_SCKT_STATUS_SHUTDOWN_SEND) ||
>             ((sckt->client_status == CLIENT_SCKT_STATUS_CLOSED) &&
>              (sckt->slirp_status == SLIRP_SCKT_STATUS_SHUTDOWN_SEND)));
> @@ -3121,7 +3123,7 @@ 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"
> +            spice_printerr("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);
>          }
> @@ -3139,7 +3141,7 @@ static int tunnel_socket_recv(SlirpUsrNetworkInterface *usr_interface, UserSocke
>              ready_queue_pop_chunk(&sckt->in_data.ready_chunks_queue);
>              sckt->in_data.ready_chunks_queue.offset = 0;
>          } else {
> -            ASSERT(copied == len);
> +            spice_assert(copied == len);
>              sckt->in_data.ready_chunks_queue.offset += copy_count;
>          }
>      }
> @@ -3164,15 +3166,15 @@ static void tunnel_socket_shutdown_send(SlirpUsrNetworkInterface *usr_interface,
>      TunnelWorker *worker;
>      RedSocket *sckt;
>  
> -    ASSERT(usr_interface);
> -    ASSERT(opaque);
> +    spice_assert(usr_interface);
> +    spice_assert(opaque);
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
>      sckt = (RedSocket *)opaque;
>  
>  #ifdef DEBUG_NETWORK
>      PRINT_SCKT(sckt);
>  #endif
> -    ASSERT(!worker->channel_client->mig_inprogress);
> +    spice_assert(!worker->channel_client->mig_inprogress);
>  
>      if (sckt->slirp_status == SLIRP_SCKT_STATUS_DELAY_ABORT) {
>          return;
> @@ -3181,7 +3183,7 @@ static void tunnel_socket_shutdown_send(SlirpUsrNetworkInterface *usr_interface,
>      if (sckt->slirp_status == SLIRP_SCKT_STATUS_OPEN) {
>          sckt->slirp_status = SLIRP_SCKT_STATUS_SHUTDOWN_SEND;
>      } else if (sckt->slirp_status == SLIRP_SCKT_STATUS_SHUTDOWN_RECV) {
> -        ASSERT(sckt->client_status == CLIENT_SCKT_STATUS_SHUTDOWN_SEND);
> +        spice_assert(sckt->client_status == CLIENT_SCKT_STATUS_SHUTDOWN_SEND);
>          sckt->slirp_status = SLIRP_SCKT_STATUS_WAIT_CLOSE;
>      } else {
>          SET_TUNNEL_ERROR(worker->channel_client, "unexpected tunnel_socket_shutdown_send slirp_status=%d",
> @@ -3216,15 +3218,15 @@ static void tunnel_socket_shutdown_recv(SlirpUsrNetworkInterface *usr_interface,
>      TunnelWorker *worker;
>      RedSocket *sckt;
>  
> -    ASSERT(usr_interface);
> -    ASSERT(opaque);
> +    spice_assert(usr_interface);
> +    spice_assert(opaque);
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
>      sckt = (RedSocket *)opaque;
>  
>  #ifdef DEBUG_NETWORK
>      PRINT_SCKT(sckt);
>  #endif
> -    ASSERT(!worker->channel_client->mig_inprogress);
> +    spice_assert(!worker->channel_client->mig_inprogress);
>  
>      /* failure in recv can happen after the client sckt was shutdown
>        (after client sent FIN, or after slirp sent FIN and client socket was closed */
> @@ -3253,8 +3255,8 @@ static void null_tunnel_socket_close(SlirpUsrNetworkInterface *usr_interface, Us
>      TunnelWorker *worker;
>      RedSocket *sckt;
>  
> -    ASSERT(usr_interface);
> -    ASSERT(opaque);
> +    spice_assert(usr_interface);
> +    spice_assert(opaque);
>  
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
>  
> @@ -3278,8 +3280,8 @@ static void tunnel_socket_close(SlirpUsrNetworkInterface *usr_interface, UserSoc
>      TunnelWorker *worker;
>      RedSocket *sckt;
>  
> -    ASSERT(usr_interface);
> -    ASSERT(opaque);
> +    spice_assert(usr_interface);
> +    spice_assert(opaque);
>  
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
>  
> @@ -3313,7 +3315,7 @@ static UserTimer *create_timer(SlirpUsrNetworkInterface *usr_interface,
>  {
>      TunnelWorker *worker;
>  
> -    ASSERT(usr_interface);
> +    spice_assert(usr_interface);
>  
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
>  
> @@ -3324,12 +3326,12 @@ static void arm_timer(SlirpUsrNetworkInterface *usr_interface, UserTimer *timer,
>  {
>      TunnelWorker *worker;
>  
> -    ASSERT(usr_interface);
> +    spice_assert(usr_interface);
>  
>      worker = ((RedSlirpNetworkInterface *)usr_interface)->worker;
>  #ifdef DEBUG_NETWORK
>      if (!worker->channel_client) {
> -        red_printf("channel not connected");
> +        spice_printerr("channel not connected");
>      }
>  #endif
>      if (worker->channel_client && worker->channel_client->mig_inprogress) {
> @@ -3352,12 +3354,12 @@ static int tunnel_channel_config_socket(RedChannelClient *rcc)
>      RedsStream *stream = red_channel_client_get_stream(rcc);
>  
>      if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
> -        red_printf("accept failed, %s", strerror(errno)); // can't we just use red_error?
> +        spice_printerr("accept failed, %s", strerror(errno)); // can't we just use spice_error?
>          return FALSE;
>      }
>  
>      if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          return FALSE;
>      }
>  
> @@ -3366,7 +3368,7 @@ static int tunnel_channel_config_socket(RedChannelClient *rcc)
>      if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val,
>                     sizeof(delay_val)) == -1) {
>          if (errno != ENOTSUP) {
> -            red_printf("setsockopt failed, %s", strerror(errno));
> +            spice_printerr("setsockopt failed, %s", strerror(errno));
>          }
>      }
>  
> @@ -3401,7 +3403,7 @@ static void tunnel_channel_on_disconnect(RedChannel *channel)
>      if (!channel) {
>          return;
>      }
> -    red_printf("");
> +    spice_printerr("");
>      worker = (TunnelWorker *)channel->data;
>  
>      tunnel_worker_disconnect_slirp(worker);
> @@ -3444,7 +3446,7 @@ static void handle_tunnel_channel_link(RedChannel *channel, RedClient *client,
>      TunnelWorker *worker = (TunnelWorker *)channel->data;
>  
>      if (worker->channel_client) {
> -        red_error("tunnel does not support multiple client");
> +        spice_error("tunnel does not support multiple client");
>      }
>  
>      tcc = (TunnelChannelClient*)red_channel_client_create(sizeof(TunnelChannelClient),
> @@ -3462,10 +3464,10 @@ static void handle_tunnel_channel_client_migrate(RedChannelClient *rcc)
>  {
>      TunnelChannelClient *tunnel_channel;
>  #ifdef DEBUG_NETWORK
> -    red_printf("TUNNEL_DBG: MIGRATE STARTED");
> +    spice_printerr("TUNNEL_DBG: MIGRATE STARTED");
>  #endif
>      tunnel_channel = (TunnelChannelClient *)rcc;
> -    ASSERT(tunnel_channel == tunnel_channel->worker->channel_client);
> +    spice_assert(tunnel_channel == tunnel_channel->worker->channel_client);
>      tunnel_channel->mig_inprogress = TRUE;
>      net_slirp_freeze();
>      red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_MIGRATE);
> diff --git a/server/red_worker.c b/server/red_worker.c
> index 46d46f3..276ada4 100644
> --- a/server/red_worker.c
> +++ b/server/red_worker.c
> @@ -19,6 +19,8 @@
>  #include <config.h>
>  #endif
>  
> +#define SPICE_LOG_DOMAIN "SpiceWorker"
> +
>  /* Common variable abberiviations:
>   *
>   * rcc - RedChannelClient
> @@ -1111,46 +1113,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->common.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",
> +    spice_printerr("==> Compression stats for display %u", display_channel->common.id);
> +    spice_printerr("Method   \t  count  \torig_size(MB)\tenc_size(MB)\tenc_time(s)");
> +    spice_printerr("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",
> +    spice_printerr("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",
> +    spice_printerr("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",
> +    spice_printerr("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",
> +    spice_printerr("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",
> +    spice_printerr("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",
> +    spice_printerr("-------------------------------------------------------------------");
> +    spice_printerr("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 +
> @@ -1186,15 +1188,15 @@ static inline int is_primary_surface(RedWorker *worker, uint32_t surface_id)
>  
>  static inline void __validate_surface(RedWorker *worker, uint32_t surface_id)
>  {
> -    PANIC_ON(surface_id >= worker->n_surfaces);
> +    spice_warn_if(surface_id >= worker->n_surfaces);
>  }
>  
>  static inline void validate_surface(RedWorker *worker, uint32_t surface_id)
>  {
> -    PANIC_ON(surface_id >= worker->n_surfaces);
> +    spice_warn_if(surface_id >= worker->n_surfaces);
>      if (!worker->surfaces[surface_id].context.canvas) {
> -        red_printf("failed on %d", surface_id);
> -        PANIC_ON(!worker->surfaces[surface_id].context.canvas);
> +        spice_printerr("failed on %d", surface_id);
> +        spice_warn_if(!worker->surfaces[surface_id].context.canvas);
>      }
>  }
>  
> @@ -1262,7 +1264,7 @@ static void show_red_drawable(RedWorker *worker, RedDrawable *drawable, const ch
>      case QXL_DRAW_TEXT:
>          break;
>      default:
> -        red_error("bad drawable type");
> +        spice_error("bad drawable type");
>      }
>      printf("\n");
>  }
> @@ -1361,8 +1363,8 @@ static void put_drawable_pipe_item(DrawablePipeItem *dpi)
>          return;
>      }
>  
> -    ASSERT(!ring_item_is_linked(&dpi->dpi_pipe_item.link));
> -    ASSERT(!ring_item_is_linked(&dpi->base));
> +    spice_assert(!ring_item_is_linked(&dpi->dpi_pipe_item.link));
> +    spice_assert(!ring_item_is_linked(&dpi->base));
>      release_drawable(worker, dpi->drawable);
>      free(dpi);
>  }
> @@ -1385,7 +1387,7 @@ static inline DrawablePipeItem *get_drawable_pipe_item(DisplayChannelClient *dcc
>  
>  static inline DrawablePipeItem *ref_drawable_pipe_item(DrawablePipeItem *dpi)
>  {
> -    ASSERT(dpi->drawable);
> +    spice_assert(dpi->drawable);
>      dpi->refs++;
>      return dpi;
>  }
> @@ -1404,7 +1406,7 @@ static inline void red_pipes_add_drawable(RedWorker *worker, Drawable *drawable)
>      DisplayChannelClient *dcc;
>      RingItem *dcc_ring_item;
>  
> -    PANIC_ON(!ring_is_empty(&drawable->pipes));
> +    spice_warn_if(!ring_is_empty(&drawable->pipes));
>      WORKER_FOREACH_DCC(worker, dcc_ring_item, dcc) {
>          red_pipe_add_drawable(dcc, drawable);
>      }
> @@ -1444,7 +1446,7 @@ static inline void red_pipes_add_drawable_after(RedWorker *worker,
>      }
>      if (num_other_linked != worker->display_channel->common.base.clients_num) {
>          RingItem *worker_item;
> -        red_printf("TODO: not O(n^2)");
> +        spice_printerr("TODO: not O(n^2)");
>          WORKER_FOREACH_DCC(worker, worker_item, dcc) {
>              int sent = 0;
>              DRAWABLE_FOREACH_DPI(pos_after, dpi_link, dpi_pos_after) {
> @@ -1590,7 +1592,7 @@ static SurfaceDestroyItem *get_surface_destroy_item(RedChannel *channel,
>      SurfaceDestroyItem *destroy;
>  
>      destroy = (SurfaceDestroyItem *)malloc(sizeof(SurfaceDestroyItem));
> -    PANIC_ON(!destroy);
> +    spice_warn_if(!destroy);
>  
>      destroy->surface_destroy.surface_id = surface_id;
>  
> @@ -1626,7 +1628,7 @@ static inline void red_destroy_surface(RedWorker *worker, uint32_t surface_id)
>          if (is_primary_surface(worker, surface_id)) {
>              red_reset_stream_trace(worker);
>          }
> -        ASSERT(surface->context.canvas);
> +        spice_assert(surface->context.canvas);
>  
>          surface->context.canvas->ops->destroy(surface->context.canvas);
>          if (surface->create.info) {
> @@ -1642,7 +1644,7 @@ static inline void red_destroy_surface(RedWorker *worker, uint32_t surface_id)
>              red_destroy_surface_item(worker, dcc, surface_id);
>          }
>  
> -        PANIC_ON(!ring_is_empty(&surface->depend_on_me));
> +        spice_warn_if(!ring_is_empty(&surface->depend_on_me));
>      }
>  }
>  
> @@ -1691,8 +1693,8 @@ static inline void put_red_drawable(RedWorker *worker, RedDrawable *drawable, ui
>  
>  static void remove_depended_item(DependItem *item)
>  {
> -    ASSERT(item->drawable);
> -    ASSERT(ring_item_is_linked(&item->ring_item));
> +    spice_assert(item->drawable);
> +    spice_assert(ring_item_is_linked(&item->ring_item));
>      item->drawable = NULL;
>      ring_remove(&item->ring_item);
>  }
> @@ -1729,9 +1731,9 @@ static inline void release_drawable(RedWorker *worker, Drawable *drawable)
>      RingItem *item, *next;
>  
>      if (!--drawable->refs) {
> -        ASSERT(!drawable->stream);
> -        ASSERT(!drawable->tree_item.shadow);
> -        ASSERT(ring_is_empty(&drawable->pipes));
> +        spice_assert(!drawable->stream);
> +        spice_assert(!drawable->tree_item.shadow);
> +        spice_assert(ring_is_empty(&drawable->pipes));
>          region_destroy(&drawable->tree_item.base.rgn);
>  
>          remove_drawable_dependencies(worker, drawable);
> @@ -1767,7 +1769,7 @@ static inline void remove_shadow(RedWorker *worker, DrawItem *item)
>  
>  static inline void current_remove_container(RedWorker *worker, Container *container)
>  {
> -    ASSERT(ring_is_empty(&container->items));
> +    spice_assert(ring_is_empty(&container->items));
>      worker->containers_count--;
>      ring_remove(&container->base.siblings_link);
>      region_destroy(&container->base.rgn);
> @@ -1780,7 +1782,7 @@ static inline void container_cleanup(RedWorker *worker, Container *container)
>          Container *next = container->base.container;
>          if (container->items.next != &container->items) {
>              TreeItem *item = (TreeItem *)ring_get_head(&container->items);
> -            ASSERT(item);
> +            spice_assert(item);
>              ring_remove(&item->siblings_link);
>              ring_add_after(&item->siblings_link, &container->base.siblings_link);
>              item->container = container->base.container;
> @@ -1865,7 +1867,7 @@ static inline void current_remove(RedWorker *worker, TreeItem *item)
>          } else {
>              Container *container = (Container *)now;
>  
> -            ASSERT(now->type == TREE_ITEM_TYPE_CONTAINER);
> +            spice_assert(now->type == TREE_ITEM_TYPE_CONTAINER);
>  
>              if ((ring_item = ring_get_head(&container->items))) {
>                  now = SPICE_CONTAINEROF(ring_item, TreeItem, siblings_link);
> @@ -2078,7 +2080,7 @@ static void print_base_item(const char* prefix, const TreeItem *base)
>          print_container_item(prefix, (const Container *)base);
>          break;
>      default:
> -        red_error("invalid type %u", base->type);
> +        spice_error("invalid type %u", base->type);
>      }
>  }
>  
> @@ -2090,7 +2092,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");
> +        spice_printerr("TEST: TREE: EMPTY");
>          return;
>      }
>      current_tree_for_each(ring, __show_current, NULL);
> @@ -2126,7 +2128,7 @@ static inline Ring *ring_of(RedWorker *worker, Ring *ring, TreeItem *item)
>  
>  static inline int __contained_by(RedWorker *worker, TreeItem *item, Ring *ring)
>  {
> -    ASSERT(item && ring);
> +    spice_assert(item && ring);
>      do {
>          Ring *now = ring_of(worker, ring, item);
>          if (now == ring) {
> @@ -2198,7 +2200,7 @@ static inline void __exclude_region(RedWorker *worker, Ring *ring, TreeItem *ite
>          } else {
>              Shadow *shadow;
>  
> -            ASSERT(item->type == TREE_ITEM_TYPE_SHADOW);
> +            spice_assert(item->type == TREE_ITEM_TYPE_SHADOW);
>              shadow = (Shadow *)item;
>              region_exclude(rgn, &and_rgn);
>              region_or(&shadow->on_hold, &and_rgn);
> @@ -2226,7 +2228,7 @@ static void exclude_region(RedWorker *worker, Ring *ring, RingItem *ring_item, Q
>          TreeItem *now = SPICE_CONTAINEROF(ring_item, TreeItem, siblings_link);
>          Container *container = now->container;
>  
> -        ASSERT(!region_is_empty(&now->rgn));
> +        spice_assert(!region_is_empty(&now->rgn));
>  
>          if (region_intersects(rgn, &now->rgn)) {
>              print_base_item("EXCLUDE2", now);
> @@ -2234,7 +2236,7 @@ static void exclude_region(RedWorker *worker, Ring *ring, RingItem *ring_item, Q
>              print_base_item("EXCLUDE3", now);
>  
>              if (region_is_empty(&now->rgn)) {
> -                ASSERT(now->type != TREE_ITEM_TYPE_SHADOW);
> +                spice_assert(now->type != TREE_ITEM_TYPE_SHADOW);
>                  ring_item = now->siblings_link.prev;
>                  print_base_item("EXCLUDE_REMOVE", now);
>                  current_remove(worker, now);
> @@ -2245,7 +2247,7 @@ static void exclude_region(RedWorker *worker, Ring *ring, RingItem *ring_item, Q
>                  Container *container = (Container *)now;
>                  if ((ring_item = ring_get_head(&container->items))) {
>                      ring = &container->items;
> -                    ASSERT(((TreeItem *)ring_item)->container);
> +                    spice_assert(((TreeItem *)ring_item)->container);
>                      continue;
>                  }
>                  ring_item = &now->siblings_link;
> @@ -2400,7 +2402,7 @@ static inline void red_free_stream(RedWorker *worker, Stream *stream)
>  static void red_release_stream(RedWorker *worker, Stream *stream)
>  {
>      if (!--stream->refs) {
> -        ASSERT(!ring_item_is_linked(&stream->link));
> +        spice_assert(!ring_item_is_linked(&stream->link));
>          if (stream->mjpeg_encoder) {
>              mjpeg_encoder_destroy(stream->mjpeg_encoder);
>          }
> @@ -2411,8 +2413,8 @@ static void red_release_stream(RedWorker *worker, Stream *stream)
>  
>  static inline void red_detach_stream(RedWorker *worker, Stream *stream)
>  {
> -    ASSERT(stream->current && stream->current->stream);
> -    ASSERT(stream->current->stream == stream);
> +    spice_assert(stream->current && stream->current->stream);
> +    spice_assert(stream->current->stream == stream);
>      stream->current->stream = NULL;
>      stream->current = NULL;
>  }
> @@ -2436,7 +2438,7 @@ static void push_stream_clip_by_drawable(DisplayChannelClient* dcc, StreamAgent
>      int n_rects;
>  
>      if (!item) {
> -        PANIC("alloc failed");
> +        spice_critical("alloc failed");
>      }
>  
>      if (drawable->red_drawable->clip.type == SPICE_CLIP_TYPE_NONE) {
> @@ -2460,7 +2462,7 @@ static void push_stream_clip(DisplayChannelClient* dcc, StreamAgent *agent)
>      int n_rects;
>  
>      if (!item) {
> -        PANIC("alloc failed");
> +        spice_critical("alloc failed");
>      }
>      item->clip_type = SPICE_CLIP_TYPE_RECTS;
>  
> @@ -2487,8 +2489,8 @@ static void red_attach_stream(RedWorker *worker, Drawable *drawable, Stream *str
>      StreamAgent *agent;
>      RingItem *item;
>  
> -    ASSERT(!drawable->stream && !stream->current);
> -    ASSERT(drawable && stream);
> +    spice_assert(!drawable->stream && !stream->current);
> +    spice_assert(drawable && stream);
>      stream->current = drawable;
>      drawable->stream = stream;
>      stream->last_time = drawable->creation_time;
> @@ -2508,13 +2510,13 @@ static void red_stop_stream(RedWorker *worker, Stream *stream)
>      DisplayChannelClient *dcc;
>      RingItem *item;
>  
> -    ASSERT(ring_item_is_linked(&stream->link));
> -    ASSERT(!stream->current);
> +    spice_assert(ring_item_is_linked(&stream->link));
> +    spice_assert(!stream->current);
>      WORKER_FOREACH_DCC(worker, item, dcc) {
>          StreamAgent *stream_agent;
>          stream_agent = &dcc->stream_agents[stream - worker->streams_buf];
>          region_clear(&stream_agent->vis_region);
> -        ASSERT(!pipe_item_is_linked(&stream_agent->destroy_item));
> +        spice_assert(!pipe_item_is_linked(&stream_agent->destroy_item));
>          stream->refs++;
>          red_channel_client_pipe_add(&dcc->common.base, &stream_agent->destroy_item);
>      }
> @@ -2534,7 +2536,7 @@ static inline void red_detach_stream_gracefully(RedWorker *worker, Stream *strea
>      RedChannelClient *rcc;
>      DisplayChannelClient *dcc;
>  
> -    ASSERT(stream->current);
> +    spice_assert(stream->current);
>      WORKER_FOREACH_DCC(worker, item, dcc) {
>          UpgradeItem *upgrade_item;
>          int n_rects;
> @@ -2680,7 +2682,7 @@ static inline void red_handle_streams_timout(RedWorker *worker)
>  
>  static void red_display_release_stream(RedWorker *worker, StreamAgent *agent)
>  {
> -    ASSERT(agent->stream);
> +    spice_assert(agent->stream);
>      red_release_stream(worker, agent->stream);
>  }
>  
> @@ -2734,7 +2736,7 @@ static void red_display_create_stream(DisplayChannelClient *dcc, Stream *stream)
>      StreamAgent *agent = &dcc->stream_agents[stream - dcc->common.worker->streams_buf];
>  
>      stream->refs++;
> -    ASSERT(region_is_empty(&agent->vis_region));
> +    spice_assert(region_is_empty(&agent->vis_region));
>      if (stream->current) {
>          agent->frames = 1;
>          region_clone(&agent->vis_region, &stream->current->tree_item.base.rgn);
> @@ -2758,13 +2760,13 @@ static void red_create_stream(RedWorker *worker, Drawable *drawable)
>      int stream_width;
>      int stream_height;
>  
> -    ASSERT(!drawable->stream);
> +    spice_assert(!drawable->stream);
>  
>      if (!(stream = red_alloc_stream(worker))) {
>          return;
>      }
>  
> -    ASSERT(drawable->red_drawable->type == QXL_DRAW_COPY);
> +    spice_assert(drawable->red_drawable->type == QXL_DRAW_COPY);
>      src_rect = &drawable->red_drawable->u.copy.src_area;
>      stream_width = src_rect->right - src_rect->left;
>      stream_height = src_rect->bottom - src_rect->top;
> @@ -2917,7 +2919,7 @@ static inline void pre_stream_item_swap(RedWorker *worker, Stream *stream)
>      StreamAgent *agent;
>      RingItem *ring_item;
>  
> -    ASSERT(stream->current);
> +    spice_assert(stream->current);
>  
>      if (!display_is_connected(worker)) {
>          return;
> @@ -2960,7 +2962,7 @@ static inline void pre_stream_item_swap(RedWorker *worker, Stream *stream)
>  static inline void red_update_copy_graduality(RedWorker* worker, Drawable *drawable)
>  {
>      SpiceBitmap *bitmap;
> -    ASSERT(drawable->red_drawable->type == QXL_DRAW_COPY);
> +    spice_assert(drawable->red_drawable->type == QXL_DRAW_COPY);
>  
>      if (worker->streaming_video != STREAM_VIDEO_FILTER) {
>          drawable->copy_bitmap_graduality = BITMAP_GRADUAL_INVALID;
> @@ -3209,7 +3211,7 @@ static void red_reset_stream_trace(RedWorker *worker)
>          if (!stream->current) {
>              red_stop_stream(worker, stream);
>          } else {
> -            red_printf("attached stream");
> +            spice_printerr("attached stream");
>          }
>      }
>  
> @@ -3228,7 +3230,7 @@ static inline int red_current_add(RedWorker *worker, Ring *ring, Drawable *drawa
>      RingItem *exclude_base = NULL;
>  
>      print_base_item("ADD", &item->base);
> -    ASSERT(!region_is_empty(&item->base.rgn));
> +    spice_assert(!region_is_empty(&item->base.rgn));
>      region_init(&exclude_rgn);
>      now = ring_next(ring, ring);
>  
> @@ -3296,11 +3298,11 @@ static inline int red_current_add(RedWorker *worker, Ring *ring, Drawable *drawa
>                      now = ring_next(ring, ring);
>                      continue;
>                  }
> -                ASSERT(IS_DRAW_ITEM(sibling));
> +                spice_assert(IS_DRAW_ITEM(sibling));
>                  if (!((DrawItem *)sibling)->container_root) {
>                      container = __new_container(worker, (DrawItem *)sibling);
>                      if (!container) {
> -                        red_printf("create new container failed");
> +                        spice_printerr("create new container failed");
>                          region_destroy(&exclude_rgn);
>                          return FALSE;
>                      }
> @@ -3463,17 +3465,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",
> +        spice_printerr("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",
> +        spice_printerr("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%%",
> +        spice_printerr("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 -
> @@ -3512,7 +3514,7 @@ static int surface_format_to_image_type(uint32_t surface_format)
>      case SPICE_SURFACE_FMT_32_ARGB:
>          return SPICE_BITMAP_FMT_RGBA;
>      default:
> -        PANIC("Unsupported surface format");
> +        spice_critical("Unsupported surface format");
>      }
>      return 0;
>  }
> @@ -3612,7 +3614,7 @@ static void free_one_drawable(RedWorker *worker, int force_glz_free)
>      Drawable *drawable;
>      Container *container;
>  
> -    ASSERT(ring_item);
> +    spice_assert(ring_item);
>      drawable = SPICE_CONTAINEROF(ring_item, Drawable, list_link);
>      if (force_glz_free) {
>          RingItem *glz_item, *next_item;
> @@ -3750,7 +3752,7 @@ static inline void red_process_drawable(RedWorker *worker, RedDrawable *drawable
>      int surface_id;
>      Drawable *item = get_drawable(worker, drawable->effect, drawable, group_id);
>  
> -    ASSERT(item);
> +    spice_assert(item);
>  
>      surface_id = item->surface_id;
>  
> @@ -3849,7 +3851,7 @@ static inline void red_process_surface(RedWorker *worker, RedSurfaceCmd *surface
>          break;
>      }
>      case QXL_SURFACE_CMD_DESTROY:
> -        PANIC_ON(!red_surface->context.canvas);
> +        spice_warn_if(!red_surface->context.canvas);
>          set_surface_release_info(worker, surface_id, 0, surface->release_info, group_id);
>          red_handle_depends_on_target_surface(worker, surface_id);
>          /* note that red_handle_depends_on_target_surface must be called before red_current_clear.
> @@ -3860,7 +3862,7 @@ static inline void red_process_surface(RedWorker *worker, RedSurfaceCmd *surface
>          red_destroy_surface(worker, surface_id);
>          break;
>      default:
> -            red_error("unknown surface command");
> +            spice_error("unknown surface command");
>      };
>      red_put_surface_cmd(surface);
>      free(surface);
> @@ -3919,7 +3921,7 @@ static void image_cache_remove(ImageCache *cache, ImageCacheItem *item)
>  
>      now = &cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE];
>      for (;;) {
> -        ASSERT(*now);
> +        spice_assert(*now);
>          if (*now == item) {
>              *now = item->next;
>              break;
> @@ -3944,7 +3946,7 @@ static void image_cache_put(SpiceImageCache *spice_cache, uint64_t id, pixman_im
>  #ifndef IMAGE_CACHE_AGE
>      if (cache->num_items == IMAGE_CACHE_MAX_ITEMS) {
>          ImageCacheItem *tail = (ImageCacheItem *)ring_get_tail(&cache->lru);
> -        ASSERT(tail);
> +        spice_assert(tail);
>          image_cache_remove(cache, tail);
>      }
>  #endif
> @@ -3971,7 +3973,7 @@ static pixman_image_t *image_cache_get(SpiceImageCache *spice_cache, uint64_t id
>  
>      ImageCacheItem *item = image_cache_find(cache, id);
>      if (!item) {
> -        red_error("not found");
> +        spice_error("not found");
>      }
>      return pixman_image_ref(item->image);
>  }
> @@ -4026,8 +4028,8 @@ static void localize_bitmap(RedWorker *worker, SpiceImage **image_ptr, SpiceImag
>      SpiceImage *image = *image_ptr;
>  
>      if (image == NULL) {
> -        ASSERT(drawable != NULL);
> -        ASSERT(drawable->self_bitmap != NULL);
> +        spice_assert(drawable != NULL);
> +        spice_assert(drawable->self_bitmap != NULL);
>          *image_ptr = drawable->self_bitmap;
>          return;
>      }
> @@ -4059,7 +4061,7 @@ static void localize_bitmap(RedWorker *worker, SpiceImage **image_ptr, SpiceImag
>          /* nothing */
>          break;
>      default:
> -        red_error("invalid image type");
> +        spice_error("invalid image type");
>      }
>  }
>  
> @@ -4202,7 +4204,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
>          break;
>      }
>      default:
> -        red_printf("invalid type");
> +        spice_printerr("invalid type");
>      }
>  }
>  
> @@ -4240,7 +4242,7 @@ static void validate_area(RedWorker *worker, const SpiceRect *area, uint32_t sur
>              return;
>          }
>  
> -        ASSERT(stride < 0);
> +        spice_assert(stride < 0);
>          uint8_t *dest = line_0 + (area->top * stride) + area->left * sizeof(uint32_t);
>          dest += (h - 1) * stride;
>          canvas->ops->read_bits(canvas, dest, -stride, area);
> @@ -4278,7 +4280,7 @@ static inline void __red_collect_for_update(RedWorker *worker, Ring *ring, RingI
>  
>                  if ((ring_item = ring_get_head(&container->items))) {
>                      ring = &container->items;
> -                    ASSERT(((TreeItem *)ring_item)->container);
> +                    spice_assert(((TreeItem *)ring_item)->container);
>                      continue;
>                  }
>                  ring_item = &now->siblings_link;
> @@ -4351,8 +4353,8 @@ static void red_update_area_till(RedWorker *worker, const SpiceRect *area, int s
>      Drawable *now;
>      QRegion rgn;
>  
> -    ASSERT(last);
> -    ASSERT(ring_item_is_linked(&last->list_link));
> +    spice_assert(last);
> +    spice_assert(ring_item_is_linked(&last->list_link));
>  
>      surface = &worker->surfaces[surface_id];
>  
> @@ -4469,7 +4471,7 @@ static void red_update_area(RedWorker *worker, const SpiceRect *area, int surfac
>          release_drawable(worker, now);
>  #ifdef ACYCLIC_SURFACE_DEBUG
>          if (gn != surface->current_gn) {
> -            red_error("cyclic surface dependencies");
> +            spice_error("cyclic surface dependencies");
>          }
>  #endif
>      } while (now != last);
> @@ -4531,7 +4533,7 @@ static inline void free_cursor_item(RedWorker *worker, CursorItem *item)
>      worker->free_cursor_items = (_CursorItem *)item;
>  #ifdef DEBUG_CURSORS
>      ++_cursor_count;
> -    ASSERT(_cursor_count <= NUM_CURSORS);
> +    spice_assert(_cursor_count <= NUM_CURSORS);
>  #endif
>  }
>  
> @@ -4549,7 +4551,7 @@ static CursorItem *get_cursor_item(RedWorker *worker, RedCursorCmd *cmd, uint32_
>  {
>      CursorItem *cursor_item;
>  
> -    PANIC_ON(!(cursor_item = alloc_cursor_item(worker)));
> +    spice_warn_if(!(cursor_item = alloc_cursor_item(worker)));
>  
>      cursor_item->refs = 1;
>      cursor_item->group_id = group_id;
> @@ -4560,7 +4562,7 @@ static CursorItem *get_cursor_item(RedWorker *worker, RedCursorCmd *cmd, uint32_
>  
>  static CursorPipeItem *ref_cursor_pipe_item(CursorPipeItem *item)
>  {
> -    ASSERT(item);
> +    spice_assert(item);
>      item->refs++;
>      return item;
>  }
> @@ -4578,13 +4580,13 @@ static PipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int num
>  
>  static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem *pipe_item)
>  {
> -    ASSERT(pipe_item);
> +    spice_assert(pipe_item);
>  
>      if (--pipe_item->refs) {
>          return;
>      }
>  
> -    ASSERT(!pipe_item_is_linked(&pipe_item->base));
> +    spice_assert(!pipe_item_is_linked(&pipe_item->base));
>  
>      red_release_cursor(ccc->common.worker, pipe_item->cursor_item);
>      free(pipe_item);
> @@ -4615,7 +4617,7 @@ static void qxl_process_cursor(RedWorker *worker, RedCursorCmd *cursor_cmd, uint
>          worker->cursor_trail_frequency = cursor_cmd->u.trail.frequency;
>          break;
>      default:
> -        red_error("invalid cursor command %u", cursor_cmd->type);
> +        spice_error("invalid cursor command %u", cursor_cmd->type);
>      }
>  
>      if (cursor_is_connected(worker) && (worker->mouse_mode == SPICE_MOUSE_MODE_SERVER ||
> @@ -4673,7 +4675,7 @@ static int red_process_cursor(RedWorker *worker, uint32_t max_pipe_size, int *ri
>              break;
>          }
>          default:
> -            red_error("bad command type");
> +            spice_error("bad command type");
>          }
>          n++;
>      }
> @@ -4753,7 +4755,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);
> +            spice_printerr("MESSAGE: %s", message.data);
>  #endif
>              release_info_ext.group_id = ext_cmd.group_id;
>              release_info_ext.info = message.release_info;
> @@ -4770,7 +4772,7 @@ static int red_process_commands(RedWorker *worker, uint32_t max_pipe_size, int *
>              break;
>          }
>          default:
> -            red_error("bad command type");
> +            spice_error("bad command type");
>          }
>          n++;
>          if ((worker->display_channel &&
> @@ -4791,9 +4793,8 @@ static void red_free_some(RedWorker *worker)
>      DisplayChannelClient *dcc;
>      RingItem *item;
>  
> -    red_printf_debug(3, "WORKER",
> -                     "#draw=%d, #red_draw=%d, #glz_draw=%d", worker->drawable_count,
> -                     worker->red_drawable_count, worker->glz_drawable_count);
> +    spice_debug("#draw=%d, #red_draw=%d, #glz_draw=%d", worker->drawable_count,
> +                worker->red_drawable_count, worker->glz_drawable_count);
>      WORKER_FOREACH_DCC(worker, item, dcc) {
>          GlzSharedDictionary *glz_dict = dcc ? dcc->glz_dict : NULL;
>  
> @@ -4842,7 +4843,7 @@ static ImageItem *red_add_surface_area_image(DisplayChannelClient *dcc, int surf
>      int bpp;
>      int all_set;
>  
> -    ASSERT(area);
> +    spice_assert(area);
>  
>      width = area->right - area->left;
>      height = area->bottom - area->top;
> @@ -4927,7 +4928,7 @@ static void marshaller_add_compressed(SpiceMarshaller *m,
>      size_t max = size;
>      size_t now;
>      do {
> -        ASSERT(comp_buf);
> +        spice_assert(comp_buf);
>          now = MIN(sizeof(comp_buf->buf), max);
>          max -= now;
>          spice_marshaller_add_ref(m, (uint8_t*)comp_buf->buf, now);
> @@ -5018,7 +5019,7 @@ static void red_display_free_compress_buf(DisplayChannelClient *dcc,
>      RedCompressBuf **curr_used = &dcc->send_data.used_compress_bufs;
>  
>      for (;;) {
> -        ASSERT(*curr_used);
> +        spice_assert(*curr_used);
>          if (*curr_used == buf) {
>              *curr_used = buf->next;
>              break;
> @@ -5039,7 +5040,7 @@ static void red_display_reset_compress_buf(DisplayChannelClient *dcc)
>  
>  static void red_display_destroy_compress_bufs(DisplayChannel *display_channel)
>  {
> -    ASSERT(!red_channel_is_connected(&display_channel->common.base));
> +    spice_assert(!red_channel_is_connected(&display_channel->common.base));
>      while (display_channel->free_compress_bufs) {
>          RedCompressBuf *buf = display_channel->free_compress_bufs;
>          display_channel->free_compress_bufs = buf->next;
> @@ -5089,7 +5090,7 @@ static RedGlzDrawable *red_display_get_glz_drawable(DisplayChannelClient *dcc, D
>     NOTE - the caller should set the glz_instance returned by the encoder by itself.*/
>  static GlzDrawableInstanceItem *red_display_add_glz_drawable_instance(RedGlzDrawable *glz_drawable)
>  {
> -    ASSERT(glz_drawable->instances_count < MAX_GLZ_DRAWABLE_INSTANCES);
> +    spice_assert(glz_drawable->instances_count < MAX_GLZ_DRAWABLE_INSTANCES);
>      // NOTE: We assume the additions are performed consecutively, without removals in the middle
>      GlzDrawableInstanceItem *ret = glz_drawable->instances_pool + glz_drawable->instances_count;
>      glz_drawable->instances_count++;
> @@ -5115,13 +5116,13 @@ static void red_display_free_glz_drawable_instance(DisplayChannelClient *dcc,
>      RedWorker *worker = display_channel->common.worker;
>      RedGlzDrawable *glz_drawable;
>  
> -    ASSERT(glz_drawable_instance);
> -    ASSERT(glz_drawable_instance->red_glz_drawable);
> +    spice_assert(glz_drawable_instance);
> +    spice_assert(glz_drawable_instance->red_glz_drawable);
>  
>      glz_drawable = glz_drawable_instance->red_glz_drawable;
>  
> -    ASSERT(glz_drawable->dcc == dcc);
> -    ASSERT(glz_drawable->instances_count);
> +    spice_assert(glz_drawable->dcc == dcc);
> +    spice_assert(glz_drawable->instances_count);
>  
>      ring_remove(&glz_drawable_instance->glz_link);
>      glz_drawable->instances_count--;
> @@ -5132,7 +5133,7 @@ static void red_display_free_glz_drawable_instance(DisplayChannelClient *dcc,
>      }
>  
>      if (ring_is_empty(&glz_drawable->instances)) {
> -        ASSERT(!glz_drawable->instances_count);
> +        spice_assert(!glz_drawable->instances_count);
>  
>          Drawable *drawable = glz_drawable->drawable;
>  
> @@ -5270,7 +5271,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);
> +    spice_printerr("%s", usr_data->message_buf);
>  
>      longjmp(usr_data->jmp_env, 1);
>  }
> @@ -5283,7 +5284,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);
> +    spice_printerr("%s", usr_data->message_buf);
>  
>      longjmp(usr_data->jmp_env, 1);
>  }
> @@ -5297,7 +5298,7 @@ static void glz_usr_error(GlzEncoderUsrContext *usr, const char *fmt, ...)
>      vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
>      va_end(ap);
>  
> -    PANIC("%s", usr_data->message_buf); // if global lz fails in the middle
> +    spice_critical("%s", usr_data->message_buf); // if global lz fails in the middle
>                                          // the consequences are not predictable since the window
>                                          // can turn to be unsynchronized between the server and
>                                          // and the client
> @@ -5311,7 +5312,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);
> +    spice_printerr("%s", usr_data->message_buf);
>  }
>  
>  static void lz_usr_warn(LzUsrContext *usr, const char *fmt, ...)
> @@ -5322,7 +5323,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);
> +    spice_printerr("%s", usr_data->message_buf);
>  }
>  
>  static void glz_usr_warn(GlzEncoderUsrContext *usr, const char *fmt, ...)
> @@ -5333,7 +5334,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);
> +    spice_printerr("%s", usr_data->message_buf);
>  }
>  
>  static void *quic_usr_malloc(QuicUsrContext *usr, int size)
> @@ -5470,7 +5471,7 @@ static int zlib_usr_more_input(ZlibEncoderUsrContext *usr, uint8_t** input)
>      int buf_size;
>  
>      if (!usr_data->u.compressed_data.next) {
> -        ASSERT(usr_data->u.compressed_data.size_left == 0);
> +        spice_assert(usr_data->u.compressed_data.size_left == 0);
>          return 0;
>      }
>  
> @@ -5519,7 +5520,7 @@ static inline void red_init_quic(RedWorker *worker)
>      worker->quic = quic_create(&worker->quic_data.usr);
>  
>      if (!worker->quic) {
> -        PANIC("create quic failed");
> +        spice_critical("create quic failed");
>      }
>  }
>  
> @@ -5536,7 +5537,7 @@ static inline void red_init_lz(RedWorker *worker)
>      worker->lz = lz_create(&worker->lz_data.usr);
>  
>      if (!worker->lz) {
> -        PANIC("create lz failed");
> +        spice_critical("create lz failed");
>      }
>  }
>  
> @@ -5561,7 +5562,7 @@ static inline void red_init_jpeg(RedWorker *worker)
>      worker->jpeg = jpeg_encoder_create(&worker->jpeg_data.usr);
>  
>      if (!worker->jpeg) {
> -        PANIC("create jpeg encoder failed");
> +        spice_critical("create jpeg encoder failed");
>      }
>  }
>  
> @@ -5573,7 +5574,7 @@ static inline void red_init_zlib(RedWorker *worker)
>      worker->zlib = zlib_encoder_create(&worker->zlib_data.usr, ZLIB_DEFAULT_COMPRESSION_LEVEL);
>  
>      if (!worker->zlib) {
> -        PANIC("create zlib encoder failed");
> +        spice_critical("create zlib encoder failed");
>      }
>  }
>  
> @@ -5653,13 +5654,13 @@ static BitmapGradualType _get_bitmap_graduality_level(RedWorker *worker, SpiceBi
>                                                &chunk_score, &chunk_num_samples);
>              break;
>          default:
> -            red_error("invalid bitmap format (not RGB) %u", bitmap->format);
> +            spice_error("invalid bitmap format (not RGB) %u", bitmap->format);
>          }
>          score += chunk_score;
>          num_samples += chunk_num_samples;
>      }
>  
> -    ASSERT(num_samples);
> +    spice_assert(num_samples);
>      score /= num_samples;
>  
>      if (bitmap->format == SPICE_BITMAP_FMT_16BIT) {
> @@ -5681,7 +5682,7 @@ static BitmapGradualType _get_bitmap_graduality_level(RedWorker *worker, SpiceBi
>  
>  static inline int _stride_is_extra(SpiceBitmap *bitmap)
>  {
> -    ASSERT(bitmap);
> +    spice_assert(bitmap);
>      if (BITMAP_FMT_IS_RGB[bitmap->format]) {
>          return ((bitmap->x * BITMAP_FMP_BYTES_PER_PIXEL[bitmap->format]) < bitmap->stride);
>      } else {
> @@ -5699,9 +5700,11 @@ static inline int _stride_is_extra(SpiceBitmap *bitmap)
>              return bytes_width < bitmap->stride;
>          }
>          default:
> -            red_error("invalid image type %u", bitmap->format);
> +            spice_error("invalid image type %u", bitmap->format);
> +            return 0;
>          }
>      }
> +    return 0;
>  }
>  
>  static const LzImageType MAP_BITMAP_FMT_TO_LZ_IMAGE_TYPE[] = {
> @@ -5734,7 +5737,7 @@ static inline int red_glz_compress_image(DisplayChannelClient *dcc,
>  #ifdef COMPRESS_STAT
>      stat_time_t start_time = stat_now();
>  #endif
> -    ASSERT(BITMAP_FMT_IS_RGB[src->format]);
> +    spice_assert(BITMAP_FMT_IS_RGB[src->format]);
>      GlzData *glz_data = &dcc->glz_data;
>      ZlibData *zlib_data;
>      LzImageType type = MAP_BITMAP_FMT_TO_LZ_IMAGE_TYPE[src->format];
> @@ -5783,7 +5786,7 @@ static inline int red_glz_compress_image(DisplayChannelClient *dcc,
>      zlib_data->data.bufs_head = zlib_data->data.bufs_tail;
>  
>      if (!zlib_data->data.bufs_head) {
> -        red_printf("failed to allocate zlib compress buffer");
> +        spice_printerr("failed to allocate zlib compress buffer");
>          goto glz;
>      }
>  
> @@ -5946,7 +5949,7 @@ static int red_jpeg_compress_image(DisplayChannelClient *dcc, SpiceImage *dest,
>      jpeg_data->data.bufs_head = jpeg_data->data.bufs_tail;
>  
>      if (!jpeg_data->data.bufs_head) {
> -        red_printf("failed to allocate compress buffer");
> +        spice_printerr("failed to allocate compress buffer");
>          return FALSE;
>      }
>  
> @@ -6188,7 +6191,7 @@ static inline int red_compress_image(DisplayChannelClient *dcc,
>  
>      if (quic_compress) {
>  #ifdef COMPRESS_DEBUG
> -        red_printf("QUIC compress");
> +        spice_printerr("QUIC compress");
>  #endif
>          // if bitmaps is picture-like, compress it using jpeg
>          if (can_lossy && display_channel->enable_jpeg &&
> @@ -6214,7 +6217,8 @@ static inline int red_compress_image(DisplayChannelClient *dcc,
>                     (image_compression == SPICE_IMAGE_COMPRESS_LZ)) {
>              glz = FALSE;
>          } else {
> -            red_error("invalid image compression type %u", image_compression);
> +            spice_error("invalid image compression type %u", image_compression);
> +            return FALSE;
>          }
>  
>          if (glz) {
> @@ -6234,12 +6238,12 @@ static inline int red_compress_image(DisplayChannelClient *dcc,
>              ret = red_lz_compress_image(dcc, dest, src, o_comp_data,
>                                          drawable->group_id);
>  #ifdef COMPRESS_DEBUG
> -            red_printf("LZ LOCAL compress");
> +            spice_printerr("LZ LOCAL compress");
>  #endif
>          }
>  #ifdef COMPRESS_DEBUG
>          else {
> -            red_printf("LZ global compress fmt=%d", src->format);
> +            spice_printerr("LZ global compress fmt=%d", src->format);
>          }
>  #endif
>          return ret;
> @@ -6254,7 +6258,7 @@ static inline void red_display_add_image_to_pixmap_cache(RedChannelClient *rcc,
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
>  
>      if ((image->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME)) {
> -        ASSERT(image->descriptor.width * image->descriptor.height > 0);
> +        spice_assert(image->descriptor.width * image->descriptor.height > 0);
>          if (!(io_image->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_REPLACE_ME)) {
>              if (pixmap_cache_add(dcc->pixmap_cache, image->descriptor.id,
>                                   image->descriptor.width * image->descriptor.height, is_lossy,
> @@ -6294,7 +6298,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>      SpiceMarshaller *bitmap_palette_out, *lzplt_palette_out;
>  
>      if (simage == NULL) {
> -        ASSERT(drawable->self_bitmap);
> +        spice_assert(drawable->self_bitmap);
>          simage = drawable->self_bitmap;
>      }
>  
> @@ -6317,8 +6321,8 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>                  }
>                  spice_marshall_Image(m, &image,
>                                       &bitmap_palette_out, &lzplt_palette_out);
> -                ASSERT(bitmap_palette_out == NULL);
> -                ASSERT(lzplt_palette_out == NULL);
> +                spice_assert(bitmap_palette_out == NULL);
> +                spice_assert(lzplt_palette_out == NULL);
>                  stat_inc_counter(display_channel->cache_hits_counter, 1);
>                  return FILL_BITS_TYPE_CACHE;
>              } else {
> @@ -6346,8 +6350,8 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>          image.u.surface.surface_id = surface_id;
>          spice_marshall_Image(m, &image,
>                               &bitmap_palette_out, &lzplt_palette_out);
> -        ASSERT(bitmap_palette_out == NULL);
> -        ASSERT(lzplt_palette_out == NULL);
> +        spice_assert(bitmap_palette_out == NULL);
> +        spice_assert(lzplt_palette_out == NULL);
>          return FILL_BITS_TYPE_SURFACE;
>      }
>      case SPICE_IMAGE_TYPE_BITMAP: {
> @@ -6371,7 +6375,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>              fill_palette(dcc, palette, &bitmap->flags);
>              spice_marshall_Image(m, &image,
>                                   &bitmap_palette_out, &lzplt_palette_out);
> -            ASSERT(lzplt_palette_out == NULL);
> +            spice_assert(lzplt_palette_out == NULL);
>  
>              if (bitmap_palette_out && palette) {
>                  spice_marshall_Palette(bitmap_palette_out, palette);
> @@ -6385,7 +6389,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>  
>              spice_marshall_Image(m, &image,
>                                   &bitmap_palette_out, &lzplt_palette_out);
> -            ASSERT(bitmap_palette_out == NULL);
> +            spice_assert(bitmap_palette_out == NULL);
>  
>              marshaller_add_compressed(m, comp_send_data.comp_buf,
>                                        comp_send_data.comp_buf_size);
> @@ -6394,7 +6398,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>                  spice_marshall_Palette(lzplt_palette_out, comp_send_data.lzplt_palette);
>              }
>  
> -            ASSERT(!comp_send_data.is_lossy || can_lossy);
> +            spice_assert(!comp_send_data.is_lossy || can_lossy);
>              return (comp_send_data.is_lossy ? FILL_BITS_TYPE_COMPRESS_LOSSY :
>                                                FILL_BITS_TYPE_COMPRESS_LOSSLESS);
>          }
> @@ -6405,13 +6409,15 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc, SpiceMarshaller *m,
>          image.u.quic = simage->u.quic;
>          spice_marshall_Image(m, &image,
>                               &bitmap_palette_out, &lzplt_palette_out);
> -        ASSERT(bitmap_palette_out == NULL);
> -        ASSERT(lzplt_palette_out == NULL);
> +        spice_assert(bitmap_palette_out == NULL);
> +        spice_assert(lzplt_palette_out == NULL);
>          spice_marshaller_add_ref_chunks(m, image.u.quic.data);
>          return FILL_BITS_TYPE_COMPRESS_LOSSLESS;
>      default:
> -        red_error("invalid image type %u", image.descriptor.type);
> +        spice_error("invalid image type %u", image.descriptor.type);
>      }
> +
> +    return 0;
>  }
>  
>  static void fill_mask(RedChannelClient *rcc, SpiceMarshaller *m,
> @@ -6704,7 +6710,7 @@ static int pipe_rendered_drawables_intersect_with_areas(RedWorker *worker,
>      PipeItem *pipe_item;
>      Ring *pipe;
>  
> -    ASSERT(num_surfaces);
> +    spice_assert(num_surfaces);
>      pipe = &dcc->common.base.pipe;
>  
>      for (pipe_item = (PipeItem *)ring_get_head(pipe);
> @@ -6778,7 +6784,7 @@ static void red_pipe_replace_rendered_drawables_with_images(RedWorker *worker,
>          resent_areas[num_resent] = drawable->red_drawable->bbox;
>          num_resent++;
>  
> -        ASSERT(image);
> +        spice_assert(image);
>          red_channel_client_pipe_remove_and_release(&dcc->common.base, &dpi->dpi_pipe_item);
>          pipe_item = &image->link;
>      }
> @@ -7720,7 +7726,7 @@ static void red_lossy_marshall_qxl_drawable(RedWorker *worker, RedChannelClient
>          red_lossy_marshall_qxl_draw_text(worker, rcc, base_marshaller, dpi);
>          break;
>      default:
> -        red_error("invalid type");
> +        spice_error("invalid type");
>      }
>  }
>  
> @@ -7771,7 +7777,7 @@ static inline void red_marshall_qxl_drawable(RedWorker *worker, RedChannelClient
>          red_marshall_qxl_draw_text(worker, rcc, m, dpi);
>          break;
>      default:
> -        red_error("invalid type");
> +        spice_error("invalid type");
>      }
>  }
>  
> @@ -7954,7 +7960,7 @@ static inline uint8_t *red_get_image_line(RedWorker *worker, SpiceChunks *chunks
>      }
>  
>      if (chunk->len - *offset < stride) {
> -        red_printf("bad chunk alignment");
> +        spice_printerr("bad chunk alignment");
>          return NULL;
>      }
>      ret = chunk->data + *offset;
> @@ -8009,8 +8015,8 @@ static inline int red_marshall_stream_data(RedChannelClient *rcc,
>      RedWorker *worker = dcc->common.worker;
>      int n;
>  
> -    ASSERT(stream);
> -    ASSERT(drawable->red_drawable->type == QXL_DRAW_COPY);
> +    spice_assert(stream);
> +    spice_assert(drawable->red_drawable->type == QXL_DRAW_COPY);
>  
>      worker = display_channel->common.worker;
>      image = drawable->red_drawable->u.copy.src_bitmap;
> @@ -8060,7 +8066,7 @@ static inline void marshall_qxl_drawable(RedChannelClient *rcc,
>      Drawable *item = dpi->drawable;
>      DisplayChannel *display_channel = SPICE_CONTAINEROF(rcc->channel, DisplayChannel, common.base);
>  
> -    ASSERT(display_channel && rcc);
> +    spice_assert(display_channel && rcc);
>      if (item->stream && red_marshall_stream_data(rcc, m, item)) {
>          return;
>      }
> @@ -8072,7 +8078,7 @@ static inline void marshall_qxl_drawable(RedChannelClient *rcc,
>  
>  static inline void red_marshall_verb(RedChannelClient *rcc, uint16_t verb)
>  {
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      red_channel_client_init_send_data(rcc, verb, NULL);
>  }
>  
> @@ -8107,9 +8113,9 @@ static void display_channel_marshall_migrate_data(RedChannelClient *rcc,
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, NULL);
>  
> -    ASSERT(dcc->pixmap_cache);
> +    spice_assert(dcc->pixmap_cache);
>      display_data.magic = DISPLAY_MIGRATE_DATA_MAGIC;
> -    ASSERT(MAX_CACHE_CLIENTS == 4); //MIGRATE_DATA_VERSION dependent
> +    spice_assert(MAX_CACHE_CLIENTS == 4); //MIGRATE_DATA_VERSION dependent
>      display_data.version = DISPLAY_MIGRATE_DATA_VERSION;
>  
>      display_data.message_serial = red_channel_client_get_message_serial(rcc);
> @@ -8120,7 +8126,7 @@ static void display_channel_marshall_migrate_data(RedChannelClient *rcc,
>      memcpy(display_data.pixmap_cache_clients, dcc->pixmap_cache->sync,
>             sizeof(display_data.pixmap_cache_clients));
>  
> -    ASSERT(dcc->glz_dict);
> +    spice_assert(dcc->glz_dict);
>      red_freeze_glz(dcc);
>      display_data.glz_dict_id = dcc->glz_dict->id;
>      glz_enc_dictionary_get_restore_data(dcc->glz_dict->dict,
> @@ -8185,7 +8191,7 @@ static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageI
>      SpiceMarshaller *src_bitmap_out, *mask_bitmap_out;
>      SpiceMarshaller *bitmap_palette_out, *lzplt_palette_out;
>  
> -    ASSERT(rcc && display_channel && item);
> +    spice_assert(rcc && display_channel && item);
>      worker = display_channel->common.worker;
>  
>      QXL_SET_IMAGE_ID(&red_image, QXL_IMAGE_GROUP_RED, ++worker->bits_unique);
> @@ -8310,14 +8316,14 @@ static void red_display_marshall_upgrade(RedChannelClient *rcc, SpiceMarshaller
>      SpiceMsgDisplayDrawCopy copy;
>      SpiceMarshaller *src_bitmap_out, *mask_bitmap_out;
>  
> -    ASSERT(rcc && rcc->channel && item && item->drawable);
> +    spice_assert(rcc && rcc->channel && item && item->drawable);
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_DRAW_COPY, &item->base);
>  
>      red_drawable = item->drawable->red_drawable;
> -    ASSERT(red_drawable->type == QXL_DRAW_COPY);
> -    ASSERT(red_drawable->u.copy.rop_descriptor == SPICE_ROPD_OP_PUT);
> -    ASSERT(red_drawable->u.copy.mask.bitmap == 0);
> +    spice_assert(red_drawable->type == QXL_DRAW_COPY);
> +    spice_assert(red_drawable->u.copy.rop_descriptor == SPICE_ROPD_OP_PUT);
> +    spice_assert(red_drawable->u.copy.mask.bitmap == 0);
>  
>      copy.base.surface_id = 0;
>      copy.base.box = red_drawable->bbox;
> @@ -8338,7 +8344,7 @@ static void red_display_marshall_stream_start(RedChannelClient *rcc,
>      Stream *stream = agent->stream;
>  
>      agent->last_send_time = 0;
> -    ASSERT(stream);
> +    spice_assert(stream);
>      red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_CREATE, &agent->create_item);
>      SpiceMsgDisplayStreamCreate stream_create;
>      SpiceClipRects clip_rects;
> @@ -8376,7 +8382,7 @@ static void red_display_marshall_stream_clip(RedChannelClient *rcc,
>      StreamAgent *agent = item->stream_agent;
>      Stream *stream = agent->stream;
>  
> -    ASSERT(stream);
> +    spice_assert(stream);
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_CLIP, &item->base);
>      SpiceMsgDisplayStreamClip stream_clip;
> @@ -8403,7 +8409,7 @@ static void red_display_marshall_stream_end(RedChannelClient *rcc,
>  static void red_cursor_marshall_inval(RedChannelClient *rcc,
>                  SpiceMarshaller *m, CacheItem *cach_item)
>  {
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      red_marshall_inval(rcc, m, cach_item);
>  }
>  
> @@ -8416,7 +8422,7 @@ static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller *bas
>      SpiceMsgCursorInit msg;
>      AddBufInfo info;
>  
> -    ASSERT(rcc);
> +    spice_assert(rcc);
>      cursor_channel = SPICE_CONTAINEROF(rcc->channel, CursorChannel, common.base);
>      worker = cursor_channel->common.worker;
>  
> @@ -8452,7 +8458,7 @@ static void red_marshall_cursor(RedChannelClient *rcc,
>      RedCursorCmd *cmd;
>      RedWorker *worker;
>  
> -    ASSERT(cursor_channel);
> +    spice_assert(cursor_channel);
>  
>      worker = cursor_channel->common.worker;
>  
> @@ -8494,7 +8500,7 @@ static void red_marshall_cursor(RedChannelClient *rcc,
>          }
>          break;
>      default:
> -        red_error("bad cursor command %d", cmd->type);
> +        spice_error("bad cursor command %d", cmd->type);
>      }
>  }
>  
> @@ -8560,7 +8566,7 @@ static void display_channel_send_item(RedChannelClient *rcc, PipeItem *pipe_item
>          red_marshall_verb(rcc, ((VerbItem*)pipe_item)->verb);
>          break;
>      case PIPE_ITEM_TYPE_MIGRATE:
> -        red_printf("PIPE_ITEM_TYPE_MIGRATE");
> +        spice_printerr("PIPE_ITEM_TYPE_MIGRATE");
>          display_channel_marshall_migrate(rcc, m);
>          break;
>      case PIPE_ITEM_TYPE_MIGRATE_DATA:
> @@ -8592,7 +8598,7 @@ static void display_channel_send_item(RedChannelClient *rcc, PipeItem *pipe_item
>          break;
>      }
>      default:
> -        red_error("invalid pipe item type");
> +        spice_error("invalid pipe item type");
>      }
>  
>      display_channel_client_release_item_before_push(dcc, pipe_item);
> @@ -8619,7 +8625,7 @@ static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem *pipe_item)
>          red_marshall_verb(rcc, ((VerbItem*)pipe_item)->verb);
>          break;
>      case PIPE_ITEM_TYPE_MIGRATE:
> -        red_printf("PIPE_ITEM_TYPE_MIGRATE");
> +        spice_printerr("PIPE_ITEM_TYPE_MIGRATE");
>          cursor_channel_marshall_migrate(rcc, m);
>          break;
>      case PIPE_ITEM_TYPE_CURSOR_INIT:
> @@ -8631,7 +8637,7 @@ static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem *pipe_item)
>          red_marshall_verb(rcc, SPICE_MSG_CURSOR_INVAL_ALL);
>          break;
>      default:
> -        red_error("invalid pipe item type");
> +        spice_error("invalid pipe item type");
>      }
>  
>      cursor_channel_client_release_item_before_push(ccc, pipe_item);
> @@ -8661,7 +8667,7 @@ static void __show_tree_call(TreeItem *item, void *data)
>      int i;
>  
>      while (tree_data->container != item->container) {
> -        ASSERT(tree_data->container);
> +        spice_assert(tree_data->container);
>          tree_data->level--;
>          tree_data->container = tree_data->container->base.container;
>      }
> @@ -8725,11 +8731,11 @@ static void display_channel_client_on_disconnect(RedChannelClient *rcc)
>      if (!rcc) {
>          return;
>      }
> -    red_printf("");
> +    spice_printerr("");
>      common = SPICE_CONTAINEROF(rcc->channel, CommonChannel, base);
>      worker = common->worker;
>      display_channel = (DisplayChannel *)rcc->channel;
> -    ASSERT(display_channel == worker->display_channel);
> +    spice_assert(display_channel == worker->display_channel);
>  #ifdef COMPRESS_STAT
>      print_compress_stats(display_channel);
>  #endif
> @@ -8745,9 +8751,9 @@ static void display_channel_client_on_disconnect(RedChannelClient *rcc)
>      if (!red_channel_is_connected(rcc->channel)) {
>          red_display_destroy_compress_bufs(display_channel);
>      }
> -    red_printf_debug(3, "WORKER", "#draw=%d, #red_draw=%d, #glz_draw=%d",
> -                     worker->drawable_count, worker->red_drawable_count,
> -                     worker->glz_drawable_count);
> +    spice_debug("#draw=%d, #red_draw=%d, #glz_draw=%d",
> +                worker->drawable_count, worker->red_drawable_count,
> +                worker->glz_drawable_count);
>  }
>  
>  void red_disconnect_all_display_TODO_remove_me(RedChannel *channel)
> @@ -8857,8 +8863,10 @@ static inline void *create_canvas_for_surface(RedWorker *worker, RedSurface *sur
>          return canvas;
>  #endif
>      default:
> -        red_error("invalid renderer type");
> +        spice_error("invalid renderer type");
>      };
> +
> +    return NULL;
>  }
>  
>  static SurfaceCreateItem *get_surface_create_item(
> @@ -8869,7 +8877,7 @@ static SurfaceCreateItem *get_surface_create_item(
>      SurfaceCreateItem *create;
>  
>      create = (SurfaceCreateItem *)malloc(sizeof(SurfaceCreateItem));
> -    PANIC_ON(!create);
> +    spice_warn_if(!create);
>  
>      create->surface_create.surface_id = surface_id;
>      create->surface_create.width = width;
> @@ -8930,9 +8938,9 @@ static inline void red_create_surface(RedWorker *worker, uint32_t surface_id, ui
>      uint32_t i;
>  
>      if (stride >= 0) {
> -        PANIC("Untested path stride >= 0");
> +        spice_critical("Untested path stride >= 0");
>      }
> -    PANIC_ON(surface->context.canvas);
> +    spice_warn_if(surface->context.canvas);
>  
>      surface->context.canvas_draws_on_surface = FALSE;
>      surface->context.width = width;
> @@ -8955,7 +8963,7 @@ static inline void red_create_surface(RedWorker *worker, uint32_t surface_id, ui
>                                                              width, height, stride,
>                                                              surface->context.format, line_0);
>          if (!surface->context.canvas) {
> -            PANIC("drawing canvas creating failed - can`t create same type canvas");
> +            spice_critical("drawing canvas creating failed - can`t create same type canvas");
>          }
>  
>          if (send_client) {
> @@ -8983,7 +8991,7 @@ static inline void red_create_surface(RedWorker *worker, uint32_t surface_id, ui
>          }
>      }
>  
> -    PANIC("unable to create drawing canvas");
> +    spice_critical("unable to create drawing canvas");
>  }
>  
>  static inline void flush_display_commands(RedWorker *worker)
> @@ -9020,7 +9028,7 @@ static inline void flush_display_commands(RedWorker *worker)
>              // TODO: MC: the whole timeout will break since it takes lowest timeout, should
>              // do it client by client.
>              if (red_now() >= end_time) {
> -                red_printf("update timeout");
> +                spice_printerr("update timeout");
>                  red_disconnect_all_display_TODO_remove_me(channel);
>              } else {
>                  sleep_count++;
> @@ -9062,7 +9070,7 @@ static inline void flush_cursor_commands(RedWorker *worker)
>              red_channel_receive(channel);
>              red_channel_send(channel);
>              if (red_now() >= end_time) {
> -                red_printf("flush cursor timeout");
> +                spice_printerr("flush cursor timeout");
>                  red_disconnect_cursor(channel);
>              } else {
>                  sleep_count++;
> @@ -9106,15 +9114,15 @@ static int display_channel_client_wait_for_init(DisplayChannelClient *dcc)
>          if (dcc->pixmap_cache && dcc->glz_dict) {
>              dcc->pixmap_cache_generation = dcc->pixmap_cache->generation;
>              /* TODO: move common.id? if it's used for a per client structure.. */
> -            red_printf("creating encoder with id == %d", dcc->common.id);
> +            spice_printerr("creating encoder with id == %d", dcc->common.id);
>              dcc->glz = glz_encoder_create(dcc->common.id, dcc->glz_dict->dict, &dcc->glz_data.usr);
>              if (!dcc->glz) {
> -                PANIC("create global lz failed");
> +                spice_critical("create global lz failed");
>              }
>              return TRUE;
>          }
>          if (red_now() > end_time) {
> -            red_printf("timeout");
> +            spice_printerr("timeout");
>              red_channel_client_disconnect(&dcc->common.base);
>              break;
>          }
> @@ -9188,10 +9196,10 @@ static GlzSharedDictionary *red_create_glz_dictionary(DisplayChannelClient *dcc,
>                                                              MAX_LZ_ENCODERS,
>                                                              &dcc->glz_data.usr);
>  #ifdef COMPRESS_DEBUG
> -    red_printf("Lz Window %d Size=%d", id, window_size);
> +    spice_printerr("Lz Window %d Size=%d", id, window_size);
>  #endif
>      if (!glz_dict) {
> -        PANIC("failed creating lz dictionary");
> +        spice_critical("failed creating lz dictionary");
>          return NULL;
>      }
>      return _red_create_glz_dictionary(dcc->common.base.client, id, glz_dict);
> @@ -9204,7 +9212,7 @@ static GlzSharedDictionary *red_create_restored_glz_dictionary(DisplayChannelCli
>      GlzEncDictContext *glz_dict = glz_enc_dictionary_restore(restore_data,
>                                                               &dcc->glz_data.usr);
>      if (!glz_dict) {
> -        PANIC("failed creating lz dictionary");
> +        spice_critical("failed creating lz dictionary");
>          return NULL;
>      }
>      return _red_create_glz_dictionary(dcc->common.base.client, id, glz_dict);
> @@ -9341,7 +9349,7 @@ static void red_release_pixmap_cache(DisplayChannelClient *dcc)
>  
>  static int display_channel_init_cache(DisplayChannelClient *dcc, SpiceMsgcDisplayInit *init_info)
>  {
> -    ASSERT(!dcc->pixmap_cache);
> +    spice_assert(!dcc->pixmap_cache);
>      return !!(dcc->pixmap_cache = red_get_pixmap_cache(dcc->common.base.client,
>                                                         init_info->pixmap_cache_id,
>                                                         init_info->pixmap_cache_size));
> @@ -9350,7 +9358,7 @@ static int display_channel_init_cache(DisplayChannelClient *dcc, SpiceMsgcDispla
>  static int display_channel_init_glz_dictionary(DisplayChannelClient *dcc,
>                                                 SpiceMsgcDisplayInit *init_info)
>  {
> -    ASSERT(!dcc->glz_dict);
> +    spice_assert(!dcc->glz_dict);
>      ring_init(&dcc->glz_drawables);
>      ring_init(&dcc->glz_drawables_inst_to_free);
>      pthread_mutex_init(&dcc->glz_drawables_inst_to_free_lock, NULL);
> @@ -9368,7 +9376,7 @@ static int display_channel_init(DisplayChannelClient *dcc, SpiceMsgcDisplayInit
>  static int display_channel_handle_migrate_glz_dictionary(DisplayChannelClient *dcc,
>                                                           DisplayChannelMigrateData *migrate_info)
>  {
> -    ASSERT(!dcc->glz_dict);
> +    spice_assert(!dcc->glz_dict);
>      ring_init(&dcc->glz_drawables);
>      ring_init(&dcc->glz_drawables_inst_to_free);
>      pthread_mutex_init(&dcc->glz_drawables_inst_to_free_lock, NULL);
> @@ -9383,7 +9391,7 @@ static int display_channel_handle_migrate_mark(RedChannelClient *rcc)
>      RedChannel *channel = &display_channel->common.base;
>  
>      if (!display_channel->expect_migrate_mark) {
> -        red_printf("unexpected");
> +        spice_printerr("unexpected");
>          return FALSE;
>      }
>      display_channel->expect_migrate_mark = FALSE;
> @@ -9397,12 +9405,12 @@ static uint64_t display_channel_handle_migrate_data_get_serial(
>      DisplayChannelMigrateData *migrate_data = message;
>  
>      if (size < sizeof(*migrate_data)) {
> -        red_printf("bad message size");
> +        spice_printerr("bad message size");
>          return 0;
>      }
>      if (migrate_data->magic != DISPLAY_MIGRATE_DATA_MAGIC ||
>          migrate_data->version != DISPLAY_MIGRATE_DATA_VERSION) {
> -        red_printf("invalid content");
> +        spice_printerr("invalid content");
>          return 0;
>      }
>      return migrate_data->message_serial;
> @@ -9418,17 +9426,17 @@ static uint64_t display_channel_handle_migrate_data(RedChannelClient *rcc, uint3
>      int i;
>  
>      if (size < sizeof(*migrate_data)) {
> -        red_printf("bad message size");
> +        spice_printerr("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");
> +        spice_printerr("invalid content");
>          return FALSE;
>      }
>      if (!display_channel->expect_migrate_data) {
> -        red_printf("unexpected");
> +        spice_printerr("unexpected");
>          return FALSE;
>      }
>      display_channel->expect_migrate_data = FALSE;
> @@ -9455,10 +9463,10 @@ static uint64_t display_channel_handle_migrate_data(RedChannelClient *rcc, uint3
>          dcc->glz = glz_encoder_create(dcc->common.id,
>                                        dcc->glz_dict->dict, &dcc->glz_data.usr);
>          if (!dcc->glz) {
> -            PANIC("create global lz failed");
> +            spice_critical("create global lz failed");
>          }
>      } else {
> -        PANIC("restoring global lz dictionary failed");
> +        spice_critical("restoring global lz dictionary failed");
>      }
>  
>      red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_INVAL_PALLET_CACHE);
> @@ -9473,7 +9481,7 @@ static int display_channel_handle_message(RedChannelClient *rcc, uint32_t size,
>      switch (type) {
>      case SPICE_MSGC_DISPLAY_INIT:
>          if (!dcc->expect_init) {
> -            red_printf("unexpected SPICE_MSGC_DISPLAY_INIT");
> +            spice_printerr("unexpected SPICE_MSGC_DISPLAY_INIT");
>              return FALSE;
>          }
>          dcc->expect_init = FALSE;
> @@ -9492,12 +9500,12 @@ static int common_channel_config_socket(RedChannelClient *rcc)
>      int delay_val;
>  
>      if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          return FALSE;
>      }
>  
>      if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          return FALSE;
>      }
>  
> @@ -9506,7 +9514,7 @@ static int common_channel_config_socket(RedChannelClient *rcc)
>      if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val,
>                     sizeof(delay_val)) == -1) {
>          if (errno != ENOTSUP) {
> -            red_printf("setsockopt failed, %s", strerror(errno));
> +            spice_printerr("setsockopt failed, %s", strerror(errno));
>          }
>      }
>      return TRUE;
> @@ -9552,7 +9560,7 @@ static SpiceWatch *worker_watch_add(int fd, int event_mask, SpiceWatchFunc func,
>          }
>      }
>      if (i == MAX_EVENT_SOURCES) {
> -        red_printf("ERROR could not add a watch for channel type %u id %u",
> +        spice_printerr("ERROR could not add a watch for channel type %u id %u",
>                     rcc->channel->type, rcc->channel->id);
>          return NULL;
>      }
> @@ -9699,7 +9707,7 @@ error:
>  
>  static void display_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
>  {
> -    ASSERT(item);
> +    spice_assert(item);
>      switch (item->type) {
>      case PIPE_ITEM_TYPE_DRAW:
>          ref_drawable_pipe_item(SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item));
> @@ -9721,7 +9729,7 @@ static void display_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item
>          ((ImageItem *)item)->refs++;
>          break;
>      default:
> -        PANIC("invalid item type");
> +        spice_critical("invalid item type");
>      }
>  }
>  
> @@ -9754,7 +9762,7 @@ static void display_channel_client_release_item_after_push(DisplayChannelClient
>          free(item);
>          break;
>      default:
> -        PANIC("invalid item type");
> +        spice_critical("invalid item type");
>      }
>  }
>  
> @@ -9813,7 +9821,7 @@ static void display_channel_client_release_item_before_push(DisplayChannelClient
>          free(item);
>          break;
>      default:
> -        PANIC("invalid item type");
> +        spice_critical("invalid item type");
>      }
>  }
>  
> @@ -9821,11 +9829,11 @@ static void display_channel_release_item(RedChannelClient *rcc, PipeItem *item,
>  {
>      DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
>  
> -    ASSERT(item);
> +    spice_assert(item);
>      if (item_pushed) {
>          display_channel_client_release_item_after_push(dcc, item);
>      } else {
> -        red_printf_once("not pushed (%d)", item->type);
> +        spice_debug("not pushed (%d)", item->type);
>          display_channel_client_release_item_before_push(dcc, item);
>      }
>  }
> @@ -9838,7 +9846,7 @@ static void display_channel_create(RedWorker *worker, int migrate)
>          return;
>      }
>  
> -    red_printf("create display channel");
> +    spice_printerr("create display channel");
>      if (!(worker->display_channel = (DisplayChannel *)__new_channel(
>              worker, sizeof(*display_channel),
>              SPICE_CHANNEL_DISPLAY, migrate,
> @@ -9851,7 +9859,7 @@ static void display_channel_create(RedWorker *worker, int migrate)
>              display_channel_handle_migrate_data,
>              display_channel_handle_migrate_data_get_serial
>              ))) {
> -        red_printf("failed to create display channel");
> +        spice_printerr("failed to create display channel");
>          return;
>      }
>      display_channel = worker->display_channel;
> @@ -9886,18 +9894,18 @@ static void handle_new_display_channel(RedWorker *worker, RedClient *client, Red
>      int is_low_bandwidth = main_channel_client_is_low_bandwidth(red_client_get_main(client));
>  
>      if (!worker->display_channel) {
> -        red_printf("Warning: Display channel was not created");
> +        spice_printerr("Warning: Display channel was not created");
>          return;
>      }
>      display_channel = worker->display_channel;
> -    red_printf("add display channel client");
> +    spice_printerr("add display channel client");
>      dcc = display_channel_client_create(&display_channel->common, client, stream,
>                                          common_caps, num_common_caps,
>                                          caps, num_caps);
>      if (!dcc) {
>          return;
>      }
> -    red_printf("New display (client %p) dcc %p stream %p", client, dcc, stream);
> +    spice_printerr("New display (client %p) dcc %p stream %p", client, dcc, stream);
>      stream_buf_size = 32*1024;
>      dcc->send_data.stream_outbuf = spice_malloc(stream_buf_size);
>      dcc->send_data.stream_outbuf_size = stream_buf_size;
> @@ -9924,8 +9932,8 @@ static void handle_new_display_channel(RedWorker *worker, RedClient *client, Red
>                                                   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");
> +    spice_printerr("jpeg %s", display_channel->enable_jpeg ? "enabled" : "disabled");
> +    spice_printerr("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;
> @@ -9949,7 +9957,7 @@ static void red_disconnect_cursor(RedChannel *channel)
>          return;
>      }
>      common = SPICE_CONTAINEROF(channel, CommonChannel, base);
> -    ASSERT(channel == (RedChannel *)common->worker->cursor_channel);
> +    spice_assert(channel == (RedChannel *)common->worker->cursor_channel);
>      common->worker->cursor_channel = NULL;
>      red_channel_apply_clients(channel, red_reset_cursor_cache);
>      red_channel_disconnect(channel);
> @@ -9970,7 +9978,7 @@ static void on_new_cursor_channel(RedWorker *worker, RedChannelClient *rcc)
>  {
>      CursorChannel *channel = worker->cursor_channel;
>  
> -    ASSERT(channel);
> +    spice_assert(channel);
>      red_channel_client_ack_zero_messages_window(rcc);
>      red_channel_client_push_set_ack(rcc);
>      // TODO: why do we check for context.canvas? defer this to after display cc is connected
> @@ -9983,7 +9991,7 @@ static void on_new_cursor_channel(RedWorker *worker, RedChannelClient *rcc)
>  static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem *item)
>  {
>      CursorPipeItem *cursor_pipe_item;
> -    ASSERT(item);
> +    spice_assert(item);
>      cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
>      ref_cursor_pipe_item(cursor_pipe_item);
>  }
> @@ -10007,7 +10015,7 @@ static void cursor_channel_client_release_item_before_push(CursorChannelClient *
>          free(item);
>          break;
>      default:
> -        red_error("invalid pipe item type");
> +        spice_error("invalid pipe item type");
>      }
>  }
>  
> @@ -10021,7 +10029,7 @@ static void cursor_channel_client_release_item_after_push(CursorChannelClient *c
>              break;
>          }
>          default:
> -            PANIC("invalid item type");
> +            spice_critical("invalid item type");
>      }
>  }
>  
> @@ -10029,12 +10037,12 @@ static void cursor_channel_release_item(RedChannelClient *rcc, PipeItem *item, i
>  {
>      CursorChannelClient *ccc = RCC_TO_CCC(rcc);
>  
> -    ASSERT(item);
> +    spice_assert(item);
>  
>      if (item_pushed) {
>          cursor_channel_client_release_item_after_push(ccc, item);
>      } else {
> -        red_printf_once("not pushed (%d)", item->type);
> +        spice_debug("not pushed (%d)", item->type);
>          cursor_channel_client_release_item_before_push(ccc, item);
>      }
>  }
> @@ -10044,7 +10052,7 @@ static void cursor_channel_create(RedWorker *worker, int migrate)
>      if (worker->cursor_channel != NULL) {
>          return;
>      }
> -    red_printf("create cursor channel");
> +    spice_printerr("create cursor channel");
>      worker->cursor_channel = (CursorChannel *)__new_channel(
>          worker, sizeof(*worker->cursor_channel),
>          SPICE_CHANNEL_CURSOR, migrate,
> @@ -10067,11 +10075,11 @@ static void red_connect_cursor(RedWorker *worker, RedClient *client, RedsStream
>      CursorChannelClient *ccc;
>  
>      if (worker->cursor_channel == NULL) {
> -        red_printf("Warning: cursor channel was not created");
> +        spice_printerr("Warning: cursor channel was not created");
>          return;
>      }
>      channel = worker->cursor_channel;
> -    red_printf("add cursor channel client");
> +    spice_printerr("add cursor channel client");
>      ccc = cursor_channel_create_rcc(&channel->common, client, stream,
>                                      common_caps, num_common_caps,
>                                      caps, num_caps);
> @@ -10103,7 +10111,7 @@ static void red_wait_outgoing_item(RedChannelClient *rcc)
>          return;
>      }
>      end_time = red_now() + DETACH_TIMEOUT;
> -    red_printf("blocked");
> +    spice_printerr("blocked");
>  
>      do {
>          usleep(DETACH_SLEEP_DURATION);
> @@ -10112,12 +10120,12 @@ static void red_wait_outgoing_item(RedChannelClient *rcc)
>      } while ((blocked = red_channel_client_blocked(rcc)) && red_now() < end_time);
>  
>      if (blocked) {
> -        red_printf("timeout");
> +        spice_printerr("timeout");
>          // TODO - shutting down the socket but we still need to trigger
>          // disconnection. Right now we wait for main channel to error for that.
>          red_channel_client_shutdown(rcc);
>      } else {
> -        ASSERT(red_channel_client_no_item_being_sent(rcc));
> +        spice_assert(red_channel_client_no_item_being_sent(rcc));
>      }
>  }
>  
> @@ -10126,7 +10134,7 @@ static void rcc_shutdown_if_blocked(RedChannelClient *rcc)
>      if (red_channel_client_blocked(rcc)) {
>          red_channel_client_shutdown(rcc);
>      } else {
> -        ASSERT(red_channel_client_no_item_being_sent(rcc));
> +        spice_assert(red_channel_client_no_item_being_sent(rcc));
>      }
>  }
>  
> @@ -10140,7 +10148,7 @@ static void red_wait_outgoing_items(RedChannel *channel)
>      }
>  
>      end_time = red_now() + DETACH_TIMEOUT;
> -    red_printf("blocked");
> +    spice_printerr("blocked");
>  
>      do {
>          usleep(DETACH_SLEEP_DURATION);
> @@ -10149,10 +10157,10 @@ static void red_wait_outgoing_items(RedChannel *channel)
>      } while ((blocked = red_channel_any_blocked(channel)) && red_now() < end_time);
>  
>      if (blocked) {
> -        red_printf("timeout");
> +        spice_printerr("timeout");
>          red_channel_apply_clients(channel, rcc_shutdown_if_blocked);
>      } else {
> -        ASSERT(red_channel_no_item_being_sent(channel));
> +        spice_assert(red_channel_no_item_being_sent(channel));
>      }
>  }
>  
> @@ -10167,7 +10175,7 @@ static void red_wait_pipe_item_sent(RedChannelClient *rcc, PipeItem *item)
>          return;
>      }
>  
> -    red_printf("");
> +    spice_printerr("");
>      channel->channel_cbs.hold_item(rcc, item);
>  
>      end_time = red_now() + CHANNEL_PUSH_TIMEOUT;
> @@ -10186,7 +10194,7 @@ static void red_wait_pipe_item_sent(RedChannelClient *rcc, PipeItem *item)
>      }
>  
>      if (item_in_pipe) {
> -        red_printf("timeout");
> +        spice_printerr("timeout");
>          red_channel_client_disconnect(rcc);
>      } else {
>          if (red_channel_client_item_being_sent(rcc, item)) {
> @@ -10235,7 +10243,7 @@ void handle_dev_update_async(void *opaque, void *payload)
>      red_get_rect_ptr(&rect, &qxl_area);
>      flush_display_commands(worker);
>  
> -    ASSERT(worker->running);
> +    spice_assert(worker->running);
>  
>      validate_surface(worker, surface_id);
>      red_update_area(worker, &rect, surface_id);
> @@ -10271,7 +10279,7 @@ void handle_dev_update(void *opaque, void *payload)
>      red_get_rect_ptr(rect, qxl_area);
>      flush_display_commands(worker);
>  
> -    ASSERT(worker->running);
> +    spice_assert(worker->running);
>  
>      validate_surface(worker, surface_id);
>      red_update_area(worker, rect, surface_id);
> @@ -10327,7 +10335,7 @@ static inline void destroy_surface_wait(RedWorker *worker, int surface_id)
>  
>  static void dev_destroy_surface_wait(RedWorker *worker, uint32_t surface_id)
>  {
> -    ASSERT(surface_id == 0);
> +    spice_assert(surface_id == 0);
>  
>      flush_all_qxl_commands(worker);
>  
> @@ -10380,10 +10388,10 @@ static inline void dev_destroy_surfaces(RedWorker *worker)
>              if (worker->surfaces[i].context.canvas) {
>                  red_destroy_surface(worker, i);
>              }
> -            ASSERT(!worker->surfaces[i].context.canvas);
> +            spice_assert(!worker->surfaces[i].context.canvas);
>          }
>      }
> -    ASSERT(ring_is_empty(&worker->streams));
> +    spice_assert(ring_is_empty(&worker->streams));
>  
>      if (display_is_connected(worker)) {
>          red_channel_pipes_add_type(&worker->display_channel->common.base,
> @@ -10409,9 +10417,9 @@ static void dev_create_primary_surface(RedWorker *worker, uint32_t surface_id,
>  {
>      uint8_t *line_0;
>  
> -    PANIC_ON(surface_id != 0);
> -    PANIC_ON(surface.height == 0);
> -    PANIC_ON(((uint64_t)abs(surface.stride) * (uint64_t)surface.height) !=
> +    spice_warn_if(surface_id != 0);
> +    spice_warn_if(surface.height == 0);
> +    spice_warn_if(((uint64_t)abs(surface.stride) * (uint64_t)surface.height) !=
>               abs(surface.stride) * surface.height);
>  
>      line_0 = (uint8_t*)get_virt(&worker->mem_slots, surface.mem,
> @@ -10445,19 +10453,19 @@ void handle_dev_create_primary_surface(void *opaque, void *payload)
>  
>  static void dev_destroy_primary_surface(RedWorker *worker, uint32_t surface_id)
>  {
> -    PANIC_ON(surface_id != 0);
> +    spice_warn_if(surface_id != 0);
>  
>      if (!worker->surfaces[surface_id].context.canvas) {
> -        red_printf("double destroy of primary surface");
> +        spice_printerr("double destroy of primary surface");
>          return;
>      }
>  
>      flush_all_qxl_commands(worker);
>      dev_destroy_surface_wait(worker, 0);
>      red_destroy_surface(worker, 0);
> -    ASSERT(ring_is_empty(&worker->streams));
> +    spice_assert(ring_is_empty(&worker->streams));
>  
> -    ASSERT(!worker->surfaces[surface_id].context.canvas);
> +    spice_assert(!worker->surfaces[surface_id].context.canvas);
>  
>      red_cursor_reset(worker);
>  }
> @@ -10517,8 +10525,8 @@ void handle_dev_stop(void *opaque, void *payload)
>  {
>      RedWorker *worker = opaque;
>  
> -    red_printf("stop");
> -    ASSERT(worker->running);
> +    spice_printerr("stop");
> +    spice_assert(worker->running);
>      worker->running = FALSE;
>      red_display_clear_glz_drawables(worker->display_channel);
>      flush_all_surfaces(worker);
> @@ -10532,7 +10540,7 @@ void handle_dev_start(void *opaque, void *payload)
>      RedChannel *cursor_red_channel = &worker->cursor_channel->common.base;
>      RedChannel *display_red_channel = &worker->display_channel->common.base;
>  
> -    ASSERT(!worker->running);
> +    spice_assert(!worker->running);
>      if (worker->cursor_channel) {
>          cursor_red_channel->migrate = FALSE;
>      }
> @@ -10557,16 +10565,15 @@ void handle_dev_oom(void *opaque, void *payload)
>      RedChannel *display_red_channel = &worker->display_channel->common.base;
>      int ring_is_empty;
>  
> -    ASSERT(worker->running);
> +    spice_assert(worker->running);
>      // streams? but without streams also leak
> -    red_printf_debug(1, "WORKER",
> -                     "OOM1 #draw=%u, #red_draw=%u, #glz_draw=%u current %u pipes %u",
> -                     worker->drawable_count,
> -                     worker->red_drawable_count,
> -                     worker->glz_drawable_count,
> -                     worker->current_size,
> -                     worker->display_channel ?
> -                     red_channel_sum_pipes_size(display_red_channel) : 0);
> +    spice_debug("OOM1 #draw=%u, #red_draw=%u, #glz_draw=%u current %u pipes %u",
> +                worker->drawable_count,
> +                worker->red_drawable_count,
> +                worker->glz_drawable_count,
> +                worker->current_size,
> +                worker->display_channel ?
> +                red_channel_sum_pipes_size(display_red_channel) : 0);
>      while (red_process_commands(worker, MAX_PIPE_SIZE, &ring_is_empty)) {
>          red_channel_push(&worker->display_channel->common.base);
>      }
> @@ -10574,14 +10581,13 @@ void handle_dev_oom(void *opaque, void *payload)
>          red_free_some(worker);
>          worker->qxl->st->qif->flush_resources(worker->qxl);
>      }
> -    red_printf_debug(1, "WORKER",
> -                     "OOM2 #draw=%u, #red_draw=%u, #glz_draw=%u current %u pipes %u",
> -                     worker->drawable_count,
> -                     worker->red_drawable_count,
> -                     worker->glz_drawable_count,
> -                     worker->current_size,
> -                     worker->display_channel ?
> -                     red_channel_sum_pipes_size(display_red_channel) : 0);
> +    spice_debug("OOM2 #draw=%u, #red_draw=%u, #glz_draw=%u current %u pipes %u",
> +                worker->drawable_count,
> +                worker->red_drawable_count,
> +                worker->glz_drawable_count,
> +                worker->current_size,
> +                worker->display_channel ?
> +                red_channel_sum_pipes_size(display_red_channel) : 0);
>      clear_bit(RED_WORKER_PENDING_OOM, worker->pending);
>  }
>  
> @@ -10643,7 +10649,7 @@ void handle_dev_display_connect(void *opaque, void *payload)
>      RedClient *client = msg->client;
>      int migration = msg->migration;
>  
> -    red_printf("connect");
> +    spice_printerr("connect");
>      handle_new_display_channel(worker, client, stream, migration,
>                                 msg->common_caps, msg->num_common_caps,
>                                 msg->caps, msg->num_caps);
> @@ -10656,8 +10662,8 @@ void handle_dev_display_disconnect(void *opaque, void *payload)
>      RedWorkerMessageDisplayDisconnect *msg = payload;
>      RedChannelClient *rcc = msg->rcc;
>  
> -    red_printf("disconnect display client");
> -    ASSERT(rcc);
> +    spice_printerr("disconnect display client");
> +    spice_assert(rcc);
>      red_channel_client_disconnect(rcc);
>  }
>  
> @@ -10667,8 +10673,8 @@ void handle_dev_display_migrate(void *opaque, void *payload)
>      RedWorker *worker = opaque;
>  
>      RedChannelClient *rcc = msg->rcc;
> -    red_printf("migrate display client");
> -    ASSERT(rcc);
> +    spice_printerr("migrate display client");
> +    spice_assert(rcc);
>      red_migrate_display(worker, rcc);
>  }
>  
> @@ -10692,7 +10698,7 @@ void handle_dev_cursor_connect(void *opaque, void *payload)
>      RedClient *client = msg->client;
>      int migration = msg->migration;
>  
> -    red_printf("cursor connect");
> +    spice_printerr("cursor connect");
>      red_connect_cursor(worker, client, stream, migration,
>                         msg->common_caps, msg->num_common_caps,
>                         msg->caps, msg->num_caps);
> @@ -10705,8 +10711,8 @@ void handle_dev_cursor_disconnect(void *opaque, void *payload)
>      RedWorkerMessageCursorDisconnect *msg = payload;
>      RedChannelClient *rcc = msg->rcc;
>  
> -    red_printf("disconnect cursor client");
> -    ASSERT(rcc);
> +    spice_printerr("disconnect cursor client");
> +    spice_assert(rcc);
>      red_channel_client_disconnect(rcc);
>  }
>  
> @@ -10716,8 +10722,8 @@ void handle_dev_cursor_migrate(void *opaque, void *payload)
>      RedWorker *worker = opaque;
>      RedChannelClient *rcc = msg->rcc;
>  
> -    red_printf("migrate cursor client");
> -    ASSERT(rcc);
> +    spice_printerr("migrate cursor client");
> +    spice_assert(rcc);
>      red_migrate_cursor(worker, rcc);
>  }
>  
> @@ -10729,25 +10735,25 @@ void handle_dev_set_compression(void *opaque, void *payload)
>      worker->image_compression = msg->image_compression;
>      switch (worker->image_compression) {
>      case SPICE_IMAGE_COMPRESS_AUTO_LZ:
> -        red_printf("ic auto_lz");
> +        spice_printerr("ic auto_lz");
>          break;
>      case SPICE_IMAGE_COMPRESS_AUTO_GLZ:
> -        red_printf("ic auto_glz");
> +        spice_printerr("ic auto_glz");
>          break;
>      case SPICE_IMAGE_COMPRESS_QUIC:
> -        red_printf("ic quic");
> +        spice_printerr("ic quic");
>          break;
>      case SPICE_IMAGE_COMPRESS_LZ:
> -        red_printf("ic lz");
> +        spice_printerr("ic lz");
>          break;
>      case SPICE_IMAGE_COMPRESS_GLZ:
> -        red_printf("ic glz");
> +        spice_printerr("ic glz");
>          break;
>      case SPICE_IMAGE_COMPRESS_OFF:
> -        red_printf("ic off");
> +        spice_printerr("ic off");
>          break;
>      default:
> -        red_printf("ic invalid");
> +        spice_printerr("ic invalid");
>      }
>  #ifdef COMPRESS_STAT
>      print_compress_stats(worker->display_channel);
> @@ -10768,19 +10774,19 @@ void handle_dev_set_streaming_video(void *opaque, void *payload)
>      RedWorker *worker = opaque;
>  
>      worker->streaming_video = msg->streaming_video;
> -    ASSERT(worker->streaming_video != STREAM_VIDEO_INVALID);
> +    spice_assert(worker->streaming_video != STREAM_VIDEO_INVALID);
>      switch(worker->streaming_video) {
>          case STREAM_VIDEO_ALL:
> -            red_printf("sv all");
> +            spice_printerr("sv all");
>              break;
>          case STREAM_VIDEO_FILTER:
> -            red_printf("sv filter");
> +            spice_printerr("sv filter");
>              break;
>          case STREAM_VIDEO_OFF:
> -            red_printf("sv off");
> +            spice_printerr("sv off");
>              break;
>          default:
> -            red_printf("sv invalid");
> +            spice_printerr("sv invalid");
>      }
>  }
>  
> @@ -10790,7 +10796,7 @@ void handle_dev_set_mouse_mode(void *opaque, void *payload)
>      RedWorker *worker = opaque;
>  
>      worker->mouse_mode = msg->mode;
> -    red_printf("mouse mode %u", worker->mouse_mode);
> +    spice_printerr("mouse mode %u", worker->mouse_mode);
>  }
>  
>  void handle_dev_add_memslot_async(void *opaque, void *payload)
> @@ -10818,7 +10824,7 @@ void handle_dev_loadvm_commands(void *opaque, void *payload)
>      uint32_t count = msg->count;
>      QXLCommandExt *ext = msg->ext;
>  
> -    red_printf("loadvm_commands");
> +    spice_printerr("loadvm_commands");
>      for (i = 0 ; i < count ; ++i) {
>          switch (ext[i].cmd.type) {
>          case QXL_CMD_CURSOR:
> @@ -10834,7 +10840,7 @@ void handle_dev_loadvm_commands(void *opaque, void *payload)
>              red_process_surface(worker, surface_cmd, ext[i].group_id, TRUE);
>              break;
>          default:
> -            red_printf("unhandled loadvm command type (%d)", ext[i].cmd.type);
> +            spice_printerr("unhandled loadvm command type (%d)", ext[i].cmd.type);
>              break;
>          }
>      }
> @@ -10847,7 +10853,7 @@ static void worker_handle_dispatcher_async_done(void *opaque,
>      RedWorker *worker = opaque;
>      RedWorkerMessageAsync *msg_async = payload;
>  
> -    red_printf_debug(2, "WORKER", "");
> +    spice_debug(NULL);
>      red_dispatcher_async_complete(worker->red_dispatcher, msg_async->cmd);
>  }
>  
> @@ -11038,7 +11044,7 @@ static void red_init(RedWorker *worker, WorkerInitData *init_data)
>      Dispatcher *dispatcher;
>      int i;
>  
> -    ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
> +    spice_assert(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
>  
>      memset(worker, 0, sizeof(RedWorker));
>      dispatcher = red_dispatcher_get_dispatcher(init_data->red_dispatcher);
> @@ -11050,7 +11056,7 @@ static void red_init(RedWorker *worker, WorkerInitData *init_data)
>      register_callbacks(dispatcher);
>      worker->pending = init_data->pending;
>      worker->cursor_visible = TRUE;
> -    ASSERT(init_data->num_renderers > 0);
> +    spice_assert(init_data->num_renderers > 0);
>      worker->num_renderers = init_data->num_renderers;
>      memcpy(worker->renderers, init_data->renderers, sizeof(worker->renderers));
>      worker->renderer = RED_RENDERER_INVALID;
> @@ -11092,7 +11098,7 @@ static void red_init(RedWorker *worker, WorkerInitData *init_data)
>                            init_data->memslot_id_bits,
>                            init_data->internal_groupslot_id);
>  
> -    PANIC_ON(init_data->n_surfaces > NUM_SURFACES);
> +    spice_warn_if(init_data->n_surfaces > NUM_SURFACES);
>      worker->n_surfaces = init_data->n_surfaces;
>  
>      message = RED_WORKER_MESSAGE_READY;
> @@ -11110,13 +11116,13 @@ void *red_worker_main(void *arg)
>  {
>      RedWorker worker;
>  
> -    red_printf("begin");
> -    ASSERT(MAX_PIPE_SIZE > WIDE_CLIENT_ACK_WINDOW &&
> +    spice_printerr("begin");
> +    spice_assert(MAX_PIPE_SIZE > WIDE_CLIENT_ACK_WINDOW &&
>             MAX_PIPE_SIZE > NARROW_CLIENT_ACK_WINDOW); //ensure wakeup by ack message
>  
>  #if  defined(RED_WORKER_STAT) || defined(COMPRESS_STAT)
>      if (pthread_getcpuclockid(pthread_self(), &clock_id)) {
> -        red_error("pthread_getcpuclockid failed");
> +        spice_error("pthread_getcpuclockid failed");
>      }
>  #endif
>  
> @@ -11144,7 +11150,7 @@ void *red_worker_main(void *arg)
>          worker.event_timeout = INF_EVENT_WAIT;
>          if (num_events == -1) {
>              if (errno != EINTR) {
> -                red_error("poll failed, %s", strerror(errno));
> +                spice_error("poll failed, %s", strerror(errno));
>              }
>          }
>  
> @@ -11180,7 +11186,7 @@ void *red_worker_main(void *arg)
>          }
>          red_push(&worker);
>      }
> -    red_printf("exit");
> +    spice_printerr("exit");
>      return 0;
>  }
>  
> @@ -11259,7 +11265,7 @@ static void dump_bitmap(RedWorker *worker, SpiceBitmap *bitmap, uint32_t group_i
>          alpha = 1;
>          break;
>      default:
> -        red_error("invalid bitmap format  %u", bitmap->format);
> +        spice_error("invalid bitmap format  %u", bitmap->format);
>      }
>  
>      if (!rgb) {
> @@ -11281,7 +11287,7 @@ static void dump_bitmap(RedWorker *worker, SpiceBitmap *bitmap, uint32_t group_i
>  
>      f = fopen(file_str, "wb");
>      if (!f) {
> -        red_error("Error creating bmp\n");
> +        spice_error("Error creating bmp");
>          return;
>      }
>  
> diff --git a/server/red_worker.h b/server/red_worker.h
> index 1f63d01..fd23ede 100644
> --- a/server/red_worker.h
> +++ b/server/red_worker.h
> @@ -131,7 +131,7 @@ static inline void send_data(int fd, void *in_buf, int n)
>              if (errno == EINTR) {
>                  continue;
>              }
> -            red_error("%s", strerror(errno));
> +            spice_error("%s", strerror(errno));
>          }
>          buf += now;
>          n -= now;
> @@ -152,7 +152,7 @@ static inline void receive_data(int fd, void *in_buf, int n)
>              if (errno == EINTR) {
>                  continue;
>              }
> -            red_error("%s", strerror(errno));
> +            spice_error("%s", strerror(errno));
>          }
>          buf += now;
>          n -= now;
> diff --git a/server/reds.c b/server/reds.c
> index c54d30c..c0c5299 100644
> --- a/server/reds.c
> +++ b/server/reds.c
> @@ -467,7 +467,7 @@ StatNodeRef stat_add_node(StatNodeRef parent, const char *name, int visible)
>      StatNodeRef ref;
>      SpiceStatNode *node;
>  
> -    ASSERT(name && strlen(name) > 0);
> +    spice_assert(name && strlen(name) > 0);
>      if (strlen(name) >= sizeof(node->name)) {
>          return INVALID_STAT_REF;
>      }
> @@ -495,7 +495,7 @@ StatNodeRef stat_add_node(StatNodeRef parent, const char *name, int visible)
>              break;
>          }
>      }
> -    ASSERT(!(node->flags & SPICE_STAT_NODE_FLAG_ENABLED));
> +    spice_assert(!(node->flags & SPICE_STAT_NODE_FLAG_ENABLED));
>      node->value = 0;
>      node->flags = SPICE_STAT_NODE_FLAG_ENABLED | (visible ? SPICE_STAT_NODE_FLAG_VISIBLE : 0);
>      strncpy(node->name, name, sizeof(node->name));
> @@ -552,7 +552,7 @@ void reds_update_stat_value(uint32_t value)
>  
>  void reds_register_channel(RedChannel *channel)
>  {
> -    ASSERT(reds);
> +    spice_assert(reds);
>      ring_add(&reds->channels, &channel->link);
>      reds->num_of_channels++;
>  }
> @@ -563,7 +563,7 @@ void reds_unregister_channel(RedChannel *channel)
>          ring_remove(&channel->link);
>          reds->num_of_channels--;
>      } else {
> -        red_printf("not found");
> +        spice_printerr("not found");
>      }
>  }
>  
> @@ -585,7 +585,7 @@ static void reds_mig_cleanup(void)
>      if (reds->mig_inprogress) {
>          if (reds->mig_wait_connect) {
>              SpiceMigrateInterface *sif;
> -            ASSERT(migration_interface);
> +            spice_assert(migration_interface);
>              sif = SPICE_CONTAINEROF(migration_interface->base.sif, SpiceMigrateInterface, base);
>              sif->migrate_connect_complete(migration_interface);
>          }
> @@ -644,7 +644,7 @@ void reds_client_disconnect(RedClient *client)
>          return;
>      }
>  
> -    red_printf("");
> +    spice_printerr("");
>      /* disconnecting is set to prevent recursion because of the following:
>       * main_channel_client_on_disconnect->
>       *  reds_client_disconnect->red_client_destroy->main_channel...
> @@ -684,7 +684,7 @@ static void reds_disconnect(void)
>  {
>      RingItem *link, *next;
>  
> -    red_printf("");
> +    spice_printerr("");
>      RING_FOREACH_SAFE(link, next, &reds->clients) {
>          reds_client_disconnect(SPICE_CONTAINEROF(link, RedClient, link));
>      }
> @@ -759,7 +759,7 @@ static void reds_agent_remove(void)
>  static void reds_push_tokens(void)
>  {
>      reds->agent_state.num_client_tokens += reds->agent_state.num_tokens;
> -    ASSERT(reds->agent_state.num_client_tokens <= REDS_AGENT_WINDOW_SIZE);
> +    spice_assert(reds->agent_state.num_client_tokens <= REDS_AGENT_WINDOW_SIZE);
>      main_channel_push_tokens(reds->main_channel, reds->agent_state.num_tokens);
>      reds->agent_state.num_tokens = 0;
>  }
> @@ -865,7 +865,7 @@ static void dispatch_vdi_port_data(int port, VDIReadBuf *buf)
>          break;
>      default:
>          ring_add(&state->read_bufs, &buf->link);
> -        red_printf("invalid port");
> +        spice_printerr("invalid port");
>          reds_agent_remove();
>      }
>  }
> @@ -1019,7 +1019,7 @@ int reds_num_of_clients(void)
>  
>  SPICE_GNUC_VISIBLE int spice_server_get_num_clients(SpiceServer *s)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      return reds_num_of_clients();
>  }
>  
> @@ -1055,7 +1055,7 @@ void reds_fill_channels(SpiceMsgChannels *channels_info)
>  
>      channels_info->num_of_channels = used_channels;
>      if (used_channels != reds->num_of_channels) {
> -        red_printf("sent %d out of %d", used_channels, reds->num_of_channels);
> +        spice_printerr("sent %d out of %d", used_channels, reds->num_of_channels);
>      }
>  }
>  
> @@ -1076,7 +1076,7 @@ void reds_on_main_agent_data(MainChannelClient *mcc, void *message, size_t size)
>      int res;
>  
>      if (!reds->agent_state.num_client_tokens) {
> -        red_printf("token violation");
> +        spice_printerr("token violation");
>          reds_disconnect();
>          return;
>      }
> @@ -1096,7 +1096,7 @@ void reds_on_main_agent_data(MainChannelClient *mcc, void *message, size_t size)
>      }
>  
>      if (!(ring_item = ring_get_head(&reds->agent_state.external_bufs))) {
> -        red_printf("no agent free bufs");
> +        spice_printerr("no agent free bufs");
>          reds_disconnect();
>          return;
>      }
> @@ -1124,14 +1124,14 @@ void reds_on_main_mouse_mode_request(void *message, size_t size)
>          if (reds->is_client_mouse_allowed) {
>              reds_set_mouse_mode(SPICE_MOUSE_MODE_CLIENT);
>          } else {
> -            red_printf("client mouse is disabled");
> +            spice_printerr("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");
> +        spice_printerr("unsupported mouse mode");
>      }
>  }
>  
> @@ -1211,7 +1211,7 @@ static int reds_main_channel_restore_vdi_read_state(MainMigrateData *data, uint8
>      switch (state->read_state) {
>      case VDI_PORT_READ_STATE_READ_HADER:
>          if (data->read_buf_len) {
> -            red_printf("unexpected receive buf");
> +            spice_printerr("unexpected receive buf");
>              reds_disconnect();
>              return FALSE;
>          }
> @@ -1219,13 +1219,13 @@ static int reds_main_channel_restore_vdi_read_state(MainMigrateData *data, uint8
>          break;
>      case VDI_PORT_READ_STATE_GET_BUFF:
>          if (state->message_recive_len > state->vdi_chunk_header.size) {
> -            red_printf("invalid message receive len");
> +            spice_printerr("invalid message receive len");
>              reds_disconnect();
>              return FALSE;
>          }
>  
>          if (data->read_buf_len) {
> -            red_printf("unexpected receive buf");
> +            spice_printerr("unexpected receive buf");
>              reds_disconnect();
>              return FALSE;
>          }
> @@ -1235,20 +1235,20 @@ static int reds_main_channel_restore_vdi_read_state(MainMigrateData *data, uint8
>          uint32_t n;
>  
>          if (!data->read_buf_len) {
> -            red_printf("read state and read_buf_len == 0");
> +            spice_printerr("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");
> +            spice_printerr("invalid message receive len");
>              reds_disconnect();
>              return FALSE;
>          }
>  
>  
>          if (!(ring_item = ring_get_head(&state->read_bufs))) {
> -            red_printf("get read buf failed");
> +            spice_printerr("get read buf failed");
>              reds_disconnect();
>              return FALSE;
>          }
> @@ -1258,7 +1258,7 @@ static int reds_main_channel_restore_vdi_read_state(MainMigrateData *data, uint8
>          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");
> +            spice_printerr("bad read position");
>              reds_disconnect();
>              return FALSE;
>          }
> @@ -1268,7 +1268,7 @@ static int reds_main_channel_restore_vdi_read_state(MainMigrateData *data, uint8
>          break;
>      }
>      default:
> -        red_printf("invalid read state");
> +        spice_printerr("invalid read state");
>          reds_disconnect();
>          return FALSE;
>      }
> @@ -1296,14 +1296,14 @@ static int reds_main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *
>      inf_end = inf + data->write_queue_size;
>      pos = (uint8_t *)inf_end;
>      if (pos > end) {
> -        red_printf("access violation");
> +        spice_printerr("access violation");
>          reds_disconnect();
>          return FALSE;
>      }
>  
>      for (; inf < inf_end; inf++) {
>          if (pos + inf->len > end) {
> -            red_printf("access violation");
> +            spice_printerr("access violation");
>              reds_disconnect();
>              return FALSE;
>          }
> @@ -1311,7 +1311,7 @@ static int reds_main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *
>              VDInternalBuf *buf;
>  
>              if (inf->len > sizeof(*buf) - SPICE_OFFSETOF(VDInternalBuf, header)) {
> -                red_printf("bad buffer len");
> +                spice_printerr("bad buffer len");
>                  reds_disconnect();
>                  return FALSE;
>              }
> @@ -1327,12 +1327,12 @@ static int reds_main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *
>  
>              state->num_tokens--;
>              if (inf->len > sizeof(*buf) - SPICE_OFFSETOF(VDAgentExtBuf, buf)) {
> -                red_printf("bad buffer len");
> +                spice_printerr("bad buffer len");
>                  reds_disconnect();
>                  return FALSE;
>              }
>              if (!(ring_item = ring_get_head(&reds->agent_state.external_bufs))) {
> -                red_printf("no external buff");
> +                spice_printerr("no external buff");
>                  reds_disconnect();
>                  return FALSE;
>              }
> @@ -1343,7 +1343,7 @@ static int reds_main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *
>              buf->base.write_len = inf->len;
>              ring_add(&reds->agent_state.write_queue, &buf->base.link);
>          } else {
> -            red_printf("invalid data");
> +            spice_printerr("invalid data");
>              reds_disconnect();
>              return FALSE;
>          }
> @@ -1358,13 +1358,13 @@ void reds_on_main_receive_migrate_data(MainMigrateData *data, uint8_t *end)
>      uint8_t *pos;
>  
>      if (data->version != MAIN_CHANNEL_MIG_DATA_VERSION) {
> -        red_printf("version mismatch");
> +        spice_printerr("version mismatch");
>          reds_disconnect();
>          return;
>      }
>  
>      state->num_client_tokens = data->num_client_tokens;
> -    ASSERT(state->num_client_tokens + data->write_queue_size <= REDS_AGENT_WINDOW_SIZE +
> +    spice_assert(state->num_client_tokens + data->write_queue_size <= REDS_AGENT_WINDOW_SIZE +
>                                                                  REDS_NUM_INTERNAL_AGENT_MESSAGES);
>      state->num_tokens = REDS_AGENT_WINDOW_SIZE - state->num_client_tokens;
>  
> @@ -1395,7 +1395,7 @@ void reds_on_main_receive_migrate_data(MainMigrateData *data, uint8_t *end)
>      }
>  
>      reds_main_channel_restore_vdi_wqueue(data, pos, end);
> -    ASSERT(state->num_client_tokens + state->num_tokens == REDS_AGENT_WINDOW_SIZE);
> +    spice_assert(state->num_client_tokens + state->num_tokens == REDS_AGENT_WINDOW_SIZE);
>  
>      while (write_to_vdi_port() || read_from_vdi_port());
>  }
> @@ -1447,8 +1447,8 @@ static int reds_send_link_ack(RedLinkInfo *link)
>  
>      channel = reds_find_channel(link->link_mess->channel_type, 0);
>      if (!channel) {
> -        ASSERT(link->link_mess->channel_type == SPICE_CHANNEL_MAIN);
> -        ASSERT(reds->main_channel);
> +        spice_assert(link->link_mess->channel_type == SPICE_CHANNEL_MAIN);
> +        spice_assert(reds->main_channel);
>          channel = &reds->main_channel->base;
>      }
>  
> @@ -1461,12 +1461,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");
> +        spice_printerr("RSA nes failed");
>          return FALSE;
>      }
>  
>      if (!(bio = BIO_new(BIO_s_mem()))) {
> -        red_printf("BIO new failed");
> +        spice_printerr("BIO new failed");
>          return FALSE;
>      }
>  
> @@ -1511,7 +1511,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",
> +    spice_printerr("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");
> @@ -1532,7 +1532,7 @@ static void reds_send_link_result(RedLinkInfo *link, uint32_t error)
>  
>  int reds_expects_link_id(uint32_t connection_id)
>  {
> -    red_printf("TODO: keep a list of connection_id's from migration, compare to them");
> +    spice_printerr("TODO: keep a list of connection_id's from migration, compare to them");
>      return 1;
>  }
>  
> @@ -1540,8 +1540,8 @@ static void reds_mig_target_client_add(RedClient *client)
>  {
>      RedsMigTargetClient *mig_client;
>  
> -    ASSERT(reds);
> -    red_printf("");
> +    spice_assert(reds);
> +    spice_printerr("");
>      mig_client = spice_malloc0(sizeof(RedsMigTargetClient));
>      mig_client->client = client;
>      ring_init(&mig_client->pending_links);
> @@ -1571,8 +1571,8 @@ static void reds_mig_target_client_add_pending_link(RedsMigTargetClient *client,
>  {
>      RedsMigPendingLink *mig_link;
>  
> -    ASSERT(reds);
> -    ASSERT(client);
> +    spice_assert(reds);
> +    spice_assert(client);
>      mig_link = spice_malloc0(sizeof(RedsMigPendingLink));
>      mig_link->link_msg = link_msg;
>      mig_link->stream = stream;
> @@ -1617,8 +1617,8 @@ static void reds_handle_main_link(RedLinkInfo *link)
>      MainChannelClient *mcc;
>      int mig_target = FALSE;
>  
> -    red_printf("");
> -    ASSERT(reds->main_channel);
> +    spice_printerr("");
> +    spice_assert(reds->main_channel);
>  
>      link_mess = link->link_mess;
>      if (!reds->allow_multiple_clients) {
> @@ -1657,7 +1657,7 @@ static void reds_handle_main_link(RedLinkInfo *link)
>                              link_mess->num_common_caps,
>                              link_mess->num_common_caps ? caps : NULL, link_mess->num_channel_caps,
>                              link_mess->num_channel_caps ? caps + link_mess->num_common_caps : NULL);
> -    red_printf("NEW Client %p mcc %p connect-id %d", client, mcc, connection_id);
> +    spice_printerr("NEW Client %p mcc %p connect-id %d", client, mcc, connection_id);
>      free(link_mess);
>      red_client_set_main(client, mcc);
>  
> @@ -1713,7 +1713,7 @@ static void openssl_init(RedLinkInfo *link)
>      link->tiTicketing.bn = BN_new();
>  
>      if (!link->tiTicketing.bn) {
> -        red_error("OpenSSL BIGNUMS alloc failed");
> +        spice_error("OpenSSL BIGNUMS alloc failed");
>      }
>  
>      BN_set_word(link->tiTicketing.bn, f4);
> @@ -1725,9 +1725,9 @@ static void reds_channel_do_link(RedChannel *channel, RedClient *client,
>  {
>      uint32_t *caps;
>  
> -    ASSERT(channel);
> -    ASSERT(link_msg);
> -    ASSERT(stream);
> +    spice_assert(channel);
> +    spice_assert(link_msg);
> +    spice_assert(stream);
>  
>      if (link_msg->channel_type == SPICE_CHANNEL_INPUTS && !stream->ssl) {
>          char *mess = "keyboard channel is insecure";
> @@ -1751,11 +1751,11 @@ void reds_on_client_migrate_complete(RedClient *client)
>      MainChannelClient *mcc;
>      RingItem *item;
>  
> -    red_printf("%p", client);
> +    spice_printerr("%p", client);
>      mcc = red_client_get_main(client);
>      mig_client = reds_mig_target_client_find(client);
>      if (!mig_client) {
> -        red_printf("Error: mig target client was not found");
> +        spice_printerr("Error: mig target client was not found");
>          return;
>      }
>  
> @@ -1773,7 +1773,7 @@ void reds_on_client_migrate_complete(RedClient *client)
>          channel = reds_find_channel(mig_link->link_msg->channel_type,
>                                      mig_link->link_msg->channel_id);
>          if (!channel) {
> -            red_printf("warning: client %p channel (%d, %d) (type, id) wasn't found",
> +            spice_printerr("warning: client %p channel (%d, %d) (type, id) wasn't found",
>                         client,
>                         mig_link->link_msg->channel_type,
>                         mig_link->link_msg->channel_id);
> @@ -1824,10 +1824,10 @@ static void reds_handle_other_links(RedLinkInfo *link)
>  
>      mig_client = reds_mig_target_client_find(client);
>      if (red_client_during_migrate_at_target(client)) {
> -        ASSERT(mig_client);
> +        spice_assert(mig_client);
>          reds_mig_target_client_add_pending_link(mig_client, link_mess, link->stream);
>      } else {
> -        ASSERT(!mig_client);
> +        spice_assert(!mig_client);
>          reds_channel_do_link(channel, client, link_mess, link->stream);
>          free(link_mess);
>      }
> @@ -1862,7 +1862,7 @@ 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. "
> +            spice_printerr("Ticketing is enabled, but no password is set. "
>                         "please set a ticket first");
>              reds_link_free(link);
>              return;
> @@ -1870,9 +1870,9 @@ static void reds_handle_ticket(void *opaque)
>  
>          if (expired || strncmp(password, taTicket.password, SPICE_MAX_PASSWORD_LENGTH) != 0) {
>              if (expired) {
> -                red_printf("Ticket has expired");
> +                spice_printerr("Ticket has expired");
>              } else {
> -                red_printf("Invalid password");
> +                spice_printerr("Invalid password");
>              }
>              reds_send_link_result(link, SPICE_LINK_ERR_PERMISSION_DENIED);
>              reds_link_free(link);
> @@ -1913,7 +1913,7 @@ static ssize_t reds_stream_sasl_write(RedsStream *s, const void *buf, size_t nby
>                            (const char **)&s->sasl.encoded,
>                            &s->sasl.encodedLength);
>          if (err != SASL_OK) {
> -            red_printf("sasl_encode error: %d", err);
> +            spice_printerr("sasl_encode error: %d", err);
>              return -1;
>          }
>  
> @@ -1922,7 +1922,7 @@ static ssize_t reds_stream_sasl_write(RedsStream *s, const void *buf, size_t nby
>          }
>  
>          if (!s->sasl.encoded) {
> -            red_printf("sasl_encode didn't return a buffer!");
> +            spice_printerr("sasl_encode didn't return a buffer!");
>              return 0;
>          }
>  
> @@ -1974,7 +1974,7 @@ static ssize_t reds_stream_sasl_read(RedsStream *s, uint8_t *buf, size_t nbyte)
>                        (char *)encoded, n,
>                        &decoded, &decodedlen);
>      if (err != SASL_OK) {
> -        red_printf("sasl_decode error: %d", err);
> +        spice_printerr("sasl_decode error: %d", err);
>          return -1;
>      }
>  
> @@ -1997,7 +1997,7 @@ static void async_read_handler(int fd, int event, void *data)
>      for (;;) {
>          int n = obj->end - obj->now;
>  
> -        ASSERT(n > 0);
> +        spice_assert(n > 0);
>          n = reds_stream_read(obj->stream, obj->now, n);
>          if (n <= 0) {
>              if (n < 0) {
> @@ -2056,7 +2056,7 @@ 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",
> +        spice_printerr("Cannot resolve address %d: %s",
>                     err, gai_strerror(err));
>          return NULL;
>      }
> @@ -2087,7 +2087,7 @@ static int auth_sasl_check_ssf(RedsSASL *sasl, int *runSSF)
>      }
>  
>      ssf = *(const int *)val;
> -    red_printf("negotiated an SSF of %d", ssf);
> +    spice_printerr("negotiated an SSF of %d", ssf);
>      if (ssf < 56) {
>          return 0; /* 56 is good for Kerberos */
>      }
> @@ -2134,7 +2134,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)",
> +    spice_printerr("Step using SASL Data %p (%d bytes)",
>                 clientdata, datalen);
>      err = sasl_server_step(sasl->conn,
>                             clientdata,
> @@ -2143,18 +2143,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)",
> +        spice_printerr("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",
> +        spice_printerr("sasl step reply data too long %d",
>                     serveroutlen);
>          goto authabort;
>      }
>  
> -    red_printf("SASL return data %d bytes, %p", serveroutlen, serverout);
> +    spice_printerr("SASL return data %d bytes, %p", serveroutlen, serverout);
>  
>      if (serveroutlen) {
>          serveroutlen += 1;
> @@ -2168,7 +2168,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)");
> +        spice_printerr("%s", "Authentication must continue (step)");
>          /* Wait for step length */
>          obj->now = (uint8_t *)&sasl->len;
>          obj->end = obj->now + sizeof(uint32_t);
> @@ -2178,11 +2178,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");
> +            spice_printerr("Authentication rejected for weak SSF");
>              goto authreject;
>          }
>  
> -        red_printf("Authentication successful");
> +        spice_printerr("Authentication successful");
>          sync_write_u32(link->stream, SPICE_LINK_ERR_OK); /* Accept auth */
>  
>          /*
> @@ -2212,9 +2212,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);
> +    spice_printerr("Got steplen %d", sasl->len);
>      if (sasl->len > SASL_DATA_MAX_LEN) {
> -        red_printf("Too much SASL data %d", sasl->len);
> +        spice_printerr("Too much SASL data %d", sasl->len);
>          reds_link_free(link);
>          return;
>      }
> @@ -2264,7 +2264,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)",
> +    spice_printerr("Start SASL auth with mechanism %s. Data %p (%d bytes)",
>                sasl->mechlist, clientdata, datalen);
>      err = sasl_server_start(sasl->conn,
>                              sasl->mechlist,
> @@ -2274,18 +2274,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)",
> +        spice_printerr("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",
> +        spice_printerr("sasl start reply data too long %d",
>                     serveroutlen);
>          goto authabort;
>      }
>  
> -    red_printf("SASL return data %d bytes, %p", serveroutlen, serverout);
> +    spice_printerr("SASL return data %d bytes, %p", serveroutlen, serverout);
>  
>      if (serveroutlen) {
>          serveroutlen += 1;
> @@ -2299,7 +2299,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)");
> +        spice_printerr("%s", "Authentication must continue (start)");
>          /* Wait for step length */
>          obj->now = (uint8_t *)&sasl->len;
>          obj->end = obj->now + sizeof(uint32_t);
> @@ -2309,11 +2309,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");
> +            spice_printerr("Authentication rejected for weak SSF");
>              goto authreject;
>          }
>  
> -        red_printf("Authentication successful");
> +        spice_printerr("Authentication successful");
>          sync_write_u32(link->stream, SPICE_LINK_ERR_OK); /* Accept auth */
>  
>          /*
> @@ -2343,9 +2343,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);
> +    spice_printerr("Got client start len %d", sasl->len);
>      if (sasl->len > SASL_DATA_MAX_LEN) {
> -        red_printf("Too much SASL data %d", sasl->len);
> +        spice_printerr("Too much SASL data %d", sasl->len);
>          reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
>          reds_link_free(link);
>          return;
> @@ -2370,24 +2370,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'",
> +    spice_printerr("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]);
> +            spice_printerr("One %d", sasl->mechlist[sasl->len]);
>              reds_link_free(link);
>              return;
>          }
>      } else {
>          char *offset = strstr(sasl->mechlist, sasl->mechname);
> -        red_printf("Two %p", offset);
> +        spice_printerr("Two %p", offset);
>          if (!offset) {
>              reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
>              return;
>          }
> -        red_printf("Two '%s'", offset);
> +        spice_printerr("Two '%s'", offset);
>          if (offset[-1] != ',' ||
>              (offset[sasl->len] != '\0'&&
>               offset[sasl->len] != ',')) {
> @@ -2399,7 +2399,7 @@ static void reds_handle_auth_mechname(void *opaque)
>      free(sasl->mechlist);
>      sasl->mechlist = strdup(sasl->mechname);
>  
> -    red_printf("Validated mechname '%s'", sasl->mechname);
> +    spice_printerr("Validated mechname '%s'", sasl->mechname);
>  
>      obj->now = (uint8_t *)&sasl->len;
>      obj->end = obj->now + sizeof(uint32_t);
> @@ -2416,14 +2416,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);
> +        spice_printerr("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");
> +    spice_printerr("Wait for client mechname");
>      obj->now = (uint8_t *)sasl->mechname;
>      obj->end = obj->now + sasl->len;
>      obj->done = reds_handle_auth_mechname;
> @@ -2465,7 +2465,7 @@ static void reds_start_auth_sasl(RedLinkInfo *link)
>      localAddr = remoteAddr = NULL;
>  
>      if (err != SASL_OK) {
> -        red_printf("sasl context setup failed %d (%s)",
> +        spice_printerr("sasl context setup failed %d (%s)",
>                     err, sasl_errstring(err, NULL, NULL));
>          sasl->conn = NULL;
>          goto error;
> @@ -2478,7 +2478,7 @@ 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)",
> +            spice_printerr("cannot set SASL external SSF %d (%s)",
>                         err, sasl_errstring(err, NULL, NULL));
>              sasl_dispose(&sasl->conn);
>              sasl->conn = NULL;
> @@ -2508,7 +2508,7 @@ 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)",
> +        spice_printerr("cannot set SASL security props %d (%s)",
>                     err, sasl_errstring(err, NULL, NULL));
>          sasl_dispose(&sasl->conn);
>          sasl->conn = NULL;
> @@ -2524,24 +2524,24 @@ static void reds_start_auth_sasl(RedLinkInfo *link)
>                          NULL,
>                          NULL);
>      if (err != SASL_OK) {
> -        red_printf("cannot list SASL mechanisms %d (%s)",
> +        spice_printerr("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);
> +    spice_printerr("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");
> +        spice_printerr("SASL mechanisms write error");
>          goto error;
>      }
>  
> -    red_printf("Wait for client mechname length");
> +    spice_printerr("Wait for client mechname length");
>      obj->now = (uint8_t *)&sasl->len;
>      obj->end = obj->now + sizeof(uint32_t);
>      obj->done = reds_handle_auth_mechlen;
> @@ -2559,7 +2559,7 @@ static void reds_handle_auth_mechanism(void *opaque)
>  {
>      RedLinkInfo *link = (RedLinkInfo *)opaque;
>  
> -    red_printf("Auth method: %d", link->auth_mechanism.auth_mechanism);
> +    spice_printerr("Auth method: %d", link->auth_mechanism.auth_mechanism);
>  
>      if (link->auth_mechanism.auth_mechanism == SPICE_COMMON_CAP_AUTH_SPICE
>          && !sasl_enabled
> @@ -2567,13 +2567,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");
> +        spice_printerr("Starting SASL");
>          reds_start_auth_sasl(link);
>  #endif
>      } else {
> -        red_printf("Unknown auth method, disconnecting");
> +        spice_printerr("Unknown auth method, disconnecting");
>          if (sasl_enabled) {
> -            red_printf("Your client doesn't handle SASL?");
> +            spice_printerr("Your client doesn't handle SASL?");
>          }
>          reds_send_link_error(link, SPICE_LINK_ERR_INVALID_DATA);
>          reds_link_free(link);
> @@ -2610,10 +2610,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);
> +            spice_printerr("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);
> +            spice_printerr("spice channels %d should be encrypted", link_mess->channel_type);
>              reds_send_link_error(link, SPICE_LINK_ERR_NEED_SECURED);
>          }
>          reds_link_free(link);
> @@ -2627,11 +2627,11 @@ static void reds_handle_read_link_done(void *opaque)
>  
>      if (!auth_selection) {
>          if (sasl_enabled && !link->skip_auth) {
> -            red_printf("SASL enabled, but peer supports only spice authentication");
> +            spice_printerr("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");
> +        spice_printerr("Peer doesn't support AUTH selection");
>          reds_get_spice_ticket(link);
>      } else {
>          obj->now = (uint8_t *)&link->auth_mechanism;
> @@ -2649,7 +2649,7 @@ static void reds_handle_link_error(void *opaque, int err)
>      case EPIPE:
>          break;
>      default:
> -        red_printf("%s", strerror(errno));
> +        spice_printerr("%s", strerror(errno));
>          break;
>      }
>      reds_link_free(link);
> @@ -2672,7 +2672,7 @@ static void reds_handle_read_header_done(void *opaque)
>              reds_send_link_error(link, SPICE_LINK_ERR_VERSION_MISMATCH);
>          }
>  
> -        red_printf("version mismatch");
> +        spice_printerr("version mismatch");
>          reds_link_free(link);
>          return;
>      }
> @@ -2681,7 +2681,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);
> +        spice_printerr("bad size %u", header->size);
>          reds_link_free(link);
>          return;
>      }
> @@ -2714,7 +2714,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);
> +            spice_printerr("SSL_accept failed, error=%d", ssl_error);
>              reds_link_free(link);
>          } else {
>              if (ssl_error == SSL_ERROR_WANT_READ) {
> @@ -2737,18 +2737,18 @@ static RedLinkInfo *reds_init_client_connection(int socket)
>      int flags;
>  
>      if ((flags = fcntl(socket, F_GETFL)) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          goto error;
>      }
>  
>      if (fcntl(socket, F_SETFL, flags | O_NONBLOCK) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          goto error;
>      }
>  
>      if (setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
>          if (errno != ENOTSUP) {
> -            red_printf("setsockopt failed, %s", strerror(errno));
> +            spice_printerr("setsockopt failed, %s", strerror(errno));
>          }
>      }
>  
> @@ -2798,13 +2798,13 @@ static RedLinkInfo *reds_init_client_ssl_connection(int socket)
>  
>      // Handle SSL handshaking
>      if (!(sbio = BIO_new_socket(link->stream->socket, BIO_NOCLOSE))) {
> -        red_printf("could not allocate ssl bio socket");
> +        spice_printerr("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");
> +        spice_printerr("could not allocate ssl context");
>          BIO_free(sbio);
>          goto error;
>      }
> @@ -2832,7 +2832,7 @@ static RedLinkInfo *reds_init_client_ssl_connection(int socket)
>      }
>  
>      ERR_print_errors_fp(stderr);
> -    red_printf("SSL_accept failed, error=%d", ssl_error);
> +    spice_printerr("SSL_accept failed, error=%d", ssl_error);
>      SSL_free(link->stream->ssl);
>  
>  error:
> @@ -2848,7 +2848,7 @@ static void reds_accept_ssl_connection(int fd, int event, void *data)
>      int socket;
>  
>      if ((socket = accept(reds->secure_listen_socket, NULL, 0)) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          return;
>      }
>  
> @@ -2864,7 +2864,7 @@ static void reds_accept(int fd, int event, void *data)
>      int socket;
>  
>      if ((socket = accept(reds->listen_socket, NULL, 0)) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          return;
>      }
>  
> @@ -2878,9 +2878,9 @@ SPICE_GNUC_VISIBLE int spice_server_add_client(SpiceServer *s, int socket, int s
>      RedLinkInfo *link;
>      RedsStream *stream;
>  
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (!(link = reds_init_client_connection(socket))) {
> -        red_printf("accept failed");
> +        spice_printerr("accept failed");
>          return -1;
>      }
>  
> @@ -2900,7 +2900,7 @@ SPICE_GNUC_VISIBLE int spice_server_add_ssl_client(SpiceServer *s, int socket, i
>  {
>      RedLinkInfo *link;
>  
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (!(link = reds_init_client_ssl_connection(socket))) {
>          return -1;
>      }
> @@ -2927,7 +2927,7 @@ static int reds_init_socket(const char *addr, int portnr, int family)
>      snprintf(port, sizeof(port), "%d", portnr);
>      rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
>      if (rc != 0) {
> -        red_error("getaddrinfo(%s,%s): %s", addr, port,
> +        spice_error("getaddrinfo(%s,%s): %s", addr, port,
>                    gai_strerror(rc));
>      }
>  
> @@ -2953,7 +2953,7 @@ static int reds_init_socket(const char *addr, int portnr, int family)
>          }
>          close(slisten);
>      }
> -    red_printf("%s: binding socket to %s:%d failed", __FUNCTION__,
> +    spice_printerr("%s: binding socket to %s:%d failed", __FUNCTION__,
>                 addr, portnr);
>      freeaddrinfo(res);
>      return -1;
> @@ -2961,7 +2961,7 @@ static int reds_init_socket(const char *addr, int portnr, int family)
>  listen:
>      freeaddrinfo(res);
>      if (listen(slisten,1) != 0) {
> -        red_error("%s: listen: %s", __FUNCTION__, strerror(errno));
> +        spice_error("listen: %s", strerror(errno));
>          close(slisten);
>          return -1;
>      }
> @@ -2979,7 +2979,7 @@ static int reds_init_net(void)
>                                               SPICE_WATCH_EVENT_READ,
>                                               reds_accept, NULL);
>          if (reds->listen_watch == NULL) {
> -            red_error("set fd handle failed");
> +            spice_error("set fd handle failed");
>          }
>      }
>  
> @@ -2993,7 +2993,7 @@ static int reds_init_net(void)
>                                                      SPICE_WATCH_EVENT_READ,
>                                                      reds_accept_ssl_connection, NULL);
>          if (reds->secure_listen_watch == NULL) {
> -            red_error("set fd handle failed");
> +            spice_error("set fd handle failed");
>          }
>      }
>  
> @@ -3003,7 +3003,7 @@ static int reds_init_net(void)
>                                               SPICE_WATCH_EVENT_READ,
>                                               reds_accept, NULL);
>          if (reds->listen_watch == NULL) {
> -            red_error("set fd handle failed");
> +            spice_error("set fd handle failed");
>          }
>      }
>      return 0;
> @@ -3015,18 +3015,18 @@ static void load_dh_params(SSL_CTX *ctx, char *file)
>      BIO *bio;
>  
>      if ((bio = BIO_new_file(file, "r")) == NULL) {
> -        red_error("Could not open DH file");
> +        spice_error("Could not open DH file");
>      }
>  
>      ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
>      if (ret == 0) {
> -        red_error("Could not read DH params");
> +        spice_error("Could not read DH params");
>      }
>  
>      BIO_free(bio);
>  
>      if (SSL_CTX_set_tmp_dh(ctx, ret) < 0) {
> -        red_error("Could not set DH params");
> +        spice_error("Could not set DH params");
>      }
>  }
>  
> @@ -3094,7 +3094,7 @@ static void reds_init_ssl(void)
>      ssl_method = TLSv1_method();
>      reds->ctx = SSL_CTX_new(ssl_method);
>      if (!reds->ctx) {
> -        red_error("Could not allocate new SSL context");
> +        spice_error("Could not allocate new SSL context");
>      }
>  
>      /* Limit connection to TLSv1 only */
> @@ -3106,9 +3106,9 @@ static void reds_init_ssl(void)
>      /* Load our keys and certificates*/
>      return_code = SSL_CTX_use_certificate_chain_file(reds->ctx, ssl_parameters.certs_file);
>      if (return_code == 1) {
> -        red_printf("Loaded certificates from %s", ssl_parameters.certs_file);
> +        spice_printerr("Loaded certificates from %s", ssl_parameters.certs_file);
>      } else {
> -        red_error("Could not load certificates from %s", ssl_parameters.certs_file);
> +        spice_error("Could not load certificates from %s", ssl_parameters.certs_file);
>      }
>  
>      SSL_CTX_set_default_passwd_cb(reds->ctx, ssl_password_cb);
> @@ -3116,17 +3116,17 @@ static void reds_init_ssl(void)
>      return_code = SSL_CTX_use_PrivateKey_file(reds->ctx, ssl_parameters.private_key_file,
>                                                SSL_FILETYPE_PEM);
>      if (return_code == 1) {
> -        red_printf("Using private key from %s", ssl_parameters.private_key_file);
> +        spice_printerr("Using private key from %s", ssl_parameters.private_key_file);
>      } else {
> -        red_error("Could not use private key file");
> +        spice_error("Could not use private key file");
>      }
>  
>      /* Load the CAs we trust*/
>      return_code = SSL_CTX_load_verify_locations(reds->ctx, ssl_parameters.ca_certificate_file, 0);
>      if (return_code == 1) {
> -        red_printf("Loaded CA certificates from %s", ssl_parameters.ca_certificate_file);
> +        spice_printerr("Loaded CA certificates from %s", ssl_parameters.ca_certificate_file);
>      } else {
> -        red_error("Could not use CA file %s", ssl_parameters.ca_certificate_file);
> +        spice_error("Could not use CA file %s", ssl_parameters.ca_certificate_file);
>      }
>  
>  #if (OPENSSL_VERSION_NUMBER < 0x00905100L)
> @@ -3197,7 +3197,7 @@ enum {
>  static inline void on_activating_ticketing(void)
>  {
>      if (!ticketing_enabled && reds_main_channel_connected()) {
> -        red_printf("disconnecting");
> +        spice_printerr("disconnecting");
>          reds_disconnect();
>      }
>  }
> @@ -3249,8 +3249,8 @@ static void reds_mig_release(void)
>  
>  static void reds_mig_started(void)
>  {
> -    red_printf("");
> -    ASSERT(reds->mig_spice);
> +    spice_printerr("");
> +    spice_assert(reds->mig_spice);
>  
>      reds->mig_inprogress = TRUE;
>      reds->mig_wait_connect = TRUE;
> @@ -3259,10 +3259,10 @@ static void reds_mig_started(void)
>  
>  static void reds_mig_finished(int completed)
>  {
> -    red_printf("");
> +    spice_printerr("");
>  
>      if (!reds_main_channel_connected()) {
> -        red_printf("no peer connected");
> +        spice_printerr("no peer connected");
>          return;
>      }
>      reds->mig_inprogress = TRUE;
> @@ -3279,7 +3279,7 @@ static void reds_mig_finished(int completed)
>  static void reds_mig_switch(void)
>  {
>      if (!reds->mig_spice) {
> -        red_printf("warning: reds_mig_switch called without migrate_info set");
> +        spice_printerr("warning: reds_mig_switch called without migrate_info set");
>          return;
>      }
>      main_channel_migrate_switch(reds->main_channel, reds->mig_spice);
> @@ -3288,8 +3288,8 @@ static void reds_mig_switch(void)
>  
>  static void migrate_timeout(void *opaque)
>  {
> -    red_printf("");
> -    ASSERT(reds->mig_wait_connect || reds->mig_wait_disconnect);
> +    spice_printerr("");
> +    spice_assert(reds->mig_wait_connect || reds->mig_wait_disconnect);
>      if (reds->mig_wait_connect) {
>          /* we will fall back to the switch host scheme when migration completes */
>          main_channel_migrate_cancel_wait(reds->main_channel);
> @@ -3385,10 +3385,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);
> +    spice_printerr("CHAR_DEVICE %s", char_device->subtype);
>      if (strcmp(char_device->subtype, SUBTYPE_VDAGENT) == 0) {
>          if (vdagent) {
> -            red_printf("vdagent already attached");
> +            spice_printerr("vdagent already attached");
>              return -1;
>          }
>          char_device->st = &vdagent_char_device_state;
> @@ -3412,7 +3412,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);
> +    spice_printerr("remove CHAR_DEVICE %s", char_device->subtype);
>      if (strcmp(char_device->subtype, SUBTYPE_VDAGENT) == 0) {
>          if (vdagent) {
>              reds_agent_remove();
> @@ -3433,23 +3433,23 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
>  {
>      const SpiceBaseInterface *interface = sin->sif;
>  
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>  
>      if (strcmp(interface->type, SPICE_INTERFACE_KEYBOARD) == 0) {
> -        red_printf("SPICE_INTERFACE_KEYBOARD");
> +        spice_printerr("SPICE_INTERFACE_KEYBOARD");
>          if (interface->major_version != SPICE_INTERFACE_KEYBOARD_MAJOR ||
>              interface->minor_version > SPICE_INTERFACE_KEYBOARD_MINOR) {
> -            red_printf("unsupported keyboard interface");
> +            spice_printerr("unsupported keyboard interface");
>              return -1;
>          }
>          if (inputs_set_keyboard(SPICE_CONTAINEROF(sin, SpiceKbdInstance, base)) != 0) {
>              return -1;
>          }
>      } else if (strcmp(interface->type, SPICE_INTERFACE_MOUSE) == 0) {
> -        red_printf("SPICE_INTERFACE_MOUSE");
> +        spice_printerr("SPICE_INTERFACE_MOUSE");
>          if (interface->major_version != SPICE_INTERFACE_MOUSE_MAJOR ||
>              interface->minor_version > SPICE_INTERFACE_MOUSE_MINOR) {
> -            red_printf("unsupported mouse interface");
> +            spice_printerr("unsupported mouse interface");
>              return -1;
>          }
>          if (inputs_set_mouse(SPICE_CONTAINEROF(sin, SpiceMouseInstance, base)) != 0) {
> @@ -3458,10 +3458,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");
> +        spice_printerr("SPICE_INTERFACE_QXL");
>          if (interface->major_version != SPICE_INTERFACE_QXL_MAJOR ||
>              interface->minor_version > SPICE_INTERFACE_QXL_MINOR) {
> -            red_printf("unsupported qxl interface");
> +            spice_printerr("unsupported qxl interface");
>              return -1;
>          }
>  
> @@ -3471,10 +3471,10 @@ 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");
> +        spice_printerr("SPICE_INTERFACE_TABLET");
>          if (interface->major_version != SPICE_INTERFACE_TABLET_MAJOR ||
>              interface->minor_version > SPICE_INTERFACE_TABLET_MINOR) {
> -            red_printf("unsupported tablet interface");
> +            spice_printerr("unsupported tablet interface");
>              return -1;
>          }
>          if (inputs_set_tablet(SPICE_CONTAINEROF(sin, SpiceTabletInstance, base)) != 0) {
> @@ -3486,19 +3486,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");
> +        spice_printerr("SPICE_INTERFACE_PLAYBACK");
>          if (interface->major_version != SPICE_INTERFACE_PLAYBACK_MAJOR ||
>              interface->minor_version > SPICE_INTERFACE_PLAYBACK_MINOR) {
> -            red_printf("unsupported playback interface");
> +            spice_printerr("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");
> +        spice_printerr("SPICE_INTERFACE_RECORD");
>          if (interface->major_version != SPICE_INTERFACE_RECORD_MAJOR ||
>              interface->minor_version > SPICE_INTERFACE_RECORD_MINOR) {
> -            red_printf("unsupported record interface");
> +            spice_printerr("unsupported record interface");
>              return -1;
>          }
>          snd_attach_record(SPICE_CONTAINEROF(sin, SpiceRecordInstance, base));
> @@ -3506,7 +3506,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");
> +            spice_printerr("unsupported char device interface");
>              return -1;
>          }
>          spice_server_char_device_add_interface(s, sin);
> @@ -3514,33 +3514,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");
> +        spice_printerr("SPICE_INTERFACE_NET_WIRE");
>          if (red_tunnel) {
> -            red_printf("net wire already attached");
> +            spice_printerr("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");
> +            spice_printerr("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");
> +        spice_printerr("unsupported net wire interface");
>          return -1;
>  #endif
>      } else if (strcmp(interface->type, SPICE_INTERFACE_MIGRATION) == 0) {
> -        red_printf("SPICE_INTERFACE_MIGRATION");
> +        spice_printerr("SPICE_INTERFACE_MIGRATION");
>          if (migration_interface) {
> -            red_printf("already have migration");
> +            spice_printerr("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");
> +            spice_printerr("unsupported migration interface");
>              return -1;
>          }
>          migration_interface = SPICE_CONTAINEROF(sin, SpiceMigrateInstance, base);
> @@ -3555,21 +3555,21 @@ 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");
> +        spice_printerr("remove SPICE_INTERFACE_TABLET");
>          inputs_detach_tablet(SPICE_CONTAINEROF(sin, SpiceTabletInstance, base));
>          reds_update_mouse_mode();
>      } else if (strcmp(interface->type, SPICE_INTERFACE_PLAYBACK) == 0) {
> -        red_printf("remove SPICE_INTERFACE_PLAYBACK");
> +        spice_printerr("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");
> +        spice_printerr("remove SPICE_INTERFACE_RECORD");
>          snd_detach_record(SPICE_CONTAINEROF(sin, SpiceRecordInstance, base));
>  
>      } else if (strcmp(interface->type, SPICE_INTERFACE_CHAR_DEVICE) == 0) {
>          spice_server_char_device_remove_interface(sin);
>      } else {
> -        red_error("VD_INTERFACE_REMOVING unsupported");
> +        spice_error("VD_INTERFACE_REMOVING unsupported");
>          return -1;
>      }
>  
> @@ -3642,10 +3642,10 @@ const char *version_string = VERSION;
>  
>  static int do_spice_init(SpiceCoreInterface *core_interface)
>  {
> -    red_printf("starting %s", version_string);
> +    spice_printerr("starting %s", version_string);
>  
>      if (core_interface->base.major_version != SPICE_INTERFACE_CORE_MAJOR) {
> -        red_printf("bad core interface version");
> +        spice_printerr("bad core interface version");
>          goto err;
>      }
>      core = core_interface;
> @@ -3659,11 +3659,11 @@ static int do_spice_init(SpiceCoreInterface *core_interface)
>      ring_init(&reds->mig_target_clients);
>  
>      if (!(reds->mig_timer = core->timer_add(migrate_timeout, NULL))) {
> -        red_error("migration timer create failed");
> +        spice_error("migration timer create failed");
>      }
>      if (!(reds->vdi_port_write_timer = core->timer_add(vdi_port_write_retry, NULL)))
>      {
> -        red_error("vdi port write timer create failed");
> +        spice_error("vdi port write timer create failed");
>      }
>      reds->vdi_port_write_timer_started = FALSE;
>  
> @@ -3674,26 +3674,26 @@ static int do_spice_init(SpiceCoreInterface *core_interface)
>      reds->stat_shm_name = (char *)spice_malloc(shm_name_len);
>      snprintf(reds->stat_shm_name, shm_name_len, SPICE_STAT_SHM_NAME, getpid());
>      if ((fd = shm_open(reds->stat_shm_name, O_CREAT | O_RDWR, 0444)) == -1) {
> -        red_error("statistics shm_open failed, %s", strerror(errno));
> +        spice_error("statistics shm_open failed, %s", strerror(errno));
>      }
>      if (ftruncate(fd, REDS_STAT_SHM_SIZE) == -1) {
> -        red_error("statistics ftruncate failed, %s", strerror(errno));
> +        spice_error("statistics ftruncate failed, %s", strerror(errno));
>      }
>      reds->stat = (SpiceStat *)mmap(NULL, REDS_STAT_SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
>      if (reds->stat == (SpiceStat *)MAP_FAILED) {
> -        red_error("statistics mmap failed, %s", strerror(errno));
> +        spice_error("statistics mmap failed, %s", strerror(errno));
>      }
>      memset(reds->stat, 0, REDS_STAT_SHM_SIZE);
>      reds->stat->magic = SPICE_STAT_MAGIC;
>      reds->stat->version = SPICE_STAT_VERSION;
>      reds->stat->root_index = INVALID_STAT_REF;
>      if (pthread_mutex_init(&reds->stat_lock, NULL)) {
> -        red_error("mutex init failed");
> +        spice_error("mutex init failed");
>      }
>  #endif
>  
>      if (!(reds->mm_timer = core->timer_add(mm_timer_proc, NULL))) {
> -        red_error("mm timer create failed");
> +        spice_error("mm timer create failed");
>      }
>      core->timer_start(reds->mm_timer, MM_TIMER_GRANULARITY_MS);
>  
> @@ -3707,7 +3707,7 @@ static int do_spice_init(SpiceCoreInterface *core_interface)
>      int saslerr;
>      if ((saslerr = sasl_server_init(NULL, sasl_appname ?
>                                      sasl_appname : "spice")) != SASL_OK) {
> -        red_error("Failed to initialize SASL auth %s",
> +        spice_error("Failed to initialize SASL auth %s",
>                    sasl_errstring(saslerr, NULL, NULL));
>          goto err;
>      }
> @@ -3719,7 +3719,7 @@ static int do_spice_init(SpiceCoreInterface *core_interface)
>      reds->mouse_mode = SPICE_MOUSE_MODE_SERVER;
>      reds->allow_multiple_clients = getenv(SPICE_DEBUG_ALLOW_MC_ENV) != NULL;
>      if (reds->allow_multiple_clients) {
> -        red_printf("spice: allowing multiple client connections");
> +        spice_printerr("spice: allowing multiple client connections");
>      }
>      atexit(reds_exit);
>      return 0;
> @@ -3732,7 +3732,7 @@ err:
>  SPICE_GNUC_VISIBLE SpiceServer *spice_server_new(void)
>  {
>      /* we can't handle multiple instances (yet) */
> -    ASSERT(reds == NULL);
> +    spice_assert(reds == NULL);
>  
>      reds = spice_new0(RedsState, 1);
>      return reds;
> @@ -3742,7 +3742,7 @@ SPICE_GNUC_VISIBLE int spice_server_init(SpiceServer *s, SpiceCoreInterface *cor
>  {
>      int ret;
>  
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      ret = do_spice_init(core);
>      if (default_renderer) {
>          red_dispatcher_add_renderer(default_renderer);
> @@ -3752,7 +3752,7 @@ SPICE_GNUC_VISIBLE int spice_server_init(SpiceServer *s, SpiceCoreInterface *cor
>  
>  SPICE_GNUC_VISIBLE void spice_server_destroy(SpiceServer *s)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      reds_exit();
>  }
>  
> @@ -3778,7 +3778,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_compat_version(SpiceServer *s,
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_port(SpiceServer *s, int port)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (port < 0 || port > 0xffff) {
>          return -1;
>      }
> @@ -3788,7 +3788,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_port(SpiceServer *s, int port)
>  
>  SPICE_GNUC_VISIBLE void spice_server_set_addr(SpiceServer *s, const char *addr, int flags)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      strncpy(spice_addr, addr, sizeof(spice_addr));
>      if (flags & SPICE_ADDR_FLAG_IPV4_ONLY) {
>          spice_family = PF_INET;
> @@ -3800,14 +3800,14 @@ SPICE_GNUC_VISIBLE void spice_server_set_addr(SpiceServer *s, const char *addr,
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_listen_socket_fd(SpiceServer *s, int listen_fd)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      spice_listen_socket_fd = listen_fd;
>      return 0;
>  }
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_noauth(SpiceServer *s)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      memset(taTicket.password, 0, sizeof(taTicket.password));
>      ticketing_enabled = 0;
>      return 0;
> @@ -3815,7 +3815,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_noauth(SpiceServer *s)
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_sasl(SpiceServer *s, int enabled)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>  #if HAVE_SASL
>      sasl_enabled = enabled;
>      return 0;
> @@ -3826,7 +3826,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_sasl(SpiceServer *s, int enabled)
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_sasl_appname(SpiceServer *s, const char *appname)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>  #if HAVE_SASL
>      free(sasl_appname);
>      sasl_appname = strdup(appname);
> @@ -3853,7 +3853,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_ticket(SpiceServer *s,
>                                                 int fail_if_connected,
>                                                 int disconnect_if_connected)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>  
>      if (reds_main_channel_connected()) {
>          if (fail_if_connected) {
> @@ -3886,7 +3886,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_tls(SpiceServer *s, int port,
>                                              const char *private_key_file, const char *key_passwd,
>                                              const char *dh_key_file, const char *ciphersuite)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (port == 0 || ca_cert_file == NULL || certs_file == NULL ||
>          private_key_file == NULL) {
>          return -1;
> @@ -3922,22 +3922,22 @@ SPICE_GNUC_VISIBLE int spice_server_set_tls(SpiceServer *s, int port,
>  SPICE_GNUC_VISIBLE int spice_server_set_image_compression(SpiceServer *s,
>                                                            spice_image_compression_t comp)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      set_image_compression(comp);
>      return 0;
>  }
>  
>  SPICE_GNUC_VISIBLE spice_image_compression_t spice_server_get_image_compression(SpiceServer *s)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      return image_compression;
>  }
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_jpeg_compression(SpiceServer *s, spice_wan_compression_t comp)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (comp == SPICE_WAN_COMPRESSION_INVALID) {
> -        red_printf("invalid jpeg state");
> +        spice_printerr("invalid jpeg state");
>          return -1;
>      }
>      // todo: support dynamically changing the state
> @@ -3947,9 +3947,9 @@ SPICE_GNUC_VISIBLE int spice_server_set_jpeg_compression(SpiceServer *s, spice_w
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_zlib_glz_compression(SpiceServer *s, spice_wan_compression_t comp)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (comp == SPICE_WAN_COMPRESSION_INVALID) {
> -        red_printf("invalid zlib_glz state");
> +        spice_printerr("invalid zlib_glz state");
>          return -1;
>      }
>      // todo: support dynamically changing the state
> @@ -3975,7 +3975,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_channel_security(SpiceServer *s, const c
>      };
>      int i;
>  
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>  
>      if (channel == NULL) {
>          default_channel_security = security;
> @@ -3992,7 +3992,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_channel_security(SpiceServer *s, const c
>  
>  SPICE_GNUC_VISIBLE int spice_server_get_sock_info(SpiceServer *s, struct sockaddr *sa, socklen_t *salen)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (main_channel_getsockname(reds->main_channel, sa, salen) < 0) {
>          return -1;
>      }
> @@ -4001,7 +4001,7 @@ SPICE_GNUC_VISIBLE int spice_server_get_sock_info(SpiceServer *s, struct sockadd
>  
>  SPICE_GNUC_VISIBLE int spice_server_get_peer_info(SpiceServer *s, struct sockaddr *sa, socklen_t *salen)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (main_channel_getpeername(reds->main_channel, sa, salen) < 0) {
>          return -1;
>      }
> @@ -4010,7 +4010,7 @@ SPICE_GNUC_VISIBLE int spice_server_get_peer_info(SpiceServer *s, struct sockadd
>  
>  SPICE_GNUC_VISIBLE int spice_server_add_renderer(SpiceServer *s, const char *name)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (!red_dispatcher_add_renderer(name)) {
>          return -1;
>      }
> @@ -4026,7 +4026,7 @@ SPICE_GNUC_VISIBLE int spice_server_kbd_leds(SpiceKbdInstance *sin, int leds)
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_streaming_video(SpiceServer *s, int value)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      if (value != SPICE_STREAM_VIDEO_OFF &&
>          value != SPICE_STREAM_VIDEO_ALL &&
>          value != SPICE_STREAM_VIDEO_FILTER)
> @@ -4038,14 +4038,14 @@ SPICE_GNUC_VISIBLE int spice_server_set_streaming_video(SpiceServer *s, int valu
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_playback_compression(SpiceServer *s, int enable)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      snd_set_playback_compression(enable);
>      return 0;
>  }
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_agent_mouse(SpiceServer *s, int enable)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      agent_mouse = enable;
>      reds_update_mouse_mode();
>      return 0;
> @@ -4053,7 +4053,7 @@ SPICE_GNUC_VISIBLE int spice_server_set_agent_mouse(SpiceServer *s, int enable)
>  
>  SPICE_GNUC_VISIBLE int spice_server_set_agent_copypaste(SpiceServer *s, int enable)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>      agent_copypaste = enable;
>      reds->agent_state.write_filter.copy_paste_enabled = agent_copypaste;
>      reds->agent_state.read_filter.copy_paste_enabled = agent_copypaste;
> @@ -4092,12 +4092,12 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_connect(SpiceServer *s, const char*
>  {
>      SpiceMigrateInterface *sif;
>  
> -    red_printf("");
> -    ASSERT(migration_interface);
> -    ASSERT(reds == s);
> +    spice_printerr("");
> +    spice_assert(migration_interface);
> +    spice_assert(reds == s);
>  
>      if (reds->expect_migrate) {
> -        red_printf("warning: consecutive calls without migration. Canceling previous call");
> +        spice_printerr("warning: consecutive calls without migration. Canceling previous call");
>          main_channel_migrate_complete(reds->main_channel, FALSE);
>      }
>  
> @@ -4116,7 +4116,7 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_connect(SpiceServer *s, const char*
>      } else {
>          if (reds->num_clients == 0) {
>              reds_mig_release();
> -            red_printf("no client connected");
> +            spice_printerr("no client connected");
>          }
>          sif->migrate_connect_complete(migration_interface);
>      }
> @@ -4128,9 +4128,9 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_info(SpiceServer *s, const char* des
>                                            int port, int secure_port,
>                                            const char* cert_subject)
>  {
> -    red_printf("");
> -    ASSERT(!migration_interface);
> -    ASSERT(reds == s);
> +    spice_printerr("");
> +    spice_assert(!migration_interface);
> +    spice_assert(reds == s);
>  
>      if (!reds_set_migration_dest_info(dest, port, secure_port, cert_subject)) {
>          return -1;
> @@ -4140,8 +4140,8 @@ 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("");
> +    spice_assert(reds == s);
> +    spice_printerr("");
>      if (!reds->mig_spice) {
>          return -1;
>      }
> @@ -4150,7 +4150,7 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_start(SpiceServer *s)
>  
>  SPICE_GNUC_VISIBLE int spice_server_migrate_client_state(SpiceServer *s)
>  {
> -    ASSERT(reds == s);
> +    spice_assert(reds == s);
>  
>      if (!reds_main_channel_connected()) {
>          return SPICE_MIGRATE_CLIENT_NONE;
> @@ -4167,14 +4167,14 @@ SPICE_GNUC_VISIBLE int spice_server_migrate_end(SpiceServer *s, int completed)
>      SpiceMigrateInterface *sif;
>      int ret = 0;
>  
> -    red_printf("");
> +    spice_printerr("");
>  
> -    ASSERT(migration_interface);
> -    ASSERT(reds == s);
> +    spice_assert(migration_interface);
> +    spice_assert(reds == s);
>  
>      sif = SPICE_CONTAINEROF(migration_interface->base.sif, SpiceMigrateInterface, base);
>      if (!reds->expect_migrate && reds->num_clients) {
> -        red_printf("spice_server_migrate_info was not called, disconnecting clients");
> +        spice_printerr("spice_server_migrate_info was not called, disconnecting clients");
>          reds_disconnect();
>          ret = -1;
>          goto complete;
> @@ -4193,8 +4193,8 @@ complete:
>  /* interface for switch-host migration */
>  SPICE_GNUC_VISIBLE int spice_server_migrate_switch(SpiceServer *s)
>  {
> -    ASSERT(reds == s);
> -    red_printf("");
> +    spice_assert(reds == s);
> +    spice_printerr("");
>      if (!reds->num_clients) {
>         return 0;
>      }
> @@ -4278,7 +4278,7 @@ void reds_stream_free(RedsStream *s)
>      }
>  
>      reds_stream_remove_watch(s);
> -    red_printf("close socket fd %d", s->socket);
> +    spice_printerr("close socket fd %d", s->socket);
>      close(s->socket);
>  
>      free(s);
> diff --git a/server/smartcard.c b/server/smartcard.c
> index 84aa18b..71dae31 100644
> --- a/server/smartcard.c
> +++ b/server/smartcard.c
> @@ -101,7 +101,7 @@ void smartcard_char_device_wakeup(SpiceCharDeviceInstance *sin)
>          if (actual_length > state->buf_size) {
>              state->buf_size = MAX(state->buf_size*2, actual_length + sizeof(VSCMsgHeader));
>              state->buf = spice_realloc(state->buf, state->buf_size);
> -            ASSERT(state->buf != NULL);
> +            spice_assert(state->buf != NULL);
>          }
>          if (state->buf_used - sizeof(VSCMsgHeader) < actual_length) {
>              continue;
> @@ -135,7 +135,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);
> +        spice_printerr("error: reader_id not assigned for message of type %d", vheader->type);
>      }
>      if (state->rcc) {
>          sent_header = spice_memdup(vheader, sizeof(*vheader) + vheader->length);
> @@ -176,7 +176,7 @@ static int smartcard_char_device_add_to_readers(SpiceCharDeviceInstance *char_de
>  
>  static SpiceCharDeviceInstance *smartcard_readers_get(uint32_t reader_id)
>  {
> -    ASSERT(reader_id < g_smartcard_readers.num);
> +    spice_assert(reader_id < g_smartcard_readers.num);
>      return g_smartcard_readers.sin[reader_id];
>  }
>  
> @@ -284,15 +284,15 @@ static void smartcard_channel_release_msg_rcv_buf(RedChannelClient *rcc,
>                                                    uint32_t size,
>                                                    uint8_t *msg)
>  {
> -    red_printf("freeing %d bytes", size);
> +    spice_printerr("freeing %d bytes", size);
>      free(msg);
>  }
>  
>  static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *m,
>                                          PipeItem *item, VSCMsgHeader *vheader)
>  {
> -    ASSERT(rcc);
> -    ASSERT(vheader);
> +    spice_assert(rcc);
> +    spice_assert(vheader);
>      red_channel_client_init_send_data(rcc, SPICE_MSG_SMARTCARD_DATA, item);
>      spice_marshaller_add_ref(m, (uint8_t*)vheader, sizeof(VSCMsgHeader));
>      if (vheader->length > 0) {
> @@ -428,7 +428,7 @@ static void smartcard_channel_write_to_reader(VSCMsgHeader *vheader)
>      uint32_t n;
>      uint32_t actual_length = vheader->length;
>  
> -    ASSERT(vheader->reader_id >= 0 &&
> +    spice_assert(vheader->reader_id >= 0 &&
>             vheader->reader_id <= g_smartcard_readers.num);
>      sin = g_smartcard_readers.sin[vheader->reader_id];
>      sif = SPICE_CONTAINEROF(sin->base.sif, SpiceCharDeviceInterface, base);
> @@ -439,7 +439,7 @@ static void smartcard_channel_write_to_reader(VSCMsgHeader *vheader)
>      n = sif->write(sin, (uint8_t*)vheader,
>                     actual_length + sizeof(VSCMsgHeader));
>      // TODO - add ring
> -    ASSERT(n == actual_length + sizeof(VSCMsgHeader));
> +    spice_assert(n == actual_length + sizeof(VSCMsgHeader));
>  }
>  
>  static int smartcard_channel_handle_message(RedChannelClient *rcc,
> @@ -454,7 +454,7 @@ static int smartcard_channel_handle_message(RedChannelClient *rcc,
>          return red_channel_client_handle_message(rcc, size, type, msg);
>      }
>  
> -    ASSERT(size == vheader->length + sizeof(VSCMsgHeader));
> +    spice_assert(size == vheader->length + sizeof(VSCMsgHeader));
>      switch (vheader->type) {
>          case VSC_ReaderAdd:
>              smartcard_add_reader(rcc, msg + sizeof(VSCMsgHeader));
> @@ -479,7 +479,7 @@ static int smartcard_channel_handle_message(RedChannelClient *rcc,
>      }
>  
>      if (vheader->reader_id >= g_smartcard_readers.num) {
> -        red_printf("ERROR: received message for non existent reader: %d, %d, %d", vheader->reader_id,
> +        spice_printerr("ERROR: received message for non existent reader: %d, %d, %d", vheader->reader_id,
>              vheader->type, vheader->length);
>          return FALSE;
>      }
> @@ -515,7 +515,7 @@ static void smartcard_init(void)
>      ChannelCbs channel_cbs = { NULL, };
>      ClientCbs client_cbs = { NULL, };
>  
> -    ASSERT(!g_smartcard_channel);
> +    spice_assert(!g_smartcard_channel);
>  
>      channel_cbs.config_socket = smartcard_channel_client_config_socket;
>      channel_cbs.on_disconnect = smartcard_channel_on_disconnect;
> @@ -533,7 +533,7 @@ static void smartcard_init(void)
>                                               &channel_cbs);
>  
>      if (!g_smartcard_channel) {
> -        red_error("failed to allocate Inputs Channel");
> +        spice_error("failed to allocate Inputs Channel");
>      }
>  
>      client_cbs.connect = smartcard_connect;
> diff --git a/server/snd_worker.c b/server/snd_worker.c
> index 4c51190..b3b44ce 100644
> --- a/server/snd_worker.c
> +++ b/server/snd_worker.c
> @@ -207,7 +207,7 @@ static SndChannel *snd_channel_put(SndChannel *channel)
>      if (!--channel->refs) {
>          channel->worker->connection = NULL;
>          free(channel);
> -        red_printf("sound channel freed");
> +        spice_printerr("sound channel freed");
>          return NULL;
>      }
>      return channel;
> @@ -294,7 +294,7 @@ static int snd_send_data(SndChannel *channel)
>                  snd_disconnect_channel(channel);
>                  return FALSE;
>              default:
> -                red_printf("%s", strerror(errno));
> +                spice_printerr("%s", strerror(errno));
>                  snd_disconnect_channel(channel);
>                  return FALSE;
>              }
> @@ -325,7 +325,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);
> +            spice_printerr("celt decode failed (%d)", celt_err);
>              return FALSE;
>          }
>          data = record_channel->celt_buf;
> @@ -365,7 +365,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);
> +        spice_printerr("invalid message type %u", type);
>          return FALSE;
>      }
>      return TRUE;
> @@ -387,7 +387,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");
> +            spice_printerr("unsupported mode");
>          }
>          break;
>      }
> @@ -401,7 +401,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");
> +            spice_printerr("invalid mig version");
>              break;
>          }
>          record_channel->mode = mig_data->mode;
> @@ -410,7 +410,7 @@ static int snd_record_handle_message(SndChannel *channel, size_t size, uint32_t
>          break;
>      }
>      default:
> -        red_printf("invalid message type %u", type);
> +        spice_printerr("invalid message type %u", type);
>          return FALSE;
>      }
>      return TRUE;
> @@ -430,14 +430,14 @@ static void snd_receive(void* data)
>      for (;;) {
>          ssize_t n;
>          n = channel->recive_data.end - channel->recive_data.now;
> -        ASSERT(n);
> +        spice_assert(n);
>          n = reds_stream_read(channel->stream, channel->recive_data.now, n);
>          if (n <= 0) {
>              if (n == 0) {
>                  snd_disconnect_channel(channel);
>                  return;
>              }
> -            ASSERT(n == -1);
> +            spice_assert(n == -1);
>              switch (errno) {
>              case EAGAIN:
>                  return;
> @@ -447,7 +447,7 @@ static void snd_receive(void* data)
>                  snd_disconnect_channel(channel);
>                  return;
>              default:
> -                red_printf("%s", strerror(errno));
> +                spice_printerr("%s", strerror(errno));
>                  snd_disconnect_channel(channel);
>                  return;
>              }
> @@ -471,7 +471,7 @@ static void snd_receive(void* data)
>                                           header->get_msg_type(header),
>                                           SPICE_VERSION_MINOR, &parsed_size, &parsed_free);
>                  if (parsed == NULL) {
> -                    red_printf("failed to parse message type %d", header->get_msg_type(header));
> +                    spice_printerr("failed to parse message type %d", header->get_msg_type(header));
>                      snd_disconnect_channel(channel);
>                      return;
>                  }
> @@ -628,7 +628,7 @@ static int snd_playback_send_start(PlaybackChannel *playback_channel)
>  
>      start.channels = SPICE_INTERFACE_PLAYBACK_CHAN;
>      start.frequency = SPICE_INTERFACE_PLAYBACK_FREQ;
> -    ASSERT(SPICE_INTERFACE_PLAYBACK_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
> +    spice_assert(SPICE_INTERFACE_PLAYBACK_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
>      start.format = SPICE_AUDIO_FMT_S16;
>      start.time = reds_get_mm_time();
>      spice_marshall_msg_playback_start(channel->send_data.marshaller, &start);
> @@ -669,7 +669,7 @@ static int snd_record_send_start(RecordChannel *record_channel)
>  
>      start.channels = SPICE_INTERFACE_RECORD_CHAN;
>      start.frequency = SPICE_INTERFACE_RECORD_FREQ;
> -    ASSERT(SPICE_INTERFACE_RECORD_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
> +    spice_assert(SPICE_INTERFACE_RECORD_FMT == SPICE_INTERFACE_AUDIO_FMT_S16);
>      start.format = SPICE_AUDIO_FMT_S16;
>      spice_marshall_msg_record_start(channel->send_data.marshaller, &start);
>  
> @@ -782,7 +782,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");
> +            spice_printerr("celt encode failed");
>              snd_disconnect_channel(channel);
>              return FALSE;
>          }
> @@ -828,12 +828,12 @@ static void snd_playback_send(void* data)
>              channel->command &= ~SND_PLAYBACK_MODE_MASK;
>          }
>          if (channel->command & SND_PLAYBACK_PCM_MASK) {
> -            ASSERT(!playback_channel->in_progress && playback_channel->pending_frame);
> +            spice_assert(!playback_channel->in_progress && playback_channel->pending_frame);
>              playback_channel->in_progress = playback_channel->pending_frame;
>              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");
> +                spice_printerr("snd_send_playback_write failed");
>                  return;
>              }
>          }
> @@ -912,7 +912,7 @@ static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_i
>      MainChannelClient *mcc = red_client_get_main(client);
>  
>      if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          goto error1;
>      }
>  
> @@ -921,7 +921,7 @@ static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_i
>      if (setsockopt(stream->socket, SOL_SOCKET, SO_PRIORITY, (void*)&priority,
>                     sizeof(priority)) == -1) {
>          if (errno != ENOTSUP) {
> -            red_printf("setsockopt failed, %s", strerror(errno));
> +            spice_printerr("setsockopt failed, %s", strerror(errno));
>          }
>      }
>  #endif
> @@ -929,23 +929,23 @@ static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_i
>      tos = IPTOS_LOWDELAY;
>      if (setsockopt(stream->socket, IPPROTO_IP, IP_TOS, (void*)&tos, sizeof(tos)) == -1) {
>          if (errno != ENOTSUP) {
> -            red_printf("setsockopt failed, %s", strerror(errno));
> +            spice_printerr("setsockopt failed, %s", strerror(errno));
>          }
>      }
>  
>      delay_val = main_channel_client_is_low_bandwidth(mcc) ? 0 : 1;
>      if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
>          if (errno != ENOTSUP) {
> -            red_printf("setsockopt failed, %s", strerror(errno));
> +            spice_printerr("setsockopt failed, %s", strerror(errno));
>          }
>      }
>  
>      if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
> -        red_printf("accept failed, %s", strerror(errno));
> +        spice_printerr("accept failed, %s", strerror(errno));
>          goto error1;
>      }
>  
> -    ASSERT(size >= sizeof(*channel));
> +    spice_assert(size >= sizeof(*channel));
>      channel = spice_malloc0(size);
>      channel->refs = 1;
>      channel->parser = spice_get_client_channel_parser(channel_id, NULL);
> @@ -959,7 +959,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));
> +        spice_printerr("watch_add failed, %s", strerror(errno));
>          goto error2;
>      }
>  
> @@ -988,13 +988,13 @@ static void snd_disconnect_channel_client(RedChannelClient *rcc)
>  {
>      SndWorker *worker;
>  
> -    ASSERT(rcc->channel);
> -    ASSERT(rcc->channel->data);
> +    spice_assert(rcc->channel);
> +    spice_assert(rcc->channel->data);
>      worker = (SndWorker *)rcc->channel->data;
>  
> -    ASSERT(worker->connection->channel_client == rcc);
> +    spice_assert(worker->connection->channel_client == rcc);
>      snd_disconnect_channel(worker->connection);
> -    ASSERT(worker->connection == NULL);
> +    spice_assert(worker->connection == NULL);
>  }
>  
>  static void snd_set_command(SndChannel *channel, uint32_t command)
> @@ -1045,7 +1045,7 @@ SPICE_GNUC_VISIBLE void spice_server_playback_start(SpicePlaybackInstance *sin)
>      sin->st->worker.active = 1;
>      if (!channel)
>          return;
> -    ASSERT(!playback_channel->base.active);
> +    spice_assert(!playback_channel->base.active);
>      reds_disable_mm_timer();
>      playback_channel->base.active = TRUE;
>      if (!playback_channel->base.client_active) {
> @@ -1064,7 +1064,7 @@ SPICE_GNUC_VISIBLE void spice_server_playback_stop(SpicePlaybackInstance *sin)
>      sin->st->worker.active = 0;
>      if (!channel)
>          return;
> -    ASSERT(playback_channel->base.active);
> +    spice_assert(playback_channel->base.active);
>      reds_enable_mm_timer();
>      playback_channel->base.active = FALSE;
>      if (playback_channel->base.client_active) {
> @@ -1075,7 +1075,7 @@ SPICE_GNUC_VISIBLE void spice_server_playback_stop(SpicePlaybackInstance *sin)
>          playback_channel->base.command &= ~SND_PLAYBACK_PCM_MASK;
>  
>          if (playback_channel->pending_frame) {
> -            ASSERT(!playback_channel->in_progress);
> +            spice_assert(!playback_channel->in_progress);
>              snd_playback_free_frame(playback_channel,
>                                      playback_channel->pending_frame);
>              playback_channel->pending_frame = NULL;
> @@ -1094,7 +1094,7 @@ SPICE_GNUC_VISIBLE void spice_server_playback_get_buffer(SpicePlaybackInstance *
>          *num_samples = 0;
>          return;
>      }
> -    ASSERT(playback_channel->base.active);
> +    spice_assert(playback_channel->base.active);
>      snd_channel_get(channel);
>  
>      *frame = playback_channel->free_frames->samples;
> @@ -1115,7 +1115,7 @@ SPICE_GNUC_VISIBLE void spice_server_playback_put_samples(SpicePlaybackInstance
>          /* lost last reference, channel has been destroyed previously */
>          return;
>      }
> -    ASSERT(playback_channel->base.active);
> +    spice_assert(playback_channel->base.active);
>  
>      if (playback_channel->pending_frame) {
>          snd_playback_free_frame(playback_channel, playback_channel->pending_frame);
> @@ -1133,7 +1133,7 @@ static void on_new_playback_channel(SndWorker *worker)
>      PlaybackChannel *playback_channel =
>          SPICE_CONTAINEROF(worker->connection, PlaybackChannel, base);
>  
> -    ASSERT(playback_channel);
> +    spice_assert(playback_channel);
>  
>      snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_MODE_MASK);
>      if (!playback_channel->base.migrate && playback_channel->base.active) {
> @@ -1174,12 +1174,12 @@ static void snd_set_playback_peer(RedChannel *channel, RedClient *client, RedsSt
>      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);
> +        spice_printerr("create celt mode failed %d", celt_error);
>          return;
>      }
>  
>      if (!(celt_encoder = celt051_encoder_create(celt_mode))) {
> -        red_printf("create celt encoder failed");
> +        spice_printerr("create celt encoder failed");
>          goto error_1;
>      }
>  
> @@ -1227,12 +1227,12 @@ static void snd_record_migrate_channel_client(RedChannelClient *rcc)
>  {
>      SndWorker *worker;
>  
> -    ASSERT(rcc->channel);
> -    ASSERT(rcc->channel->data);
> +    spice_assert(rcc->channel);
> +    spice_assert(rcc->channel->data);
>      worker = (SndWorker *)rcc->channel->data;
>  
>      if (worker->connection) {
> -        ASSERT(worker->connection->channel_client == rcc);
> +        spice_assert(worker->connection->channel_client == rcc);
>          snd_set_command(worker->connection, SND_RECORD_MIGRATE_MASK);
>          snd_record_send(worker->connection);
>      }
> @@ -1278,7 +1278,7 @@ SPICE_GNUC_VISIBLE void spice_server_record_start(SpiceRecordInstance *sin)
>      sin->st->worker.active = 1;
>      if (!channel)
>          return;
> -    ASSERT(!record_channel->base.active);
> +    spice_assert(!record_channel->base.active);
>      record_channel->base.active = TRUE;
>      record_channel->read_pos = record_channel->write_pos = 0;   //todo: improve by
>                                                                  //stream generation
> @@ -1298,7 +1298,7 @@ SPICE_GNUC_VISIBLE void spice_server_record_stop(SpiceRecordInstance *sin)
>      sin->st->worker.active = 0;
>      if (!channel)
>          return;
> -    ASSERT(record_channel->base.active);
> +    spice_assert(record_channel->base.active);
>      record_channel->base.active = FALSE;
>      if (record_channel->base.client_active) {
>          snd_set_command(&record_channel->base, SND_RECORD_CTRL_MASK);
> @@ -1319,7 +1319,7 @@ SPICE_GNUC_VISIBLE uint32_t spice_server_record_get_samples(SpiceRecordInstance
>  
>      if (!channel)
>          return 0;
> -    ASSERT(record_channel->base.active);
> +    spice_assert(record_channel->base.active);
>  
>      if (record_channel->write_pos < RECORD_SAMPLES_SIZE / 2) {
>          return 0;
> @@ -1349,7 +1349,7 @@ SPICE_GNUC_VISIBLE uint32_t spice_server_record_get_samples(SpiceRecordInstance
>  static void on_new_record_channel(SndWorker *worker)
>  {
>      RecordChannel *record_channel = (RecordChannel *)worker->connection;
> -    ASSERT(record_channel);
> +    spice_assert(record_channel);
>  
>      snd_set_command((SndChannel *)record_channel, SND_RECORD_VOLUME_MASK);
>      if (!record_channel->base.migrate) {
> @@ -1383,12 +1383,12 @@ static void snd_set_record_peer(RedChannel *channel, RedClient *client, RedsStre
>      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);
> +        spice_printerr("create celt mode failed %d", celt_error);
>          return;
>      }
>  
>      if (!(celt_decoder = celt051_decoder_create(celt_mode))) {
> -        red_printf("create celt decoder failed");
> +        spice_printerr("create celt decoder failed");
>          goto error_1;
>      }
>  
> @@ -1430,12 +1430,12 @@ static void snd_playback_migrate_channel_client(RedChannelClient *rcc)
>  {
>      SndWorker *worker;
>  
> -    ASSERT(rcc->channel);
> -    ASSERT(rcc->channel->data);
> +    spice_assert(rcc->channel);
> +    spice_assert(rcc->channel->data);
>      worker = (SndWorker *)rcc->channel->data;
>  
>      if (worker->connection) {
> -        ASSERT(worker->connection->channel_client == rcc);
> +        spice_assert(worker->connection->channel_client == rcc);
>          snd_set_command(worker->connection, SND_PLAYBACK_MIGRATE_MASK);
>          snd_playback_send(worker->connection);
>      }
> @@ -1457,7 +1457,7 @@ static void remove_worker(SndWorker *worker)
>          }
>          now = &(*now)->next;
>      }
> -    red_printf("not found");
> +    spice_printerr("not found");
>  }
>  
>  void snd_attach_playback(SpicePlaybackInstance *sin)
> @@ -1560,7 +1560,7 @@ void snd_set_playback_compression(int on)
>              PlaybackChannel* playback = (PlaybackChannel*)now->connection;
>              if (!red_channel_client_test_remote_cap(sndchannel->channel_client,
>                                                      SPICE_PLAYBACK_CAP_CELT_0_5_1)) {
> -                ASSERT(playback->mode == SPICE_AUDIO_DATA_MODE_RAW);
> +                spice_assert(playback->mode == SPICE_AUDIO_DATA_MODE_RAW);
>                  continue;
>              }
>              if (playback->mode != playback_compression) {
> diff --git a/server/spicevmc.c b/server/spicevmc.c
> index 2f1b8f7..f35150c 100644
> --- a/server/spicevmc.c
> +++ b/server/spicevmc.c
> @@ -93,7 +93,7 @@ static int spicevmc_red_channel_client_config_socket(RedChannelClient *rcc)
>          if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY,
>                  &delay_val, sizeof(delay_val)) != 0) {
>              if (errno != ENOTSUP && errno != ENOPROTOOPT) {
> -                red_printf("setsockopt failed, %s", strerror(errno));
> +                spice_printerr("setsockopt failed, %s", strerror(errno));
>                  return FALSE;
>              }
>          }
> @@ -223,8 +223,8 @@ static void spicevmc_connect(RedChannel *channel, RedClient *client,
>      sif = SPICE_CONTAINEROF(sin->base.sif, SpiceCharDeviceInterface, base);
>  
>      if (state->rcc) {
> -        WARN("channel client %d:%d (%p) already connected, refusing second connection\n",
> -             channel->type, channel->id, state->rcc);
> +        spice_printerr("channel client %d:%d (%p) already connected, refusing second connection",
> +                       channel->type, channel->id, state->rcc);
>          // TODO: notify client in advance about the in use channel using
>          // SPICE_MSG_MAIN_CHANNEL_IN_USE (for example)
>          reds_stream_free(stream);
> diff --git a/server/zlib_encoder.c b/server/zlib_encoder.c
> index c51466b..a3d2aa6 100644
> --- a/server/zlib_encoder.c
> +++ b/server/zlib_encoder.c
> @@ -50,7 +50,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");
> +        spice_printerr("zlib error");
>          free(enc);
>          return NULL;
>      }
> @@ -76,7 +76,7 @@ int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
>      z_ret = deflateReset(&zlib->strm);
>  
>      if (z_ret != Z_OK) {
> -        red_error("deflateReset failed");
> +        spice_error("deflateReset failed");
>      }
>  
>      zlib->strm.next_out = io_ptr;
> @@ -86,12 +86,12 @@ int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
>          if (zlib->strm.avail_out == 0) {
>              zlib->strm.avail_out = zlib->usr->more_space(zlib->usr, &zlib->strm.next_out);
>              if (zlib->strm.avail_out == 0) {
> -                red_error("not enough space");
> +                spice_error("not enough space");
>              }
>          }
>          z_ret = deflateParams(&zlib->strm, level, Z_DEFAULT_STRATEGY);
>          if (z_ret != Z_OK) {
> -            red_error("deflateParams failed");
> +            spice_error("deflateParams failed");
>          }
>          zlib->last_level = level;
>      }
> @@ -100,14 +100,14 @@ int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
>      do {
>          zlib->strm.avail_in = zlib->usr->more_input(zlib->usr, &zlib->strm.next_in);
>          if (zlib->strm.avail_in <= 0) {
> -            red_error("more input failed\n");
> +            spice_error("more input failed");
>          }
>          enc_size += zlib->strm.avail_in;
>          flush = (enc_size == input_size) ?  Z_FINISH : Z_NO_FLUSH;
>          while (1) {
>              int deflate_size = zlib->strm.avail_out;
>              z_ret = deflate(&zlib->strm, flush);
> -            ASSERT(z_ret != Z_STREAM_ERROR);
> +            spice_assert(z_ret != Z_STREAM_ERROR);
>              out_size += deflate_size - zlib->strm.avail_out;
>              if (zlib->strm.avail_out) {
>                  break;
> @@ -115,11 +115,11 @@ int zlib_encode(ZlibEncoder *zlib, int level, int input_size,
>  
>              zlib->strm.avail_out = zlib->usr->more_space(zlib->usr, &zlib->strm.next_out);
>              if (zlib->strm.avail_out == 0) {
> -                red_error("not enough space");
> +                spice_error("not enough space");
>              }
>          }
>      } while (flush != Z_FINISH);
>  
> -    ASSERT(z_ret == Z_STREAM_END);
> +    spice_assert(z_ret == Z_STREAM_END);
>      return out_size;
>  }
> -- 
> 1.7.7.6
> 
> _______________________________________________
> Spice-devel mailing list
> Spice-devel at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/spice-devel


More information about the Spice-devel mailing list