summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.gitignore1
-rw-r--r--server/agent-msg-filter.c8
-rw-r--r--server/dispatcher.c34
-rw-r--r--server/inputs_channel.c34
-rw-r--r--server/jpeg_encoder.c14
-rw-r--r--server/main_channel.c66
-rw-r--r--server/mjpeg_encoder.c2
-rw-r--r--server/red_channel.c96
-rw-r--r--server/red_client_cache.h4
-rw-r--r--server/red_client_shared_cache.h8
-rw-r--r--server/red_dispatcher.c37
-rw-r--r--server/red_memslots.c28
-rw-r--r--server/red_parse_qxl.c45
-rw-r--r--server/red_tunnel_worker.c240
-rw-r--r--server/red_worker.c602
-rw-r--r--server/red_worker.h4
-rw-r--r--server/reds.c448
-rw-r--r--server/smartcard.c24
-rw-r--r--server/snd_worker.c98
-rw-r--r--server/spicevmc.c6
-rw-r--r--server/zlib_encoder.c16
21 files changed, 907 insertions, 908 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 c15a7a1..cc20f89 100644
--- a/server/dispatcher.c
+++ b/server/dispatcher.c
@@ -27,14 +27,12 @@
#include <fcntl.h>
#include <poll.h>
+#define SPICE_LOG_DOMAIN "SpiceDispatcher"
+
#include "common/mem.h"
#include "common/spice_common.h"
-
#include "dispatcher.h"
-#define DISPATCHER_DEBUG_PRINTF(level, ...) \
- red_printf_debug(level, "DISP", ##__VA_ARGS__)
-
//#define DEBUG_DISPATCHER
#ifdef DEBUG_DISPATCHER
@@ -64,10 +62,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)) {
@@ -78,13 +76,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;
@@ -105,7 +103,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;
@@ -124,7 +122,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) {
@@ -133,19 +131,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) {
@@ -177,20 +175,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? */
}
@@ -259,7 +257,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 da4c53c..ad247f4 100644
--- a/server/inputs_channel.c
+++ b/server/inputs_channel.c
@@ -115,7 +115,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;
@@ -126,7 +126,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;
@@ -137,7 +137,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;
@@ -152,7 +152,7 @@ int inputs_has_tablet(void)
void inputs_detach_tablet(SpiceTabletInstance *_tablet)
{
- red_printf("");
+ spice_printerr("");
tablet = NULL;
}
@@ -166,7 +166,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;
}
@@ -177,7 +177,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;
@@ -291,7 +291,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;
@@ -333,7 +333,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);
@@ -425,7 +425,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;
@@ -451,7 +451,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);
}
@@ -473,7 +473,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;
}
}
@@ -492,10 +492,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,
@@ -530,7 +530,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;
@@ -551,7 +551,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;
@@ -561,6 +561,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 7a2938c..713f121 100644
--- a/server/main_channel.c
+++ b/server/main_channel.c
@@ -162,7 +162,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);
}
@@ -333,7 +333,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;
}
@@ -482,7 +482,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;
@@ -495,7 +495,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;
@@ -636,7 +636,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 = spice_strdup(mig_target->host);
free(main_channel->mig_target.cert_subject);
@@ -658,7 +658,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;
@@ -689,7 +689,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);
@@ -769,8 +769,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);
}
@@ -784,19 +784,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);
}
}
@@ -805,12 +805,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;
}
@@ -829,7 +829,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;
}
@@ -877,14 +877,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,
@@ -892,7 +892,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);
@@ -914,7 +914,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;
}
@@ -955,7 +955,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")) {
@@ -975,7 +975,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;
}
@@ -1003,7 +1003,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
@@ -1017,12 +1017,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);
@@ -1083,14 +1083,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;
}
@@ -1107,7 +1107,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);
@@ -1129,7 +1129,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;
}
@@ -1143,10 +1143,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;
}
@@ -1159,16 +1159,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 f27abed..4858bb5 100644
--- a/server/red_channel.c
+++ b/server/red_channel.c
@@ -89,7 +89,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)
@@ -99,7 +99,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),
@@ -132,7 +132,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) {
@@ -140,7 +140,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 {
@@ -193,7 +193,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;
}
@@ -218,7 +218,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;
@@ -285,7 +285,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;
}
@@ -362,7 +362,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
@@ -375,7 +375,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);
}
@@ -395,7 +395,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;
@@ -410,7 +410,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:
@@ -463,7 +463,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);
}
}
@@ -476,7 +476,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++;
}
@@ -521,7 +521,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;
@@ -583,7 +583,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)
@@ -605,8 +605,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;
@@ -672,7 +672,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;
@@ -723,7 +723,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) {
@@ -769,7 +769,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;
}
@@ -876,7 +876,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))) {
@@ -938,7 +938,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);
@@ -950,7 +950,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);
@@ -970,7 +970,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;
@@ -990,8 +990,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) {
@@ -1005,7 +1005,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);
@@ -1020,8 +1020,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;
@@ -1060,7 +1060,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);
}
@@ -1074,9 +1074,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);
@@ -1091,14 +1091,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);
@@ -1170,9 +1170,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???
}
@@ -1187,7 +1187,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;
@@ -1222,7 +1222,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;
@@ -1416,8 +1416,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)) {
@@ -1431,8 +1431,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.
@@ -1444,9 +1444,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);
}
@@ -1456,7 +1456,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++;
@@ -1473,7 +1473,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 9a04948..6b96a2e 100644
--- a/server/red_dispatcher.c
+++ b/server/red_dispatcher.c
@@ -44,13 +44,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;
@@ -98,7 +91,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;
@@ -127,7 +120,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
@@ -145,7 +138,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,
@@ -159,7 +152,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;
@@ -186,7 +179,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,
@@ -203,7 +196,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,
@@ -313,7 +306,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;
}
@@ -675,7 +668,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,
@@ -701,7 +694,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;
@@ -920,9 +913,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) {
@@ -943,7 +936,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);
@@ -995,7 +988,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;
@@ -1046,12 +1039,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 249b241..ae2c6e4 100644
--- a/server/red_memslots.c
+++ b/server/red_memslots.c
@@ -55,19 +55,19 @@ unsigned long get_virt_delta(RedMemSlotInfo *info, QXLPHYSICAL addr, int group_i
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)));
@@ -80,12 +80,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,
@@ -103,13 +103,13 @@ unsigned long get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size
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=%" PRIx64, addr);
+ spice_critical("slot_id too big, addr=%" PRIx64, addr);
}
slot = &info->mem_slots[group_id][slot_id];
@@ -117,7 +117,7 @@ unsigned long get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size
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);
}
@@ -152,8 +152,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;
@@ -179,8 +179,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;
@@ -190,8 +190,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 45bf6e1..384c36d 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 172a571..c17a7d0 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
@@ -1113,46 +1115,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 +
@@ -1188,15 +1190,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);
}
}
@@ -1264,7 +1266,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");
}
@@ -1363,8 +1365,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);
}
@@ -1387,7 +1389,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;
}
@@ -1406,7 +1408,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);
}
@@ -1446,7 +1448,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) {
@@ -1592,7 +1594,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;
@@ -1628,7 +1630,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) {
@@ -1644,7 +1646,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));
}
}
@@ -1693,8 +1695,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);
}
@@ -1731,9 +1733,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);
@@ -1769,7 +1771,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);
@@ -1782,7 +1784,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;
@@ -1867,7 +1869,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);
@@ -2080,7 +2082,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);
}
}
@@ -2092,7 +2094,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);
@@ -2128,7 +2130,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) {
@@ -2200,7 +2202,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);
@@ -2228,7 +2230,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);
@@ -2236,7 +2238,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);
@@ -2247,7 +2249,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;
@@ -2402,7 +2404,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);
}
@@ -2413,8 +2415,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;
}
@@ -2438,7 +2440,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) {
@@ -2462,7 +2464,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;
@@ -2489,8 +2491,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;
@@ -2510,13 +2512,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);
}
@@ -2536,7 +2538,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;
@@ -2682,7 +2684,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);
}
@@ -2736,7 +2738,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);
@@ -2760,13 +2762,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;
@@ -2919,7 +2921,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;
@@ -2962,7 +2964,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;
@@ -3211,7 +3213,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");
}
}
@@ -3230,7 +3232,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);
@@ -3298,11 +3300,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;
}
@@ -3465,17 +3467,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 -
@@ -3514,7 +3516,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;
}
@@ -3614,7 +3616,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;
@@ -3752,7 +3754,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;
@@ -3851,7 +3853,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.
@@ -3862,7 +3864,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);
@@ -3921,7 +3923,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;
@@ -3946,7 +3948,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
@@ -3973,7 +3975,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);
}
@@ -4028,8 +4030,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;
}
@@ -4061,7 +4063,7 @@ static void localize_bitmap(RedWorker *worker, SpiceImage **image_ptr, SpiceImag
/* nothing */
break;
default:
- red_error("invalid image type");
+ spice_error("invalid image type");
}
}
@@ -4204,7 +4206,7 @@ static void red_draw_qxl_drawable(RedWorker *worker, Drawable *drawable)
break;
}
default:
- red_printf("invalid type");
+ spice_printerr("invalid type");
}
}
@@ -4242,7 +4244,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);
@@ -4280,7 +4282,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;
@@ -4353,8 +4355,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];
@@ -4471,7 +4473,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);
@@ -4533,7 +4535,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
}
@@ -4551,7 +4553,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;
@@ -4562,7 +4564,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;
}
@@ -4580,13 +4582,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);
@@ -4617,7 +4619,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 ||
@@ -4675,7 +4677,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++;
}
@@ -4755,7 +4757,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;
@@ -4772,7 +4774,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 &&
@@ -4793,9 +4795,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;
@@ -4844,7 +4845,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;
@@ -4929,7 +4930,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);
@@ -5020,7 +5021,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;
@@ -5041,7 +5042,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;
@@ -5091,7 +5092,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++;
@@ -5117,13 +5118,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--;
@@ -5134,7 +5135,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;
@@ -5272,7 +5273,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);
}
@@ -5285,7 +5286,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);
}
@@ -5299,7 +5300,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
@@ -5313,7 +5314,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, ...)
@@ -5324,7 +5325,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, ...)
@@ -5335,7 +5336,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)
@@ -5472,7 +5473,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;
}
@@ -5521,7 +5522,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");
}
}
@@ -5538,7 +5539,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");
}
}
@@ -5563,7 +5564,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");
}
}
@@ -5575,7 +5576,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");
}
}
@@ -5655,13 +5656,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) {
@@ -5683,7 +5684,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 {
@@ -5701,9 +5702,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[] = {
@@ -5736,7 +5739,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];
@@ -5785,7 +5788,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;
}
@@ -5948,7 +5951,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;
}
@@ -6190,7 +6193,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 &&
@@ -6216,7 +6219,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) {
@@ -6236,12 +6240,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;
@@ -6256,7 +6260,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,
@@ -6296,7 +6300,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;
}
@@ -6319,8 +6323,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 {
@@ -6348,8 +6352,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: {
@@ -6373,7 +6377,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);
@@ -6387,7 +6391,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);
@@ -6396,7 +6400,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);
}
@@ -6407,13 +6411,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,
@@ -6706,7 +6712,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);
@@ -6780,7 +6786,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;
}
@@ -7722,7 +7728,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");
}
}
@@ -7773,7 +7779,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");
}
}
@@ -7956,7 +7962,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;
@@ -8011,8 +8017,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;
@@ -8062,7 +8068,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;
}
@@ -8074,7 +8080,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);
}
@@ -8109,9 +8115,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);
@@ -8122,7 +8128,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,
@@ -8187,7 +8193,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);
@@ -8312,14 +8318,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;
@@ -8340,7 +8346,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;
@@ -8377,7 +8383,7 @@ static void red_display_marshall_stream_clip(RedChannelClient *rcc,
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
StreamAgent *agent = item->stream_agent;
- ASSERT(agent->stream);
+ spice_assert(agent->stream);
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_CLIP, &item->base);
SpiceMsgDisplayStreamClip stream_clip;
@@ -8404,7 +8410,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);
}
@@ -8417,7 +8423,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;
@@ -8453,7 +8459,7 @@ static void red_marshall_cursor(RedChannelClient *rcc,
RedCursorCmd *cmd;
RedWorker *worker;
- ASSERT(cursor_channel);
+ spice_assert(cursor_channel);
worker = cursor_channel->common.worker;
@@ -8495,7 +8501,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);
}
}
@@ -8561,7 +8567,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:
@@ -8593,7 +8599,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);
@@ -8620,7 +8626,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:
@@ -8632,7 +8638,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);
@@ -8662,7 +8668,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;
}
@@ -8726,11 +8732,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
@@ -8746,9 +8752,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)
@@ -8858,8 +8864,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(
@@ -8870,7 +8878,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;
@@ -8931,9 +8939,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;
@@ -8956,7 +8964,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) {
@@ -8984,7 +8992,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)
@@ -9021,7 +9029,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++;
@@ -9063,7 +9071,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++;
@@ -9107,15 +9115,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;
}
@@ -9189,10 +9197,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);
@@ -9205,7 +9213,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);
@@ -9342,7 +9350,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));
@@ -9351,7 +9359,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);
@@ -9369,7 +9377,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);
@@ -9384,7 +9392,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;
@@ -9398,12 +9406,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;
@@ -9419,17 +9427,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;
@@ -9456,10 +9464,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);
@@ -9474,7 +9482,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;
@@ -9493,12 +9501,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;
}
@@ -9507,7 +9515,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;
@@ -9553,7 +9561,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;
}
@@ -9700,7 +9708,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));
@@ -9722,7 +9730,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");
}
}
@@ -9755,7 +9763,7 @@ static void display_channel_client_release_item_after_push(DisplayChannelClient
free(item);
break;
default:
- PANIC("invalid item type");
+ spice_critical("invalid item type");
}
}
@@ -9814,7 +9822,7 @@ static void display_channel_client_release_item_before_push(DisplayChannelClient
free(item);
break;
default:
- PANIC("invalid item type");
+ spice_critical("invalid item type");
}
}
@@ -9822,11 +9830,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);
}
}
@@ -9839,7 +9847,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,
@@ -9852,7 +9860,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;
@@ -9887,18 +9895,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;
@@ -9925,8 +9933,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;
@@ -9950,7 +9958,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);
@@ -9971,7 +9979,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
@@ -9984,7 +9992,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);
}
@@ -10008,7 +10016,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");
}
}
@@ -10022,7 +10030,7 @@ static void cursor_channel_client_release_item_after_push(CursorChannelClient *c
break;
}
default:
- PANIC("invalid item type");
+ spice_critical("invalid item type");
}
}
@@ -10030,12 +10038,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);
}
}
@@ -10045,7 +10053,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,
@@ -10068,11 +10076,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);
@@ -10104,7 +10112,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);
@@ -10113,12 +10121,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));
}
}
@@ -10127,7 +10135,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));
}
}
@@ -10141,7 +10149,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);
@@ -10150,10 +10158,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));
}
}
@@ -10168,7 +10176,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;
@@ -10187,7 +10195,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)) {
@@ -10236,7 +10244,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);
@@ -10272,7 +10280,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);
@@ -10328,7 +10336,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);
@@ -10381,10 +10389,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,
@@ -10410,9 +10418,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,
@@ -10446,19 +10454,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);
}
@@ -10518,8 +10526,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);
@@ -10533,7 +10541,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;
}
@@ -10558,16 +10566,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);
}
@@ -10575,14 +10582,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);
}
@@ -10644,7 +10650,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);
@@ -10657,8 +10663,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);
}
@@ -10668,8 +10674,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);
}
@@ -10693,7 +10699,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);
@@ -10706,8 +10712,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);
}
@@ -10717,8 +10723,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);
}
@@ -10730,25 +10736,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);
@@ -10769,19 +10775,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");
}
}
@@ -10791,7 +10797,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)
@@ -10819,7 +10825,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:
@@ -10835,7 +10841,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;
}
}
@@ -10848,7 +10854,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);
}
@@ -11039,7 +11045,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);
@@ -11051,7 +11057,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;
@@ -11093,7 +11099,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;
@@ -11111,13 +11117,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
@@ -11145,7 +11151,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));
}
}
@@ -11181,7 +11187,7 @@ void *red_worker_main(void *arg)
}
red_push(&worker);
}
- red_printf("exit");
+ spice_printerr("exit");
return 0;
}
@@ -11260,7 +11266,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) {
@@ -11282,7 +11288,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 cf493dd..27e7ea2 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 = spice_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));
goto error_dispose;
}
@@ -2506,7 +2506,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));
goto error_dispose;
}
@@ -2520,23 +2520,23 @@ static void reds_start_auth_sasl(RedLinkInfo *link)
NULL,
NULL);
if (err != SASL_OK || mechlist == NULL) {
- red_printf("cannot list SASL mechanisms %d (%s)",
+ spice_printerr("cannot list SASL mechanisms %d (%s)",
err, sasl_errdetail(sasl->conn));
goto error_dispose;
}
- red_printf("Available mechanisms for client: '%s'", mechlist);
+ spice_printerr("Available mechanisms for client: '%s'", mechlist);
sasl->mechlist = spice_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;
@@ -2557,7 +2557,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
@@ -2565,13 +2565,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);
@@ -2608,10 +2608,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);
@@ -2625,11 +2625,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;
@@ -2647,7 +2647,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);
@@ -2670,7 +2670,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;
}
@@ -2679,7 +2679,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;
}
@@ -2712,7 +2712,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) {
@@ -2735,18 +2735,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));
}
}
@@ -2796,13 +2796,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;
}
@@ -2830,7 +2830,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:
@@ -2846,7 +2846,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;
}
@@ -2862,7 +2862,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;
}
@@ -2876,9 +2876,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;
}
@@ -2898,7 +2898,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;
}
@@ -2925,7 +2925,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));
}
@@ -2951,7 +2951,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;
@@ -2959,7 +2959,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;
}
@@ -2977,7 +2977,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");
}
}
@@ -2991,7 +2991,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");
}
}
@@ -3001,7 +3001,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;
@@ -3013,18 +3013,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");
}
}
@@ -3092,7 +3092,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 */
@@ -3104,9 +3104,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);
@@ -3114,17 +3114,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)
@@ -3195,7 +3195,7 @@ enum {
static inline void on_activating_ticketing(void)
{
if (!ticketing_enabled && reds_main_channel_connected()) {
- red_printf("disconnecting");
+ spice_printerr("disconnecting");
reds_disconnect();
}
}
@@ -3247,8 +3247,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;
@@ -3257,10 +3257,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;
@@ -3277,7 +3277,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);
@@ -3286,8 +3286,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);
@@ -3383,10 +3383,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;
@@ -3410,7 +3410,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();
@@ -3431,23 +3431,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) {
@@ -3456,10 +3456,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;
}
@@ -3469,10 +3469,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) {
@@ -3484,19 +3484,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));
@@ -3504,7 +3504,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);
@@ -3512,33 +3512,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);
@@ -3553,21 +3553,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;
}
@@ -3640,10 +3640,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;
@@ -3657,11 +3657,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;
@@ -3672,26 +3672,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);
@@ -3705,7 +3705,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;
}
@@ -3717,7 +3717,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;
@@ -3730,7 +3730,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;
@@ -3740,7 +3740,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);
@@ -3750,7 +3750,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();
}
@@ -3776,7 +3776,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;
}
@@ -3786,7 +3786,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;
@@ -3798,14 +3798,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;
@@ -3813,7 +3813,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;
@@ -3824,7 +3824,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 = spice_strdup(appname);
@@ -3851,7 +3851,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) {
@@ -3884,7 +3884,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;
@@ -3920,22 +3920,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
@@ -3945,9 +3945,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
@@ -3973,7 +3973,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;
@@ -3990,7 +3990,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;
}
@@ -3999,7 +3999,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;
}
@@ -4008,7 +4008,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;
}
@@ -4024,7 +4024,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)
@@ -4036,14 +4036,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;
@@ -4051,7 +4051,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;
@@ -4090,12 +4090,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);
}
@@ -4114,7 +4114,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);
}
@@ -4126,9 +4126,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;
@@ -4138,8 +4138,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;
}
@@ -4148,7 +4148,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;
@@ -4165,14 +4165,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;
@@ -4191,8 +4191,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;
}
@@ -4276,7 +4276,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 d023331..894053e 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 be98094..7bdd399 100644
--- a/server/snd_worker.c
+++ b/server/snd_worker.c
@@ -208,7 +208,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;
@@ -295,7 +295,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;
}
@@ -326,7 +326,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;
@@ -366,7 +366,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;
@@ -388,7 +388,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;
}
@@ -402,7 +402,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;
@@ -411,7 +411,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;
@@ -431,14 +431,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;
@@ -448,7 +448,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;
}
@@ -472,7 +472,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;
}
@@ -629,7 +629,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);
@@ -670,7 +670,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);
@@ -783,7 +783,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;
}
@@ -829,12 +829,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;
}
}
@@ -913,7 +913,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;
}
@@ -922,7 +922,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
@@ -930,23 +930,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);
@@ -960,7 +960,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;
}
@@ -989,13 +989,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)
@@ -1046,7 +1046,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) {
@@ -1065,7 +1065,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) {
@@ -1076,7 +1076,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;
@@ -1095,7 +1095,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;
@@ -1116,7 +1116,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);
@@ -1134,7 +1134,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) {
@@ -1175,12 +1175,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;
}
@@ -1228,12 +1228,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);
}
@@ -1279,7 +1279,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
@@ -1299,7 +1299,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);
@@ -1320,7 +1320,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;
@@ -1350,7 +1350,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) {
@@ -1384,12 +1384,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;
}
@@ -1431,12 +1431,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);
}
@@ -1458,7 +1458,7 @@ static void remove_worker(SndWorker *worker)
}
now = &(*now)->next;
}
- red_printf("not found");
+ spice_printerr("not found");
}
void snd_attach_playback(SpicePlaybackInstance *sin)
@@ -1561,7 +1561,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 18ae627..27123d4 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;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-03 00:10:55 +0000