Rename RedCharDevice functions

make the function names match the type names. So
spice_char_device_state_* becomes red_char_device_* and
spice_char_device_* also becomes red_char_device_*.

Acked-by: Frediano Ziglio <fziglio@redhat.com>

5 files changed, 324 insertions, 324 deletions

diff --git a/server/char-device.c b/server/char-device.c
index d5f203f9..2957a1b8 100644
--- a/server/char-device.c
+++ b/server/char-device.c
@@ -27,7 +27,7 @@
 #include "reds.h"
 
 #define CHAR_DEVICE_WRITE_TO_TIMEOUT 100
-#define SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT 30000
+#define RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT 30000
 #define MAX_POOL_SIZE (10 * 64 * 1024)
 
 typedef struct RedCharDeviceClient RedCharDeviceClient;
@@ -88,8 +88,8 @@ enum {
 
 /* Holding references for avoiding access violation if the char device was
  * destroyed during a callback */
-static void spice_char_device_state_ref(RedCharDevice *char_dev);
-static void spice_char_device_state_unref(RedCharDevice *char_dev);
+static void red_char_device_ref(RedCharDevice *char_dev);
+static void red_char_device_unref(RedCharDevice *char_dev);
 static void red_char_device_write_buffer_unref(RedCharDeviceWriteBuffer *write_buf);
 
 static void spice_char_dev_write_retry(void *opaque);
@@ -100,43 +100,43 @@ typedef struct RedCharDeviceMsgToClientItem {
 } RedCharDeviceMsgToClientItem;
 
 static RedCharDeviceMsgToClient *
-spice_char_device_read_one_msg_from_device(RedCharDevice *dev)
+red_char_device_read_one_msg_from_device(RedCharDevice *dev)
 {
    return dev->priv->cbs.read_one_msg_from_device(dev->priv->sin, dev->priv->opaque);
 }
 
 static RedCharDeviceMsgToClient *
-spice_char_device_ref_msg_to_client(RedCharDevice *dev,
-                                    RedCharDeviceMsgToClient *msg)
+red_char_device_ref_msg_to_client(RedCharDevice *dev,
+                                  RedCharDeviceMsgToClient *msg)
 {
    return dev->priv->cbs.ref_msg_to_client(msg, dev->priv->opaque);
 }
 
 static void
-spice_char_device_unref_msg_to_client(RedCharDevice *dev,
-                                      RedCharDeviceMsgToClient *msg)
+red_char_device_unref_msg_to_client(RedCharDevice *dev,
+                                    RedCharDeviceMsgToClient *msg)
 {
    dev->priv->cbs.unref_msg_to_client(msg, dev->priv->opaque);
 }
 
 static void
-spice_char_device_send_msg_to_client(RedCharDevice *dev,
-                                     RedCharDeviceMsgToClient *msg,
-                                     RedClient *client)
+red_char_device_send_msg_to_client(RedCharDevice *dev,
+                                   RedCharDeviceMsgToClient *msg,
+                                   RedClient *client)
 {
    dev->priv->cbs.send_msg_to_client(msg, client, dev->priv->opaque);
 }
 
 static void
-spice_char_device_send_tokens_to_client(RedCharDevice *dev,
-                                        RedClient *client,
-                                        uint32_t tokens)
+red_char_device_send_tokens_to_client(RedCharDevice *dev,
+                                      RedClient *client,
+                                      uint32_t tokens)
 {
    dev->priv->cbs.send_tokens_to_client(client, tokens, dev->priv->opaque);
 }
 
 static void
-spice_char_device_on_free_self_token(RedCharDevice *dev)
+red_char_device_on_free_self_token(RedCharDevice *dev)
 {
    if (dev->priv->cbs.on_free_self_token != NULL) {
        dev->priv->cbs.on_free_self_token(dev->priv->opaque);
@@ -144,7 +144,7 @@ spice_char_device_on_free_self_token(RedCharDevice *dev)
 }
 
 static void
-spice_char_device_remove_client(RedCharDevice *dev, RedClient *client)
+red_char_device_remove_client(RedCharDevice *dev, RedClient *client)
 {
    dev->priv->cbs.remove_client(client, dev->priv->opaque);
 }
@@ -170,8 +170,8 @@ static void write_buffers_queue_free(Ring *write_queue)
     }
 }
 
