[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