-static void spice_char_device_write_buffer_pool_add(RedCharDevice *dev,
-                                                    RedCharDeviceWriteBuffer *buf)
+static void red_char_device_write_buffer_pool_add(RedCharDevice *dev,
+                                                  RedCharDeviceWriteBuffer *buf)
 {
     if (buf->refs == 1 &&
         dev->priv->cur_pool_size < MAX_POOL_SIZE) {
@@ -187,8 +187,8 @@ static void spice_char_device_write_buffer_pool_add(RedCharDevice *dev,
     red_char_device_write_buffer_unref(buf);
 }
 
-static void spice_char_device_client_send_queue_free(RedCharDevice *dev,
-                                                     RedCharDeviceClient *dev_client)
+static void red_char_device_client_send_queue_free(RedCharDevice *dev,
+                                                   RedCharDeviceClient *dev_client)
 {
     spice_debug("send_queue_empty %d", ring_is_empty(&dev_client->send_queue));
     while (!ring_is_empty(&dev_client->send_queue)) {
@@ -198,15 +198,15 @@ static void spice_char_device_client_send_queue_free(RedCharDevice *dev,
                                                                    link);
 
         ring_remove(item);
-        spice_char_device_unref_msg_to_client(dev, msg_item->msg);
+        red_char_device_unref_msg_to_client(dev, msg_item->msg);
         free(msg_item);
     }
     dev_client->num_send_tokens += dev_client->send_queue_size;
     dev_client->send_queue_size = 0;
 }
 
-static void spice_char_device_client_free(RedCharDevice *dev,
-                                          RedCharDeviceClient *dev_client)
+static void red_char_device_client_free(RedCharDevice *dev,
+                                        RedCharDeviceClient *dev_client)
 {
     RingItem *item, *next;
 
@@ -215,7 +215,7 @@ static void spice_char_device_client_free(RedCharDevice *dev,
         dev_client->wait_for_tokens_timer = NULL;
     }
 
-    spice_char_device_client_send_queue_free(dev, dev_client);
+    red_char_device_client_send_queue_free(dev, dev_client);
 
     /* remove write buffers that are associated with the client */
     spice_debug("write_queue_is_empty %d", ring_is_empty(&dev->priv->write_queue) && !dev->priv->cur_write_buf);
@@ -226,7 +226,7 @@ static void spice_char_device_client_free(RedCharDevice *dev,
         if (write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT &&
             write_buf->client == dev_client->client) {
             ring_remove(item);
-            spice_char_device_write_buffer_pool_add(dev, write_buf);
+            red_char_device_write_buffer_pool_add(dev, write_buf);
         }
     }
 
@@ -241,15 +241,15 @@ static void spice_char_device_client_free(RedCharDevice *dev,
     free(dev_client);
 }
 
-static void spice_char_device_handle_client_overflow(RedCharDeviceClient *dev_client)
+static void red_char_device_handle_client_overflow(RedCharDeviceClient *dev_client)
 {
     RedCharDevice *dev = dev_client->dev;
     spice_printerr("dev %p client %p ", dev, dev_client);
-    spice_char_device_remove_client(dev, dev_client->client);
+    red_char_device_remove_client(dev, dev_client->client);
 }
 
-static RedCharDeviceClient *spice_char_device_client_find(RedCharDevice *dev,
-                                                          RedClient *client)
+static RedCharDeviceClient *red_char_device_client_find(RedCharDevice *dev,
+                                                        RedClient *client)
 {
     RingItem *item;
 
@@ -272,15 +272,15 @@ static void device_client_wait_for_tokens_timeout(void *opaque)
 {
     RedCharDeviceClient *dev_client = opaque;
 
-    spice_char_device_handle_client_overflow(dev_client);
+    red_char_device_handle_client_overflow(dev_client);
 }
 
-static int spice_char_device_can_send_to_client(RedCharDeviceClient *dev_client)
+static int red_char_device_can_send_to_client(RedCharDeviceClient *dev_client)
 {
     return !dev_client->do_flow_control || dev_client->num_send_tokens;
 }
 
-static uint64_t spice_char_device_max_send_tokens(RedCharDevice *dev)
+static uint64_t red_char_device_max_send_tokens(RedCharDevice *dev)
 {
     RingItem *item;
     uint64_t max = 0;
@@ -302,30 +302,30 @@ static uint64_t spice_char_device_max_send_tokens(RedCharDevice *dev)
     return max;
 }
 
-static void spice_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_client,
-                                                      RedCharDeviceMsgToClient *msg)
+static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_client,
+                                                    RedCharDeviceMsgToClient *msg)
 {
     RedCharDevice *dev = dev_client->dev;
     RedCharDeviceMsgToClientItem *msg_item;
 
     if (dev_client->send_queue_size >= dev_client->max_send_queue_size) {
-        spice_char_device_handle_client_overflow(dev_client);
+        red_char_device_handle_client_overflow(dev_client);
         return;
     }
 
     msg_item = spice_new0(RedCharDeviceMsgToClientItem, 1);
-    msg_item->msg = spice_char_device_ref_msg_to_client(dev, msg);
+    msg_item->msg = red_char_device_ref_msg_to_client(dev, msg);
     ring_add(&dev_client->send_queue, &msg_item->link);
     dev_client->send_queue_size++;
     if (!dev_client->wait_for_tokens_started) {
         reds_core_timer_start(dev->priv->reds, dev_client->wait_for_tokens_timer,
-                              SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
+                              RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
         dev_client->wait_for_tokens_started = TRUE;
     }
 }
 
-static void spice_char_device_send_msg_to_clients(RedCharDevice *dev,
-                                                  RedCharDeviceMsgToClient *msg)
+static void red_char_device_send_msg_to_clients(RedCharDevice *dev,
+                                                RedCharDeviceMsgToClient *msg)
 {
     RingItem *item, *next;
 
@@ -333,19 +333,19 @@ static void spice_char_device_send_msg_to_clients(RedCharDevice *dev,
         RedCharDeviceClient *dev_client;
 
         dev_client = SPICE_CONTAINEROF(item, RedCharDeviceClient, link);
-        if (spice_char_device_can_send_to_client(dev_client)) {
+        if (red_char_device_can_send_to_client(dev_client)) {
             dev_client->num_send_tokens--;
             spice_assert(ring_is_empty(&dev_client->send_queue));
-            spice_char_device_send_msg_to_client(dev, msg, dev_client->client);
+            red_char_device_send_msg_to_client(dev, msg, dev_client->client);
 
             /* don't refer to dev_client anymore, it may have been released */
         } else {
-            spice_char_device_add_msg_to_client_queue(dev_client, msg);
+            red_char_device_add_msg_to_client_queue(dev_client, msg);
         }
     }
 }
 
-static int spice_char_device_read_from_device(RedCharDevice *dev)
+static int red_char_device_read_from_device(RedCharDevice *dev)
 {
     uint64_t max_send_tokens;
     int did_read = FALSE;
@@ -364,8 +364,8 @@ static int spice_char_device_read_from_device(RedCharDevice *dev)
         return FALSE;
     }
 
-    max_send_tokens = spice_char_device_max_send_tokens(dev);
-    spice_char_device_state_ref(dev);
+    max_send_tokens = red_char_device_max_send_tokens(dev);
+    red_char_device_ref(dev);
     /*
      * Reading from the device only in case at least one of the clients have a free token.
      * All messages will be discarded if no client is attached to the device
@@ -373,7 +373,7 @@ static int spice_char_device_read_from_device(RedCharDevice *dev)
     while ((max_send_tokens || ring_is_empty(&dev->priv->clients)) && dev->priv->running) {
         RedCharDeviceMsgToClient *msg;
 
-        msg = spice_char_device_read_one_msg_from_device(dev);
+        msg = red_char_device_read_one_msg_from_device(dev);
         if (!msg) {
             if (dev->priv->during_read_from_device > 1) {
                 dev->priv->during_read_from_device = 1;
@@ -383,82 +383,82 @@ static int spice_char_device_read_from_device(RedCharDevice *dev)
             break;
         }
         did_read = TRUE;
-        spice_char_device_send_msg_to_clients(dev, msg);
-        spice_char_device_unref_msg_to_client(dev, msg);
+        red_char_device_send_msg_to_clients(dev, msg);
+        red_char_device_unref_msg_to_client(dev, msg);
         max_send_tokens--;
     }
     dev->priv->during_read_from_device = 0;
     if (dev->priv->running) {
         dev->priv->active = dev->priv->active || did_read;
     }
-    spice_char_device_state_unref(dev);
+    red_char_device_unref(dev);
     return did_read;
 }
 
-static void spice_char_device_client_send_queue_push(RedCharDeviceClient *dev_client)
+static void red_char_device_client_send_queue_push(RedCharDeviceClient *dev_client)
 {
     RingItem *item;
     while ((item = ring_get_tail(&dev_client->send_queue)) &&
-           spice_char_device_can_send_to_client(dev_client)) {
+           red_char_device_can_send_to_client(dev_client)) {
         RedCharDeviceMsgToClientItem *msg_item;
 
         msg_item = SPICE_CONTAINEROF(item, RedCharDeviceMsgToClientItem, link);
         ring_remove(item);
 
         dev_client->num_send_tokens--;
-        spice_char_device_send_msg_to_client(dev_client->dev,
-                                             msg_item->msg,
-                                             dev_client->client);
-        spice_char_device_unref_msg_to_client(dev_client->dev, msg_item->msg);
+        red_char_device_send_msg_to_client(dev_client->dev,
+                                           msg_item->msg,
+                                           dev_client->client);
+        red_char_device_unref_msg_to_client(dev_client->dev, msg_item->msg);
         dev_client->send_queue_size--;
         free(msg_item);
     }
 }
 
-static void spice_char_device_send_to_client_tokens_absorb(RedCharDeviceClient *dev_client,
-                                                           uint32_t tokens)
+static void red_char_device_send_to_client_tokens_absorb(RedCharDeviceClient *dev_client,
+                                                         uint32_t tokens)
 {
     RedCharDevice *dev = dev_client->dev;
     dev_client->num_send_tokens += tokens;
 
     if (dev_client->send_queue_size) {
         spice_assert(dev_client->num_send_tokens == tokens);
-        spice_char_device_client_send_queue_push(dev_client);
+        red_char_device_client_send_queue_push(dev_client);
     }
 
-    if (spice_char_device_can_send_to_client(dev_client)) {
+    if (red_char_device_can_send_to_client(dev_client)) {
         reds_core_timer_cancel(dev->priv->reds, dev_client->wait_for_tokens_timer);
         dev_client->wait_for_tokens_started = FALSE;
-        spice_char_device_read_from_device(dev_client->dev);
+        red_char_device_read_from_device(dev_client->dev);
     } else if (dev_client->send_queue_size) {
         reds_core_timer_start(dev->priv->reds, dev_client->wait_for_tokens_timer,
-                              SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
+                              RED_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
         dev_client->wait_for_tokens_started = TRUE;
     }
 }
 
-void spice_char_device_send_to_client_tokens_add(RedCharDevice *dev,
-                                                 RedClient *client,
-                                                 uint32_t tokens)
+void red_char_device_send_to_client_tokens_add(RedCharDevice *dev,
+                                               RedClient *client,
+                                               uint32_t tokens)
 {
     RedCharDeviceClient *dev_client;
 
-    dev_client = spice_char_device_client_find(dev, client);
+    dev_client = red_char_device_client_find(dev, client);
 
     if (!dev_client) {
         spice_error("client wasn't found dev %p client %p", dev, client);
         return;
     }
-    spice_char_device_send_to_client_tokens_absorb(dev_client, tokens);
+    red_char_device_send_to_client_tokens_absorb(dev_client, tokens);
 }
 
-void spice_char_device_send_to_client_tokens_set(RedCharDevice *dev,
-                                                 RedClient *client,
-                                                 uint32_t tokens)
+void red_char_device_send_to_client_tokens_set(RedCharDevice *dev,
+                                               RedClient *client,
+                                               uint32_t tokens)
 {
     RedCharDeviceClient *dev_client;
 
-    dev_client = spice_char_device_client_find(dev, client);
+    dev_client = red_char_device_client_find(dev, client);
 
     if (!dev_client) {
         spice_error("client wasn't found dev %p client %p", dev, client);
@@ -466,16 +466,16 @@ void spice_char_device_send_to_client_tokens_set(RedCharDevice *dev,
     }
 
     dev_client->num_send_tokens = 0;
-    spice_char_device_send_to_client_tokens_absorb(dev_client, tokens);
+    red_char_device_send_to_client_tokens_absorb(dev_client, tokens);
 }
 
 /**************************
  * Writing to the device  *
 ***************************/
 
-static void spice_char_device_client_tokens_add(RedCharDevice *dev,
-                                                RedCharDeviceClient *dev_client,
-                                                uint32_t num_tokens)
+static void red_char_device_client_tokens_add(RedCharDevice *dev,
+                                              RedCharDeviceClient *dev_client,
+                                              uint32_t num_tokens)
 {
     if (!dev_client->do_flow_control) {
         return;
@@ -489,11 +489,11 @@ static void spice_char_device_client_tokens_add(RedCharDevice *dev,
 
         dev_client->num_client_tokens += dev_client->num_client_tokens_free;
         dev_client->num_client_tokens_free = 0;
-        spice_char_device_send_tokens_to_client(dev, dev_client->client, tokens);
+        red_char_device_send_tokens_to_client(dev, dev_client->client, tokens);
     }
 }
 
-static int spice_char_device_write_to_device(RedCharDevice *dev)
+static int red_char_device_write_to_device(RedCharDevice *dev)
 {
     SpiceCharDeviceInterface *sif;
     int total = 0;
@@ -503,12 +503,12 @@ static int spice_char_device_write_to_device(RedCharDevice *dev)
         return 0;
     }
 
-    /* protect against recursion with spice_char_device_wakeup */
+    /* protect against recursion with red_char_device_wakeup */
     if (dev->priv->during_write_to_device++ > 0) {
         return 0;
     }
 
-    spice_char_device_state_ref(dev);
+    red_char_device_ref(dev);
 
     if (dev->priv->write_to_dev_timer) {
         reds_core_timer_cancel(dev->priv->reds, dev->priv->write_to_dev_timer);
@@ -544,7 +544,7 @@ static int spice_char_device_write_to_device(RedCharDevice *dev)
         if (!write_len) {
             RedCharDeviceWriteBuffer *release_buf = dev->priv->cur_write_buf;
             dev->priv->cur_write_buf = NULL;
-            spice_char_device_write_buffer_release(dev, release_buf);
+            red_char_device_write_buffer_release(dev, release_buf);
             continue;
         }
         dev->priv->cur_write_buf_pos += n;
@@ -562,7 +562,7 @@ static int spice_char_device_write_to_device(RedCharDevice *dev)
         dev->priv->active = dev->priv->active || total;
     }
     dev->priv->during_write_to_device = 0;
-    spice_char_device_state_unref(dev);
+    red_char_device_unref(dev);
     return total;
 }
 
@@ -573,10 +573,10 @@ static void spice_char_dev_write_retry(void *opaque)
     if (dev->priv->write_to_dev_timer) {
         reds_core_timer_cancel(dev->priv->reds, dev->priv->write_to_dev_timer);
     }
-    spice_char_device_write_to_device(dev);
+    red_char_device_write_to_device(dev);
 }
 
-static RedCharDeviceWriteBuffer *__spice_char_device_write_buffer_get(
+static RedCharDeviceWriteBuffer *__red_char_device_write_buffer_get(
     RedCharDevice *dev, RedClient *client,
     int size, int origin, int migrated_data_tokens)
 {
@@ -605,12 +605,12 @@ static RedCharDeviceWriteBuffer *__spice_char_device_write_buffer_get(
 
     if (origin == WRITE_BUFFER_ORIGIN_CLIENT) {
        spice_assert(client);
-       RedCharDeviceClient *dev_client = spice_char_device_client_find(dev, client);
+       RedCharDeviceClient *dev_client = red_char_device_client_find(dev, client);
        if (dev_client) {
             if (!migrated_data_tokens &&
                 dev_client->do_flow_control && !dev_client->num_client_tokens) {
                 spice_printerr("token violation: dev %p client %p", dev, client);
-                spice_char_device_handle_client_overflow(dev_client);
+                red_char_device_handle_client_overflow(dev_client);
                 goto error;
             }
             ret->client = client;
@@ -636,19 +636,19 @@ error:
     return NULL;
 }
 
-RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get(RedCharDevice *dev,
-                                                             RedClient *client,
-                                                             int size)
+RedCharDeviceWriteBuffer *red_char_device_write_buffer_get(RedCharDevice *dev,
+                                                           RedClient *client,
+                                                           int size)
 {
-   return  __spice_char_device_write_buffer_get(dev, client, size,
+   return  __red_char_device_write_buffer_get(dev, client, size,
              client ? WRITE_BUFFER_ORIGIN_CLIENT : WRITE_BUFFER_ORIGIN_SERVER,
              0);
 }
 
-RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get_server_no_token(
+RedCharDeviceWriteBuffer *red_char_device_write_buffer_get_server_no_token(
     RedCharDevice *dev, int size)
 {
-   return  __spice_char_device_write_buffer_get(dev, NULL, size,
+   return  __red_char_device_write_buffer_get(dev, NULL, size,
              WRITE_BUFFER_ORIGIN_SERVER_NO_TOKEN, 0);
 }
 
@@ -669,24 +669,24 @@ static void red_char_device_write_buffer_unref(RedCharDeviceWriteBuffer *write_b
         red_char_device_write_buffer_free(write_buf);
 }
 
-void spice_char_device_write_buffer_add(RedCharDevice *dev,
-                                        RedCharDeviceWriteBuffer *write_buf)
+void red_char_device_write_buffer_add(RedCharDevice *dev,
+                                      RedCharDeviceWriteBuffer *write_buf)
 {
     spice_assert(dev);
     /* caller shouldn't add buffers for client that was removed */
     if (write_buf->origin == WRITE_BUFFER_ORIGIN_CLIENT &&
-        !spice_char_device_client_find(dev, write_buf->client)) {
+        !red_char_device_client_find(dev, write_buf->client)) {
         spice_printerr("client not found: dev %p client %p", dev, write_buf->client);
-        spice_char_device_write_buffer_pool_add(dev, write_buf);
+        red_char_device_write_buffer_pool_add(dev, write_buf);
         return;
     }
 
     ring_add(&dev->priv->write_queue, &write_buf->link);
-    spice_char_device_write_to_device(dev);
+    red_char_device_write_to_device(dev);
 }
 
-void spice_char_device_write_buffer_release(RedCharDevice *dev,
-                                            RedCharDeviceWriteBuffer *write_buf)
+void red_char_device_write_buffer_release(RedCharDevice *dev,
+                                          RedCharDeviceWriteBuffer *write_buf)
 {
     int buf_origin = write_buf->origin;
     uint32_t buf_token_price = write_buf->token_price;
@@ -701,18 +701,18 @@ void spice_char_device_write_buffer_release(RedCharDevice *dev,
 
     spice_assert(dev->priv->cur_write_buf != write_buf);
 
-    spice_char_device_write_buffer_pool_add(dev, write_buf);
+    red_char_device_write_buffer_pool_add(dev, write_buf);
     if (buf_origin == WRITE_BUFFER_ORIGIN_CLIENT) {
         RedCharDeviceClient *dev_client;
 
         spice_assert(client);
-        dev_client = spice_char_device_client_find(dev, client);
+        dev_client = red_char_device_client_find(dev, client);
         /* when a client is removed, we remove all the buffers that are associated with it */
         spice_assert(dev_client);
-        spice_char_device_client_tokens_add(dev, dev_client, buf_token_price);
+        red_char_device_client_tokens_add(dev, dev_client, buf_token_price);
     } else if (buf_origin == WRITE_BUFFER_ORIGIN_SERVER) {
         dev->priv->num_self_tokens++;
-        spice_char_device_on_free_self_token(dev);
+        red_char_device_on_free_self_token(dev);
     }
 }
 
@@ -720,12 +720,12 @@ void spice_char_device_write_buffer_release(RedCharDevice *dev,
  * char_device_state management *
  ********************************/
 
-RedCharDevice *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
-                                              RedsState *reds,
-                                              uint32_t client_tokens_interval,
-                                              uint32_t self_tokens,
-                                              SpiceCharDeviceCallbacks *cbs,
-                                              void *opaque)
+RedCharDevice *red_char_device_create(SpiceCharDeviceInstance *sin,
+                                      RedsState *reds,
+                                      uint32_t client_tokens_interval,
+                                      uint32_t self_tokens,
+                                      SpiceCharDeviceCallbacks *cbs,
+                                      void *opaque)
 {
     RedCharDevice *char_dev;
     SpiceCharDeviceInterface *sif;
@@ -762,39 +762,39 @@ RedCharDevice *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
     return char_dev;
 }
 
-void spice_char_device_state_reset_dev_instance(RedCharDevice *state,
-                                                SpiceCharDeviceInstance *sin)
+void red_char_device_reset_dev_instance(RedCharDevice *state,
+                                        SpiceCharDeviceInstance *sin)
 {
     spice_debug("sin %p dev_state %p", sin, state);
     state->priv->sin = sin;
     sin->st = state;
 }
 
-void *spice_char_device_state_opaque_get(RedCharDevice *dev)
+void *red_char_device_opaque_get(RedCharDevice *dev)
 {
     return dev->priv->opaque;
 }
 
-static void spice_char_device_state_ref(RedCharDevice *char_dev)
+static void red_char_device_ref(RedCharDevice *char_dev)
 {
     char_dev->priv->refs++;
 }
 
-static void spice_char_device_state_unref(RedCharDevice *char_dev)
+static void red_char_device_unref(RedCharDevice *char_dev)
 {
     /* The refs field protects the char_dev from being deallocated in
-     * case spice_char_device_state_destroy has been called
+     * case red_char_device_destroy has been called
      * during a callabck, and we might still access the char_dev afterwards.
-     * spice_char_device_state_unref is always coupled with a preceding
-     * spice_char_device_state_ref. Here, refs can turn 0
-     * only when spice_char_device_state_destroy is called in between
-     * the calls to spice_char_device_state_ref and spice_char_device_state_unref.*/
+     * red_char_device_unref is always coupled with a preceding
+     * red_char_device_ref. Here, refs can turn 0
+     * only when red_char_device_destroy is called in between
+     * the calls to red_char_device_ref and red_char_device_unref.*/
     if (!--char_dev->priv->refs) {
         free(char_dev);
     }
 }
 
-void spice_char_device_state_destroy(RedCharDevice *char_dev)
+void red_char_device_destroy(RedCharDevice *char_dev)
 {
     reds_on_char_device_state_destroy(char_dev->priv->reds, char_dev);
     if (char_dev->priv->write_to_dev_timer) {
@@ -812,11 +812,11 @@ void spice_char_device_state_destroy(RedCharDevice *char_dev)
         RedCharDeviceClient *dev_client;
 
         dev_client = SPICE_CONTAINEROF(item, RedCharDeviceClient, link);
-        spice_char_device_client_free(char_dev, dev_client);
+        red_char_device_client_free(char_dev, dev_client);
     }
     char_dev->priv->running = FALSE;
 
-    spice_char_device_state_unref(char_dev);
+    red_char_device_unref(char_dev);
 }
 
 static RedCharDeviceClient *red_char_device_client_new(RedClient *client,
@@ -850,13 +850,13 @@ static RedCharDeviceClient *red_char_device_client_new(RedClient *client,
     return dev_client;
 }
 
-int spice_char_device_client_add(RedCharDevice *dev,
-                                 RedClient *client,
-                                 int do_flow_control,
-                                 uint32_t max_send_queue_size,
-                                 uint32_t num_client_tokens,
-                                 uint32_t num_send_tokens,
-                                 int wait_for_migrate_data)
+int red_char_device_client_add(RedCharDevice *dev,
+                               RedClient *client,
+                               int do_flow_control,
+                               uint32_t max_send_queue_size,
+                               uint32_t num_client_tokens,
+                               uint32_t num_send_tokens,
+                               int wait_for_migrate_data)
 {
     RedCharDeviceClient *dev_client;
 
@@ -880,27 +880,27 @@ int spice_char_device_client_add(RedCharDevice *dev,
     ring_add(&dev->priv->clients, &dev_client->link);
     dev->priv->num_clients++;
     /* Now that we have a client, forward any pending device data */
-    spice_char_device_wakeup(dev);
+    red_char_device_wakeup(dev);
     return TRUE;
 }
 
-void spice_char_device_client_remove(RedCharDevice *dev,
-                                     RedClient *client)
+void red_char_device_client_remove(RedCharDevice *dev,
+                                   RedClient *client)
 {
     RedCharDeviceClient *dev_client;
 
     spice_debug("dev_state %p client %p", dev, client);
-    dev_client = spice_char_device_client_find(dev, client);
+    dev_client = red_char_device_client_find(dev, client);
 
     if (!dev_client) {
         spice_error("client wasn't found");
         return;
     }
-    spice_char_device_client_free(dev, dev_client);
+    red_char_device_client_free(dev, dev_client);
     if (dev->priv->wait_for_migrate_data) {
         spice_assert(dev->priv->num_clients == 0);
         dev->priv->wait_for_migrate_data  = FALSE;
-        spice_char_device_read_from_device(dev);
+        red_char_device_read_from_device(dev);
     }
 
     if (dev->priv->num_clients == 0) {
@@ -910,23 +910,23 @@ void spice_char_device_client_remove(RedCharDevice *dev,
     }
 }
 
-int spice_char_device_client_exists(RedCharDevice *dev,
-                                    RedClient *client)
+int red_char_device_client_exists(RedCharDevice *dev,
+                                  RedClient *client)
 {
-    return (spice_char_device_client_find(dev, client) != NULL);
+    return (red_char_device_client_find(dev, client) != NULL);
 }
 
-void spice_char_device_start(RedCharDevice *dev)
+void red_char_device_start(RedCharDevice *dev)
 {
     spice_debug("dev_state %p", dev);
     dev->priv->running = TRUE;
-    spice_char_device_state_ref(dev);
-    while (spice_char_device_write_to_device(dev) ||
-           spice_char_device_read_from_device(dev));
-    spice_char_device_state_unref(dev);
+    red_char_device_ref(dev);
+    while (red_char_device_write_to_device(dev) ||
+           red_char_device_read_from_device(dev));
+    red_char_device_unref(dev);
 }
 
-void spice_char_device_stop(RedCharDevice *dev)
+void red_char_device_stop(RedCharDevice *dev)
 {
     spice_debug("dev_state %p", dev);
     dev->priv->running = FALSE;
@@ -936,11 +936,11 @@ void spice_char_device_stop(RedCharDevice *dev)
     }
 }
 
-void spice_char_device_reset(RedCharDevice *dev)
+void red_char_device_reset(RedCharDevice *dev)
 {
     RingItem *client_item;
 
-    spice_char_device_stop(dev);
+    red_char_device_stop(dev);
     dev->priv->wait_for_migrate_data = FALSE;
     spice_debug("dev_state %p", dev);
     while (!ring_is_empty(&dev->priv->write_queue)) {
@@ -950,35 +950,35 @@ void spice_char_device_reset(RedCharDevice *dev)
         ring_remove(item);
         buf = SPICE_CONTAINEROF(item, RedCharDeviceWriteBuffer, link);
         /* tracking the tokens */
-        spice_char_device_write_buffer_release(dev, buf);
+        red_char_device_write_buffer_release(dev, buf);
     }
     if (dev->priv->cur_write_buf) {
         RedCharDeviceWriteBuffer *release_buf = dev->priv->cur_write_buf;
 
         dev->priv->cur_write_buf = NULL;
-        spice_char_device_write_buffer_release(dev, release_buf);
+        red_char_device_write_buffer_release(dev, release_buf);
     }
 
     RING_FOREACH(client_item, &dev->priv->clients) {
         RedCharDeviceClient *dev_client;
 
         dev_client = SPICE_CONTAINEROF(client_item, RedCharDeviceClient, link);
-        spice_char_device_client_send_queue_free(dev, dev_client);
+        red_char_device_client_send_queue_free(dev, dev_client);
     }
     dev->priv->sin = NULL;
 }
 
-void spice_char_device_wakeup(RedCharDevice *dev)
+void red_char_device_wakeup(RedCharDevice *dev)
 {
-    spice_char_device_write_to_device(dev);
-    spice_char_device_read_from_device(dev);
+    red_char_device_write_to_device(dev);
+    red_char_device_read_from_device(dev);
 }
 
 /*************
  * Migration *
  * **********/
 
-void spice_char_device_state_migrate_data_marshall_empty(SpiceMarshaller *m)
+void red_char_device_migrate_data_marshall_empty(SpiceMarshaller *m)
 {
     SpiceMigrateDataCharDevice *mig_data;
 
@@ -997,8 +997,8 @@ static void migrate_data_marshaller_write_buffer_free(uint8_t *data, void *opaqu
     red_char_device_write_buffer_unref(write_buf);
 }
 
-void spice_char_device_state_migrate_data_marshall(RedCharDevice *dev,
-                                                   SpiceMarshaller *m)
+void red_char_device_migrate_data_marshall(RedCharDevice *dev,
+                                           SpiceMarshaller *m)
 {
     RedCharDeviceClient *dev_client;
     RingItem *item;
@@ -1057,8 +1057,8 @@ void spice_char_device_state_migrate_data_marshall(RedCharDevice *dev,
                 dev, *write_to_dev_size_ptr, *write_to_dev_tokens_ptr);
 }
 
-int spice_char_device_state_restore(RedCharDevice *dev,
-                                    SpiceMigrateDataCharDevice *mig_data)
+int red_char_device_restore(RedCharDevice *dev,
+                            SpiceMigrateDataCharDevice *mig_data)
 {
     RedCharDeviceClient *dev_client;
     uint32_t client_tokens_window;
@@ -1087,12 +1087,12 @@ int spice_char_device_state_restore(RedCharDevice *dev,
     if (mig_data->write_size > 0) {
         if (mig_data->write_num_client_tokens) {
             dev->priv->cur_write_buf =
-                __spice_char_device_write_buffer_get(dev, dev_client->client,
+                __red_char_device_write_buffer_get(dev, dev_client->client,
                     mig_data->write_size, WRITE_BUFFER_ORIGIN_CLIENT,
                     mig_data->write_num_client_tokens);
         } else {
             dev->priv->cur_write_buf =
-                __spice_char_device_write_buffer_get(dev, NULL,
+                __red_char_device_write_buffer_get(dev, NULL,
                     mig_data->write_size, WRITE_BUFFER_ORIGIN_SERVER, 0);
         }
         /* the first write buffer contains all the data that was saved for migration */
@@ -1103,12 +1103,12 @@ int spice_char_device_state_restore(RedCharDevice *dev,
         dev->priv->cur_write_buf_pos = dev->priv->cur_write_buf->buf;
     }
     dev->priv->wait_for_migrate_data = FALSE;
-    spice_char_device_write_to_device(dev);
-    spice_char_device_read_from_device(dev);
+    red_char_device_write_to_device(dev);
+    red_char_device_read_from_device(dev);
     return TRUE;
 }
 
-SpiceServer* spice_char_device_get_server(RedCharDevice *dev)
+SpiceServer* red_char_device_get_server(RedCharDevice *dev)
 {
     return dev->priv->reds;
 }
diff --git a/server/char-device.h b/server/char-device.h
index 86bf1b99..f3ae6cb9 100644
--- a/server/char-device.h
+++ b/server/char-device.h
@@ -27,19 +27,19 @@
  *
  * How to use the api:
  * ==================
- * device attached: call spice_char_device_state_create
- * device detached: call spice_char_device_state_destroy/reset
+ * device attached: call red_char_device_create
+ * device detached: call red_char_device_destroy/reset
  *
- * client connected and associated with a device: spice_char_device_client_add
- * client disconnected: spice_char_device_client_remove
+ * client connected and associated with a device: red_char_device__add
+ * client disconnected: red_char_device__remove
  *
  * Writing to the device
  * ---------------------
  * Write the data into RedCharDeviceWriteBuffer:
- * call spice_char_device_write_buffer_get in order to get an appropriate buffer.
- * call spice_char_device_write_buffer_add in order to push the buffer to the write queue.
+ * call red_char_device_buffer_get in order to get an appropriate buffer.
+ * call red_char_device_buffer_add in order to push the buffer to the write queue.
  * If you choose not to push the buffer to the device, call
- * spice_char_device_write_buffer_release
+ * red_char_device_buffer_release
  *
  * reading from the device
  * -----------------------
@@ -51,9 +51,9 @@
  *
  * calls triggered from the device (qemu):
  * --------------------------------------
- * spice_char_device_start
- * spice_char_device_stop
- * spice_char_device_wakeup (for reading from the device)
+ * red_char_device_start
+ * red_char_device_stop
+ * red_char_device_wakeup (for reading from the device)
  */
 
 /*
@@ -131,26 +131,26 @@ typedef struct SpiceCharDeviceCallbacks {
     void (*remove_client)(RedClient *client, void *opaque);
 } SpiceCharDeviceCallbacks;
 
-RedCharDevice *spice_char_device_state_create(SpiceCharDeviceInstance *sin,
-                                              struct RedsState *reds,
-                                              uint32_t client_tokens_interval,
-                                              uint32_t self_tokens,
-                                              SpiceCharDeviceCallbacks *cbs,
-                                              void *opaque);
+RedCharDevice *red_char_device_create(SpiceCharDeviceInstance *sin,
+                                      struct RedsState *reds,
+                                      uint32_t client_tokens_interval,
+                                      uint32_t self_tokens,
+                                      SpiceCharDeviceCallbacks *cbs,
+                                      void *opaque);
 
-void spice_char_device_state_reset_dev_instance(RedCharDevice *dev,
-                                                SpiceCharDeviceInstance *sin);
-void spice_char_device_state_destroy(RedCharDevice *dev);
+void red_char_device_reset_dev_instance(RedCharDevice *dev,
+                                        SpiceCharDeviceInstance *sin);
+void red_char_device_destroy(RedCharDevice *dev);
 
-void *spice_char_device_state_opaque_get(RedCharDevice *dev);
+void *red_char_device_opaque_get(RedCharDevice *dev);
 
 /* only one client is supported */
-void spice_char_device_state_migrate_data_marshall(RedCharDevice *dev,
-                                                  SpiceMarshaller *m);
-void spice_char_device_state_migrate_data_marshall_empty(SpiceMarshaller *m);
+void red_char_device_migrate_data_marshall(RedCharDevice *dev,
+                                           SpiceMarshaller *m);
+void red_char_device_migrate_data_marshall_empty(SpiceMarshaller *m);
 
-int spice_char_device_state_restore(RedCharDevice *dev,
-                                    SpiceMigrateDataCharDevice *mig_data);
+int red_char_device_restore(RedCharDevice *dev,
+                            SpiceMigrateDataCharDevice *mig_data);
 
 /*
  * Resets write/read queues, and moves that state to being stopped.
@@ -167,50 +167,50 @@ int spice_char_device_state_restore(RedCharDevice *dev,
  *
  *  todo: change AGENT_CONNECT msg to contain tokens count.
  */
-void spice_char_device_reset(RedCharDevice *dev);
+void red_char_device_reset(RedCharDevice *dev);
 
 /* max_send_queue_size = how many messages we can read from the device and enqueue for this client,
  * when we have tokens for other clients and no tokens for this one */
-int spice_char_device_client_add(RedCharDevice *dev,
-                                 RedClient *client,
-                                 int do_flow_control,
-                                 uint32_t max_send_queue_size,
-                                 uint32_t num_client_tokens,
-                                 uint32_t num_send_tokens,
-                                 int wait_for_migrate_data);
-
-void spice_char_device_client_remove(RedCharDevice *dev,
-                                     RedClient *client);
-int spice_char_device_client_exists(RedCharDevice *dev,
-                                    RedClient *client);
-
-void spice_char_device_start(RedCharDevice *dev);
-void spice_char_device_stop(RedCharDevice *dev);
-SpiceServer* spice_char_device_get_server(RedCharDevice *dev);
+int red_char_device_client_add(RedCharDevice *dev,
+                               RedClient *client,
+                               int do_flow_control,
+                               uint32_t max_send_queue_size,
+                               uint32_t num_client_tokens,
+                               uint32_t num_send_tokens,
+                               int wait_for_migrate_data);
+
+void red_char_device_client_remove(RedCharDevice *dev,
+                                   RedClient *client);
+int red_char_device_client_exists(RedCharDevice *dev,
+                                  RedClient *client);
+
+void red_char_device_start(RedCharDevice *dev);
+void red_char_device_stop(RedCharDevice *dev);
+SpiceServer* red_char_device_get_server(RedCharDevice *dev);
 
 /** Read from device **/
 
-void spice_char_device_wakeup(RedCharDevice *dev);
+void red_char_device_wakeup(RedCharDevice *dev);
 
-void spice_char_device_send_to_client_tokens_add(RedCharDevice *dev,
-                                                 RedClient *client,
-                                                 uint32_t tokens);
+void red_char_device_send_to_client_tokens_add(RedCharDevice *dev,
+                                               RedClient *client,
+                                               uint32_t tokens);
 
 
-void spice_char_device_send_to_client_tokens_set(RedCharDevice *dev,
-                                                 RedClient *client,
-                                                 uint32_t tokens);
+void red_char_device_send_to_client_tokens_set(RedCharDevice *dev,
+                                               RedClient *client,
+                                               uint32_t tokens);
 /** Write to device **/
 
-RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get(RedCharDevice *dev,
-                                                             RedClient *client, int size);
-RedCharDeviceWriteBuffer *spice_char_device_write_buffer_get_server_no_token(
+RedCharDeviceWriteBuffer *red_char_device_write_buffer_get(RedCharDevice *dev,
+                                                           RedClient *client, int size);
+RedCharDeviceWriteBuffer *red_char_device_write_buffer_get_server_no_token(
     RedCharDevice *dev, int size);
 
 /* Either add the buffer to the write queue or release it */
-void spice_char_device_write_buffer_add(RedCharDevice *dev,
+void red_char_device_write_buffer_add(RedCharDevice *dev,
                                         RedCharDeviceWriteBuffer *write_buf);
-void spice_char_device_write_buffer_release(RedCharDevice *dev,
+void red_char_device_write_buffer_release(RedCharDevice *dev,
                                             RedCharDeviceWriteBuffer *write_buf);
 
 /* api for specific char devices */
diff --git a/server/reds.c b/server/reds.c
index bb96d090..12de6089 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -434,10 +434,10 @@ static void reds_reset_vdp(RedsState *reds)
      */
     if (red_channel_test_remote_cap(&reds->main_channel->base,
                                     SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS)) {
-        spice_char_device_state_destroy(state->base);
+        red_char_device_destroy(state->base);
         state->base = NULL;
     } else {
-        spice_char_device_reset(state->base);
+        red_char_device_reset(state->base);
     }
 
     sif = spice_char_device_get_interface(reds->vdagent);
@@ -488,8 +488,8 @@ void reds_client_disconnect(RedsState *reds, RedClient *client)
     if (reds->agent_state.base) {
         /* note that vdagent might be NULL, if the vdagent was once
          * up and than was removed */
-        if (spice_char_device_client_exists(reds->agent_state.base, client)) {
-            spice_char_device_client_remove(reds->agent_state.base, client);
+        if (red_char_device_client_exists(reds->agent_state.base, client)) {
+            red_char_device_client_remove(reds->agent_state.base, client);
         }
     }
 
@@ -507,7 +507,7 @@ void reds_client_disconnect(RedsState *reds, RedClient *client)
             uint32_t total_msg_size;
 
             total_msg_size = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage);
-            char_dev_buf = spice_char_device_write_buffer_get_server_no_token(
+            char_dev_buf = red_char_device_write_buffer_get_server_no_token(
                                reds->agent_state.base, total_msg_size);
             char_dev_buf->buf_used = total_msg_size;
             internal_buf = (VDInternalBuf *)char_dev_buf->buf;
@@ -518,8 +518,8 @@ void reds_client_disconnect(RedsState *reds, RedClient *client)
             internal_buf->header.opaque = 0;
             internal_buf->header.size = 0;
 
-            spice_char_device_write_buffer_add(reds->agent_state.base,
-                                               char_dev_buf);
+            red_char_device_write_buffer_add(reds->agent_state.base,
+                                             char_dev_buf);
         }
 
         /* Reset write filter to start with clean state on client reconnect */
@@ -696,10 +696,10 @@ static void vdi_port_read_buf_unref(VDIReadBuf *buf)
 
         /* read_one_msg_from_vdi_port may have never completed because the read_bufs
         ring was empty. So we call it again so it can complete its work if
-        necessary. Note that since we can be called from spice_char_device_wakeup
+        necessary. Note that since we can be called from red_char_device_wakeup
         this can cause recursion, but we have protection for that */
         if (buf->state->base) {
-            spice_char_device_wakeup(buf->state->base);
+            red_char_device_wakeup(buf->state->base);
         }
     }
 }
@@ -845,9 +845,9 @@ void reds_handle_agent_mouse_event(RedsState *reds, const VDAgentMouseState *mou
 
     total_msg_size = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) +
                      sizeof(VDAgentMouseState);
-    char_dev_buf = spice_char_device_write_buffer_get(reds->agent_state.base,
-                                                      NULL,
-                                                      total_msg_size);
+    char_dev_buf = red_char_device_write_buffer_get(reds->agent_state.base,
+                                                    NULL,
+                                                    total_msg_size);
 
     if (!char_dev_buf) {
         reds->pending_mouse_event = TRUE;
@@ -866,7 +866,7 @@ void reds_handle_agent_mouse_event(RedsState *reds, const VDAgentMouseState *mou
     internal_buf->u.mouse_state = *mouse_state;
 
     char_dev_buf->buf_used = total_msg_size;
-    spice_char_device_write_buffer_add(reds->agent_state.base, char_dev_buf);
+    red_char_device_write_buffer_add(reds->agent_state.base, char_dev_buf);
 }
 
 int reds_get_n_channels(RedsState *reds)
@@ -938,16 +938,16 @@ void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t
      * and vice versa, the sending from the server to the client won't have
      * flow control, but will have no other problem.
      */
-    if (!spice_char_device_client_exists(dev_state, rcc->client)) {
+    if (!red_char_device_client_exists(dev_state, rcc->client)) {
         int client_added;
 
-        client_added = spice_char_device_client_add(dev_state,
-                                                    rcc->client,
-                                                    TRUE, /* flow control */
-                                                    REDS_VDI_PORT_NUM_RECEIVE_BUFFS,
-                                                    REDS_AGENT_WINDOW_SIZE,
-                                                    num_tokens,
-                                                    red_channel_client_is_waiting_for_migrate_data(rcc));
+        client_added = red_char_device_client_add(dev_state,
+                                                  rcc->client,
+                                                  TRUE, /* flow control */
+                                                  REDS_VDI_PORT_NUM_RECEIVE_BUFFS,
+                                                  REDS_AGENT_WINDOW_SIZE,
+                                                  num_tokens,
+                                                  red_channel_client_is_waiting_for_migrate_data(rcc));
 
         if (!client_added) {
             spice_warning("failed to add client to agent");
@@ -955,9 +955,9 @@ void reds_on_main_agent_start(RedsState *reds, MainChannelClient *mcc, uint32_t
             return;
         }
     } else {
-        spice_char_device_send_to_client_tokens_set(dev_state,
-                                                    rcc->client,
-                                                    num_tokens);
+        red_char_device_send_to_client_tokens_set(dev_state,
+                                                  rcc->client,
+                                                  num_tokens);
     }
 
     agent_msg_filter_config(&reds->agent_state.write_filter, reds->agent_copypaste,
@@ -972,7 +972,7 @@ void reds_on_main_agent_tokens(RedsState *reds, MainChannelClient *mcc, uint32_t
         return;
     }
     spice_assert(reds->vdagent->st);
-    spice_char_device_send_to_client_tokens_add(reds->vdagent->st,
+    red_char_device_send_to_client_tokens_add(reds->vdagent->st,
                                                 main_channel_client_get_base(mcc)->client,
                                                 num_tokens);
 }
@@ -995,9 +995,9 @@ uint8_t *reds_get_agent_data_buffer(RedsState *reds, MainChannelClient *mcc, siz
 
     spice_assert(dev_state->recv_from_client_buf == NULL);
     client = main_channel_client_get_base(mcc)->client;
-    dev_state->recv_from_client_buf = spice_char_device_write_buffer_get(dev_state->base,
-                                                                         client,
-                                                                         size + sizeof(VDIChunkHeader));
+    dev_state->recv_from_client_buf = red_char_device_write_buffer_get(dev_state->base,
+                                                                       client,
+                                                                       size + sizeof(VDIChunkHeader));
     dev_state->recv_from_client_buf_pushed = FALSE;
     return dev_state->recv_from_client_buf->buf + sizeof(VDIChunkHeader);
 }
@@ -1013,8 +1013,8 @@ void reds_release_agent_data_buffer(RedsState *reds, uint8_t *buf)
 
     spice_assert(buf == dev_state->recv_from_client_buf->buf + sizeof(VDIChunkHeader));
     if (!dev_state->recv_from_client_buf_pushed) {
-        spice_char_device_write_buffer_release(reds->agent_state.base,
-                                               dev_state->recv_from_client_buf);
+        red_char_device_write_buffer_release(reds->agent_state.base,
+                                             dev_state->recv_from_client_buf);
     }
     dev_state->recv_from_client_buf = NULL;
     dev_state->recv_from_client_buf_pushed = FALSE;
@@ -1085,7 +1085,7 @@ void reds_on_main_agent_data(RedsState *reds, MainChannelClient *mcc, void *mess
     dev_state->recv_from_client_buf->buf_used = sizeof(VDIChunkHeader) + size;
 
     dev_state->recv_from_client_buf_pushed = TRUE;
-    spice_char_device_write_buffer_add(reds->agent_state.base, dev_state->recv_from_client_buf);
+    red_char_device_write_buffer_add(reds->agent_state.base, dev_state->recv_from_client_buf);
 }
 
 void reds_on_main_migrate_connected(RedsState *reds, int seamless)
@@ -1180,7 +1180,7 @@ void reds_marshall_migrate_data(RedsState *reds, SpiceMarshaller *m)
                                              is destroyed when the agent is disconnected and
                                              there is no need to track the client tokens
                                              (see reds_reset_vdp) */
-        spice_char_device_state_migrate_data_marshall_empty(m);
+        red_char_device_migrate_data_marshall_empty(m);
         null_agent_mig_data = spice_marshaller_reserve_space(m,
                                                              sizeof(SpiceMigrateDataMain) -
                                                              sizeof(SpiceMigrateDataCharDevice));
@@ -1190,7 +1190,7 @@ void reds_marshall_migrate_data(RedsState *reds, SpiceMarshaller *m)
         return;
     }
 
-    spice_char_device_state_migrate_data_marshall(reds->agent_state.base, m);
+    red_char_device_migrate_data_marshall(reds->agent_state.base, m);
     spice_marshaller_add_uint8(m, reds->agent_state.client_agent_started);
 
     mig_data.agent2client.chunk_header = agent_state->vdi_chunk_header;
@@ -1310,7 +1310,7 @@ static int reds_agent_state_restore(RedsState *reds, SpiceMigrateDataMain *mig_d
                 agent_state->read_filter.discard_all,
                 agent_state->read_filter.msg_data_to_read,
                  agent_state->read_filter.result);
-    return spice_char_device_state_restore(agent_state->base, &mig_data->agent_base);
+    return red_char_device_restore(agent_state->base, &mig_data->agent_base);
 }
 
 /*
@@ -1340,7 +1340,7 @@ int reds_handle_migrate_data(RedsState *reds, MainChannelClient *mcc,
                 spice_debug("agent is no longer connected");
             } else {
                 if (agent_state->plug_generation > 1) {
-                    /* spice_char_device_state_reset takes care of not making the device wait for migration data */
+                    /* red_char_device_reset takes care of not making the device wait for migration data */
                     spice_debug("agent has been detached and reattached before receiving migration data");
                     main_channel_push_agent_disconnected(reds->main_channel);
                     main_channel_push_agent_connected(reds->main_channel);
@@ -1358,9 +1358,9 @@ int reds_handle_migrate_data(RedsState *reds, MainChannelClient *mcc,
     } else {
         spice_debug("agent was not attached on the source host");
         if (reds->vdagent) {
-            /* spice_char_device_client_remove disables waiting for migration data */
-            spice_char_device_client_remove(agent_state->base,
-                                            main_channel_client_get_base(mcc)->client);
+            /* red_char_device_client_remove disables waiting for migration data */
+            red_char_device_client_remove(agent_state->base,
+                                          main_channel_client_get_base(mcc)->client);
             main_channel_push_agent_connected(reds->main_channel);
         }
     }
@@ -2983,14 +2983,14 @@ static RedCharDevice *attach_to_red_agent(RedsState *reds, SpiceCharDeviceInstan
         char_dev_state_cbs.remove_client = vdi_port_remove_client;
         char_dev_state_cbs.on_free_self_token = vdi_port_on_free_self_token;
 
-        state->base = spice_char_device_state_create(sin,
-                                                     reds,
-                                                     REDS_TOKENS_TO_SEND,
-                                                     REDS_NUM_INTERNAL_AGENT_MESSAGES,
-                                                     &char_dev_state_cbs,
-                                                     reds);
+        state->base = red_char_device_create(sin,
+                                             reds,
+                                             REDS_TOKENS_TO_SEND,
+                                             REDS_NUM_INTERNAL_AGENT_MESSAGES,
+                                             &char_dev_state_cbs,
+                                             reds);
     } else {
-        spice_char_device_state_reset_dev_instance(state->base, sin);
+        red_char_device_reset_dev_instance(state->base, sin);
     }
 
     reds->vdagent = sin;
@@ -3017,16 +3017,16 @@ static RedCharDevice *attach_to_red_agent(RedsState *reds, SpiceCharDeviceInstan
          * 2.b If this happens second ==> we already have spice migrate data
          *     then restore state
          */
-        if (!spice_char_device_client_exists(reds->agent_state.base, reds_get_client(reds))) {
+        if (!red_char_device_client_exists(reds->agent_state.base, reds_get_client(reds))) {
             int client_added;
 
-            client_added = spice_char_device_client_add(reds->agent_state.base,
-                                                        reds_get_client(reds),
-                                                        TRUE, /* flow control */
-                                                        REDS_VDI_PORT_NUM_RECEIVE_BUFFS,
-                                                        REDS_AGENT_WINDOW_SIZE,
-                                                        ~0,
-                                                        TRUE);
+            client_added = red_char_device_client_add(reds->agent_state.base,
+                                                      reds_get_client(reds),
+                                                      TRUE, /* flow control */
+                                                      REDS_VDI_PORT_NUM_RECEIVE_BUFFS,
+                                                      REDS_AGENT_WINDOW_SIZE,
+                                                      ~0,
+                                                      TRUE);
 
             if (!client_added) {
                 spice_warning("failed to add client to agent");
@@ -3059,7 +3059,7 @@ SPICE_GNUC_VISIBLE void spice_server_char_device_wakeup(SpiceCharDeviceInstance*
         spice_warning("no RedCharDevice attached to instance %p", sin);
         return;
     }
-    spice_char_device_wakeup(sin->st);
+    red_char_device_wakeup(sin->st);
 }
 
 #define SUBTYPE_VDAGENT "vdagent"
@@ -3135,7 +3135,7 @@ static int spice_server_char_device_add_interface(SpiceServer *reds,
         /* setting the char_device state to "started" for backward compatibily with
          * qemu releases that don't call spice api for start/stop (not implemented yet) */
         if (reds->vm_running) {
-            spice_char_device_start(char_device->st);
+            red_char_device_start(char_device->st);
         }
         reds_add_char_device(reds, char_device->st);
     } else {
@@ -3297,7 +3297,7 @@ SPICE_GNUC_VISIBLE int spice_server_remove_interface(SpiceBaseInstance *sin)
         snd_detach_record(SPICE_CONTAINEROF(sin, SpiceRecordInstance, base));
     } else if (strcmp(interface->type, SPICE_INTERFACE_CHAR_DEVICE) == 0) {
         SpiceCharDeviceInstance *char_device = SPICE_CONTAINEROF(sin, SpiceCharDeviceInstance, base);
-        reds = spice_char_device_get_server(char_device->st);
+        reds = red_char_device_get_server(char_device->st);
         spice_server_char_device_remove_interface(reds, sin);
     } else {
         spice_warning("VD_INTERFACE_REMOVING unsupported");
@@ -3976,7 +3976,7 @@ SPICE_GNUC_VISIBLE void spice_server_vm_start(SpiceServer *reds)
 
     reds->vm_running = TRUE;
     for (it = reds->char_devices; it != NULL; it = it->next) {
-        spice_char_device_start(it->data);
+        red_char_device_start(it->data);
     }
     reds_on_vm_start(reds);
 }
@@ -3987,7 +3987,7 @@ SPICE_GNUC_VISIBLE void spice_server_vm_stop(SpiceServer *reds)
 
     reds->vm_running = FALSE;
     for (it = reds->char_devices; it != NULL; it = it->next) {
-        spice_char_device_stop(it->data);
+        red_char_device_stop(it->data);
     }
     reds_on_vm_stop(reds);
 }
diff --git a/server/smartcard.c b/server/smartcard.c
index 6e32f31a..b3261d80 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -240,7 +240,7 @@ MsgItem *smartcard_char_device_on_message_from_device(SmartCardDeviceState *stat
 
 static int smartcard_char_device_add_to_readers(RedsState *reds, SpiceCharDeviceInstance *char_device)
 {
-    SmartCardDeviceState *state = spice_char_device_state_opaque_get(char_device->st);
+    SmartCardDeviceState *state = red_char_device_opaque_get(char_device->st);
 
     if (g_smartcard_readers.num >= SMARTCARD_MAX_READERS) {
         return -1;
@@ -265,7 +265,7 @@ static SpiceCharDeviceInstance *smartcard_readers_get_unattached(void)
     SmartCardDeviceState* state;
 
     for (i = 0; i < g_smartcard_readers.num; ++i) {
-        state = spice_char_device_state_opaque_get(g_smartcard_readers.sin[i]->st);
+        state = red_char_device_opaque_get(g_smartcard_readers.sin[i]->st);
         if (!state->priv->scc) {
             return g_smartcard_readers.sin[i];
         }
@@ -286,12 +286,12 @@ static SmartCardDeviceState *smartcard_device_state_new(RedsState *reds, SpiceCh
     chardev_cbs.remove_client = smartcard_remove_client;
 
     st = spice_new0(SmartCardDeviceState, 1);
-    st->priv->chardev = spice_char_device_state_create(sin,
-                                                       reds,
-                                                       0, /* tokens interval */
-                                                       ~0, /* self tokens */
-                                                       &chardev_cbs,
-                                                       st);
+    st->priv->chardev = red_char_device_create(sin,
+                                               reds,
+                                               0, /* tokens interval */
+                                               ~0, /* self tokens */
+                                               &chardev_cbs,
+                                               st);
     st->priv->reader_id = VSCARD_UNDEFINED_READER_ID;
     st->priv->reader_added = FALSE;
     st->priv->buf_size = APDUBufSize + sizeof(VSCMsgHeader);
@@ -308,13 +308,13 @@ static void smartcard_device_state_free(SmartCardDeviceState* st)
         st->priv->scc->smartcard_state = NULL;
     }
     free(st->priv->buf);
-    spice_char_device_state_destroy(st->priv->chardev);
+    red_char_device_destroy(st->priv->chardev);
     free(st);
 }
 
 void smartcard_device_disconnect(SpiceCharDeviceInstance *char_device)
 {
-    SmartCardDeviceState *st = spice_char_device_state_opaque_get(char_device->st);
+    SmartCardDeviceState *st = red_char_device_opaque_get(char_device->st);
 
     smartcard_device_state_free(st);
 }
@@ -336,7 +336,7 @@ static void smartcard_char_device_notify_reader_add(SmartCardDeviceState *st)
     RedCharDeviceWriteBuffer *write_buf;
     VSCMsgHeader *vheader;
 
-    write_buf = spice_char_device_write_buffer_get(st->priv->chardev, NULL, sizeof(vheader));
+    write_buf = red_char_device_write_buffer_get(st->priv->chardev, NULL, sizeof(vheader));
     if (!write_buf) {
         spice_error("failed to allocate write buffer");
         return;
@@ -352,20 +352,20 @@ static void smartcard_char_device_notify_reader_add(SmartCardDeviceState *st)
 static void smartcard_char_device_attach_client(SpiceCharDeviceInstance *char_device,
                                                 SmartCardChannelClient *scc)
 {
-    SmartCardDeviceState *st = spice_char_device_state_opaque_get(char_device->st);
+    SmartCardDeviceState *st = red_char_device_opaque_get(char_device->st);
     int client_added;
 
     spice_assert(!scc->smartcard_state && !st->priv->scc);
     st->priv->scc = scc;
     scc->smartcard_state = st;
-    client_added = spice_char_device_client_add(st->priv->chardev,
-                                                scc->base.client,
-                                                FALSE, /* no flow control yet */
-                                                0, /* send queue size */
-                                                ~0,
-                                                ~0,
-                                                red_channel_client_is_waiting_for_migrate_data(
-                                                    &scc->base));
+    client_added = red_char_device_client_add(st->priv->chardev,
+                                              scc->base.client,
+                                              FALSE, /* no flow control yet */
+                                              0, /* send queue size */
+                                              ~0,
+                                              ~0,
+                                              red_channel_client_is_waiting_for_migrate_data(
+                                                  &scc->base));
     if (!client_added) {
         spice_warning("failed");
         st->priv->scc = NULL;
@@ -383,7 +383,7 @@ static void smartcard_char_device_notify_reader_remove(SmartCardDeviceState *st)
         spice_debug("reader add was never sent to the device");
         return;
     }
-    write_buf = spice_char_device_write_buffer_get(st->priv->chardev, NULL, sizeof(vheader));
+    write_buf = red_char_device_write_buffer_get(st->priv->chardev, NULL, sizeof(vheader));
     if (!write_buf) {
         spice_error("failed to allocate write buffer");
         return;
@@ -405,7 +405,7 @@ static void smartcard_char_device_detach_client(SmartCardChannelClient *scc)
     }
     st = scc->smartcard_state;
     spice_assert(st->priv->scc == scc);
-    spice_char_device_client_remove(st->priv->chardev, scc->base.client);
+    red_char_device_client_remove(st->priv->chardev, scc->base.client);
     scc->smartcard_state = NULL;
     st->priv->scc = NULL;
 }
@@ -434,7 +434,7 @@ static uint8_t *smartcard_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
         st = scc->smartcard_state;
         spice_assert(st->priv->scc || scc->smartcard_state);
         spice_assert(!scc->write_buf);
-        scc->write_buf = spice_char_device_write_buffer_get(st->priv->chardev, rcc->client, size);
+        scc->write_buf = red_char_device_write_buffer_get(st->priv->chardev, rcc->client, size);
 
         if (!scc->write_buf) {
             spice_error("failed to allocate write buffer");
@@ -464,7 +464,7 @@ static void smartcard_channel_release_msg_rcv_buf(RedChannelClient *rcc,
         if (scc->write_buf) { /* msg hasn't been pushed to the guest */
             spice_assert(scc->write_buf->buf == msg);
             dev = scc->smartcard_state ? scc->smartcard_state->priv->chardev : NULL;
-            spice_char_device_write_buffer_release(dev, scc->write_buf);
+            red_char_device_write_buffer_release(dev, scc->write_buf);
             scc->write_buf = NULL;
         }
     }
@@ -512,13 +512,13 @@ static void smartcard_channel_send_migrate_data(RedChannelClient *rcc,
     spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SMARTCARD_VERSION);
 
     if (!state) {
-        spice_char_device_state_migrate_data_marshall_empty(m);
+        red_char_device_migrate_data_marshall_empty(m);
         spice_marshaller_add_uint8(m, 0);
         spice_marshaller_add_uint32(m, 0);
         spice_marshaller_add_uint32(m, 0);
         spice_debug("null char dev state");
     } else {
-        spice_char_device_state_migrate_data_marshall(state->priv->chardev, m);
+        red_char_device_migrate_data_marshall(state->priv->chardev, m);
         spice_marshaller_add_uint8(m, state->priv->reader_added);
         spice_marshaller_add_uint32(m, state->priv->buf_used);
         m2 = spice_marshaller_get_ptr_submarshaller(m, 0);
@@ -628,7 +628,7 @@ static void smartcard_remove_reader(SmartCardChannelClient *scc, uint32_t reader
         return;
     }
 
-    state = spice_char_device_state_opaque_get(char_device->st);
+    state = red_char_device_opaque_get(char_device->st);
     if (state->priv->reader_added == FALSE) {
         smartcard_push_error(&scc->base, reader_id,
             VSC_GENERAL_ERROR);
@@ -669,7 +669,7 @@ static void smartcard_channel_write_to_reader(RedCharDeviceWriteBuffer *write_bu
 
     spice_assert(vheader->reader_id <= g_smartcard_readers.num);
     sin = g_smartcard_readers.sin[vheader->reader_id];
-    st = (SmartCardDeviceState *)spice_char_device_state_opaque_get(sin->st);
+    st = (SmartCardDeviceState *)red_char_device_opaque_get(sin->st);
     spice_assert(!st->priv->scc || st == st->priv->scc->smartcard_state);
     /* protocol requires messages to be in network endianess */
     vheader->type = htonl(vheader->type);
@@ -678,7 +678,7 @@ static void smartcard_channel_write_to_reader(RedCharDeviceWriteBuffer *write_bu
     write_buf->buf_used = actual_length + sizeof(VSCMsgHeader);
     /* pushing the buffer to the write queue; It will be released
      * when it will be fully consumed by the device */
-    spice_char_device_write_buffer_add(sin->st, write_buf);
+    red_char_device_write_buffer_add(sin->st, write_buf);
     if (st->priv->scc && write_buf == st->priv->scc->write_buf) {
         st->priv->scc->write_buf = NULL;
     }
@@ -746,7 +746,7 @@ static int smartcard_channel_client_handle_migrate_data(RedChannelClient *rcc,
     scc->smartcard_state->priv->reader_added = mig_data->reader_added;
 
     smartcard_device_state_restore_partial_read(scc->smartcard_state, mig_data);
-    return spice_char_device_state_restore(scc->smartcard_state->priv->chardev, &mig_data->base);
+    return red_char_device_restore(scc->smartcard_state->priv->chardev, &mig_data->base);
 }
 
 static int smartcard_channel_handle_message(RedChannelClient *rcc,
diff --git a/server/spicevmc.c b/server/spicevmc.c
index 36c5dafa..d1e8222e 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -220,13 +220,13 @@ static void spicevmc_red_channel_client_on_disconnect(RedChannelClient *rcc)
     state = SPICE_CONTAINEROF(rcc->channel, SpiceVmcState, channel);
 
     if (state->recv_from_client_buf) { /* partial message which wasn't pushed to device */
-        spice_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
+        red_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
         state->recv_from_client_buf = NULL;
     }
 
     if (state->chardev) {
-        if (spice_char_device_client_exists(state->chardev, rcc->client)) {
-            spice_char_device_client_remove(state->chardev, rcc->client);
+        if (red_char_device_client_exists(state->chardev, rcc->client)) {
+            red_char_device_client_remove(state->chardev, rcc->client);
         } else {
             spice_printerr("client %p have already been removed from char dev %p",
                            rcc->client, state->chardev);
@@ -275,7 +275,7 @@ static int spicevmc_channel_client_handle_migrate_data(RedChannelClient *rcc,
         spice_error("bad header");
         return FALSE;
     }
-    return spice_char_device_state_restore(state->chardev, &mig_data->base);
+    return red_char_device_restore(state->chardev, &mig_data->base);
 }
 
 static int spicevmc_red_channel_client_handle_message(RedChannelClient *rcc,
@@ -293,7 +293,7 @@ static int spicevmc_red_channel_client_handle_message(RedChannelClient *rcc,
     case SPICE_MSGC_SPICEVMC_DATA:
         spice_assert(state->recv_from_client_buf->buf == msg);
         state->recv_from_client_buf->buf_used = size;
-        spice_char_device_write_buffer_add(state->chardev, state->recv_from_client_buf);
+        red_char_device_write_buffer_add(state->chardev, state->recv_from_client_buf);
         state->recv_from_client_buf = NULL;
         break;
     case SPICE_MSGC_PORT_EVENT:
@@ -323,9 +323,9 @@ static uint8_t *spicevmc_red_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
     case SPICE_MSGC_SPICEVMC_DATA:
         assert(!state->recv_from_client_buf);
 
-        state->recv_from_client_buf = spice_char_device_write_buffer_get(state->chardev,
-                                                                         rcc->client,
-                                                                         size);
+        state->recv_from_client_buf = red_char_device_write_buffer_get(state->chardev,
+                                                                       rcc->client,
+                                                                       size);
         if (!state->recv_from_client_buf) {
             spice_error("failed to allocate write buffer");
             return NULL;
@@ -350,7 +350,7 @@ static void spicevmc_red_channel_release_msg_rcv_buf(RedChannelClient *rcc,
     switch (type) {
     case SPICE_MSGC_SPICEVMC_DATA:
         if (state->recv_from_client_buf) { /* buffer wasn't pushed to device */
-            spice_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
+            red_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
             state->recv_from_client_buf = NULL;
         }
         break;
@@ -386,7 +386,7 @@ static void spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
     spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SPICEVMC_MAGIC);
     spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SPICEVMC_VERSION);
 
-    spice_char_device_state_migrate_data_marshall(state->chardev, m);
+    red_char_device_migrate_data_marshall(state->chardev, m);
 }
 
 static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
@@ -486,8 +486,8 @@ static void spicevmc_connect(RedChannel *channel, RedClient *client,
         spicevmc_port_send_init(rcc);
     }
 
-    if (!spice_char_device_client_add(state->chardev, client, FALSE, 0, ~0, ~0,
-                                      red_channel_client_is_waiting_for_migrate_data(rcc))) {
+    if (!red_char_device_client_add(state->chardev, client, FALSE, 0, ~0, ~0,
+                                    red_channel_client_is_waiting_for_migrate_data(rcc))) {
         spice_warning("failed to add client to spicevmc");
         red_channel_client_disconnect(rcc);
         return;
@@ -537,12 +537,12 @@ RedCharDevice *spicevmc_device_connect(RedsState *reds,
     char_dev_cbs.send_tokens_to_client = spicevmc_char_dev_send_tokens_to_client;
     char_dev_cbs.remove_client = spicevmc_char_dev_remove_client;
 
-    state->chardev = spice_char_device_state_create(sin,
-                                                    reds,
-                                                    0, /* tokens interval */
-                                                    ~0, /* self tokens */
-                                                    &char_dev_cbs,
-                                                    state);
+    state->chardev = red_char_device_create(sin,
+                                            reds,
+                                            0, /* tokens interval */
+                                            ~0, /* self tokens */
+                                            &char_dev_cbs,
+                                            state);
     state->chardev_sin = sin;
 
     reds_register_channel(reds, &state->channel);
@@ -555,13 +555,13 @@ void spicevmc_device_disconnect(RedsState *reds, SpiceCharDeviceInstance *sin)
     SpiceVmcState *state;
 
     /* FIXME */
-    state = (SpiceVmcState *)spice_char_device_state_opaque_get((RedCharDevice*)sin->st);
+    state = (SpiceVmcState *)red_char_device_opaque_get((RedCharDevice*)sin->st);
 
     if (state->recv_from_client_buf) {
-        spice_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
+        red_char_device_write_buffer_release(state->chardev, state->recv_from_client_buf);
     }
     /* FIXME */
-    spice_char_device_state_destroy((RedCharDevice*)sin->st);
+    red_char_device_destroy((RedCharDevice*)sin->st);
     state->chardev = NULL;
     sin->st = NULL;
 
@@ -580,7 +580,7 @@ SPICE_GNUC_VISIBLE void spice_server_port_event(SpiceCharDeviceInstance *sin, ui
     }
 
     /* FIXME */
-    state = (SpiceVmcState *)spice_char_device_state_opaque_get((RedCharDevice*)sin->st);
+    state = (SpiceVmcState *)red_char_device_opaque_get((RedCharDevice*)sin->st);
     if (event == SPICE_PORT_EVENT_OPENED) {
         state->port_opened = TRUE;
     } else if (event == SPICE_PORT_EVENT_CLOSED) {