File do-endian-swapping.patch of Package spice-vdagent

Overview Repositories Revisions Requests Users Attributes Meta

File do-endian-swapping.patch of Package spice-vdagent (Revision 3f3872197e3a1408eb15e0eec8dd7f37)

Currently displaying revision 3f3872197e3a1408eb15e0eec8dd7f37 , Show latest

commit 1223d20e7dd7a6a4f0c6a76ced340aae41afed63
Author: Michal Suchanek <msuchanek@suse.de>
Date:   Tue Jan 3 18:27:25 2017 +0100

Quiet uninitialized variable warning.
    
    Signed-off-by: Michal Suchanek <msuchanek@suse.de>
    ---
    v2:
     - use g_return_if_reached

diff --git a/src/vdagentd.c b/src/vdagentd.c
index a699681..3ab81ed 100644
--- a/src/vdagentd.c
+++ b/src/vdagentd.c
@@ -305,6 +305,8 @@ static void do_client_file_xfer(struct vdagent_virtio_port *vport,
         id = d->id;
         break;
     }
+    default:
+        g_return_if_reached();
     }
 
     conn = g_hash_table_lookup(active_xfers, GUINT_TO_POINTER(id));

commit 875bffa0f39c1c1bf482d1c7ed8e84dabca361ba
Author: Michal Suchanek <msuchanek@suse.de>
Date:   Fri Jan 20 16:40:13 2017 +0100

udscs: don't pass message type strings into the server.
    
    The message types are defined by the protocol so the same array is
    always passed into the server anyway. So define the array size to be the
    number of message types and just use the array and limit directly in
    udscs. If somebody adds a message type in the future the array will
    contain some friendly NULLs at the end.
    
    Signed-off-by: Michal Suchanek <msuchanek@suse.de>

diff --git a/src/udscs.c b/src/udscs.c
index 427a844..807d375 100644
--- a/src/udscs.c
+++ b/src/udscs.c
@@ -32,6 +32,7 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include "udscs.h"
+#include "vdagentd-proto-strings.h"
 
 struct udscs_buf {
     uint8_t *buf;
@@ -43,8 +44,6 @@ struct udscs_buf {
 
 struct udscs_connection {
     int fd;
-    const char * const *type_to_string;
-    int no_types;
     int debug;
     void *user_data;
 #ifndef UDSCS_NO_SERVER
@@ -71,7 +70,7 @@ struct udscs_connection {
 struct udscs_connection *udscs_connect(const char *socketname,
     udscs_read_callback read_callback,
     udscs_disconnect_callback disconnect_callback,
-    const char * const type_to_string[], int no_types, int debug)
+    int debug)
 {
     int c;
     struct sockaddr_un address;
@@ -81,8 +80,6 @@ struct udscs_connection *udscs_connect(const char *socketname,
     if (!conn)
         return NULL;
 
-    conn->type_to_string = type_to_string;
-    conn->no_types = no_types;
     conn->debug = debug;
 
     conn->fd = socket(PF_UNIX, SOCK_STREAM, 0);
@@ -188,9 +185,9 @@ int udscs_write(struct udscs_connection *conn, uint32_t type, uint32_t arg1,
     memcpy(new_wbuf->buf + sizeof(header), data, size);
 
     if (conn->debug) {
-        if (type < conn->no_types)
+        if (type < VDAGENTD_NO_MESSAGES)
             syslog(LOG_DEBUG, "%p sent %s, arg1: %u, arg2: %u, size %u",
-                   conn, conn->type_to_string[type], arg1, arg2, size);
+                   conn, vdagentd_messages[type], arg1, arg2, size);
         else
             syslog(LOG_DEBUG,
                    "%p sent invalid message %u, arg1: %u, arg2: %u, size %u",
@@ -218,10 +215,10 @@ static void udscs_read_complete(struct udscs_connection **connp)
     struct udscs_connection *conn = *connp;
 
     if (conn->debug) {
-        if (conn->header.type < conn->no_types)
+        if (conn->header.type < VDAGENTD_NO_MESSAGES)
             syslog(LOG_DEBUG,
                    "%p received %s, arg1: %u, arg2: %u, size %u",
-                   conn, conn->type_to_string[conn->header.type],
+                   conn, vdagentd_messages[conn->header.type],
                    conn->header.arg1, conn->header.arg2, conn->header.size);
         else
             syslog(LOG_DEBUG,
@@ -358,8 +355,6 @@ int udscs_client_fill_fds(struct udscs_connection *conn, fd_set *readfds,
 
 struct udscs_server {
     int fd;
-    const char * const *type_to_string;
-    int no_types;
     int debug;
     struct udscs_connection connections_head;
     udscs_connect_callback connect_callback;
@@ -371,7 +366,7 @@ struct udscs_server *udscs_create_server(const char *socketname,
     udscs_connect_callback connect_callback,
     udscs_read_callback read_callback,
     udscs_disconnect_callback disconnect_callback,
-    const char * const type_to_string[], int no_types, int debug)
+    int debug)
 {
     int c;
     struct sockaddr_un address;
@@ -381,8 +376,6 @@ struct udscs_server *udscs_create_server(const char *socketname,
     if (!server)
         return NULL;
 
-    server->type_to_string = type_to_string;
-    server->no_types = no_types;
     server->debug = debug;
 
     server->fd = socket(PF_UNIX, SOCK_STREAM, 0);
@@ -459,8 +452,6 @@ static void udscs_server_accept(struct udscs_server *server) {
     }
 
     new_conn->fd = fd;
-    new_conn->type_to_string = server->type_to_string;
-    new_conn->no_types = server->no_types;
     new_conn->debug = server->debug;
     new_conn->read_callback = server->read_callback;
     new_conn->disconnect_callback = server->disconnect_callback;
diff --git a/src/udscs.h b/src/udscs.h
index e13750c..016e5d1 100644
--- a/src/udscs.h
+++ b/src/udscs.h
@@ -59,7 +59,7 @@ typedef void (*udscs_disconnect_callback)(struct udscs_connection *conn);
 struct udscs_connection *udscs_connect(const char *socketname,
     udscs_read_callback read_callback,
     udscs_disconnect_callback disconnect_callback,
-    const char * const type_to_string[], int no_types, int debug);
+    int debug);
 
 /* The contents of connp will be made NULL. */
 void udscs_destroy_connection(struct udscs_connection **connp);
@@ -101,7 +101,7 @@ struct udscs_server *udscs_create_server(const char *socketname,
     udscs_connect_callback connect_callback,
     udscs_read_callback read_callback,
     udscs_disconnect_callback disconnect_callback,
-    const char * const type_to_string[], int no_types, int debug);
+    int debug);
 
 void udscs_destroy_server(struct udscs_server *server);
 
diff --git a/src/vdagent.c b/src/vdagent.c
index a3cdd9b..0882c02 100644
--- a/src/vdagent.c
+++ b/src/vdagent.c
@@ -158,7 +158,6 @@ static int client_setup(int reconnect)
 {
     while (!quit) {
         client = udscs_connect(vdagentd_socket, daemon_read_complete, NULL,
-                               vdagentd_messages, VDAGENTD_NO_MESSAGES,
                                debug);
         if (client || !reconnect || quit) {
             break;
diff --git a/src/vdagentd-proto-strings.h b/src/vdagentd-proto-strings.h
index 6e7bcee..115f67f 100644
--- a/src/vdagentd-proto-strings.h
+++ b/src/vdagentd-proto-strings.h
@@ -18,11 +18,12 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
+#include <vdagentd-proto.h>
 
 #ifndef __VDAGENTD_PROTO_STRINGS_H
 #define __VDAGENTD_PROTO_STRINGS_H
 
-static const char * const vdagentd_messages[] = {
+static const char * const vdagentd_messages[VDAGENTD_NO_MESSAGES] = {
         "guest xorg resolution",
         "monitors config",
         "clipboard grab",
diff --git a/src/vdagentd.c b/src/vdagentd.c
index 3ab81ed..c7fef91 100644
--- a/src/vdagentd.c
+++ b/src/vdagentd.c
@@ -969,7 +969,6 @@ int main(int argc, char *argv[])
     /* Setup communication with vdagent process(es) */
     server = udscs_create_server(vdagentd_socket, agent_connect,
                                  agent_read_complete, agent_disconnect,
-                                 vdagentd_messages, VDAGENTD_NO_MESSAGES,
                                  debug);
     if (!server) {
         syslog(LOG_CRIT, "Fatal could not create server socket %s",

commit 65157b66e508c3466fda7eca13bd6f448c6b6b0b
Author: Michal Suchanek <msuchanek@suse.de>
Date:   Thu Jan 19 17:14:00 2017 +0100

Move mouse-specific handling out of virtio_port_read_complete
    
    Move some mouse-specific code from the start of
    virtio_port_read_complete to a separate helper
    as is the case with other message types.
    
    Signed-off-by: Michal Suchanek <msuchanek@suse.de>

diff --git a/src/vdagentd.c b/src/vdagentd.c
index c7fef91..4fcdb0e 100644
--- a/src/vdagentd.c
+++ b/src/vdagentd.c
@@ -118,6 +118,29 @@ static void do_client_disconnect(void)
     }
 }
 
+void do_client_mouse(struct vdagentd_uinput **uinputp, VDAgentMouseState *mouse)
+{
+    vdagentd_uinput_do_mouse(uinputp, mouse);
+    if (!*uinputp) {
+        /* Try to re-open the tablet */
+        struct agent_data *agent_data =
+            udscs_get_user_data(active_session_conn);
+        if (agent_data)
+            *uinputp = vdagentd_uinput_create(uinput_device,
+                                              agent_data->width,
+                                              agent_data->height,
+                                              agent_data->screen_info,
+                                              agent_data->screen_count,
+                                              debug > 1,
+                                              uinput_fake);
+        if (!*uinputp) {
+            syslog(LOG_CRIT, "Fatal uinput error");
+            retval = 1;
+            quit = 1;
+        }
+    }
+}
+
 static void do_client_monitors(struct vdagent_virtio_port *vport, int port_nr,
     VDAgentMessage *message_header, VDAgentMonitorsConfig *new_monitors)
 {
@@ -335,25 +358,7 @@ static int virtio_port_read_complete(
     case VD_AGENT_MOUSE_STATE:
         if (message_header->size != sizeof(VDAgentMouseState))
             goto size_error;
-        vdagentd_uinput_do_mouse(&uinput, (VDAgentMouseState *)data);
-        if (!uinput) {
-            /* Try to re-open the tablet */
-            struct agent_data *agent_data =
-                udscs_get_user_data(active_session_conn);
-            if (agent_data)
-                uinput = vdagentd_uinput_create(uinput_device,
-                                                agent_data->width,
-                                                agent_data->height,
-                                                agent_data->screen_info,
-                                                agent_data->screen_count,
-                                                debug > 1,
-                                                uinput_fake);
-            if (!uinput) {
-                syslog(LOG_CRIT, "Fatal uinput error");
-                retval = 1;
-                quit = 1;
-            }
-        }
+        do_client_mouse(&uinput, (VDAgentMouseState *)data);
         break;
     case VD_AGENT_MONITORS_CONFIG:
         if (message_header->size < sizeof(VDAgentMonitorsConfig))

commit bbfd85d436e8ff0c5b329570c43a4f9960cfa565
Author: Victor Toso <me@victortoso.com>
Date:   Fri Jan 20 12:18:20 2017 +0100

vdagentd: early return on bad message size
    
    The payload size for each message should be the size of the expected
    struct or bigger when it contain arrays of no fixed size.
    
    This patch creates the vdagent_message_min_size[] static array with
    the expected size for each message so we can check on
    virtio_port_read_complete().
    
    Signed-off-by: Victor Toso <victortoso@redhat.com>
    Signed-off-by: Michal Suchanek <msuchanek@suse.de>

diff --git a/src/vdagentd.c b/src/vdagentd.c
index 4fcdb0e..71cd1bc 100644
--- a/src/vdagentd.c
+++ b/src/vdagentd.c
@@ -341,6 +341,27 @@ static void do_client_file_xfer(struct vdagent_virtio_port *vport,
     udscs_write(conn, msg_type, 0, 0, data, message_header->size);
 }
 
+static gsize vdagent_message_min_size[VD_AGENT_END_MESSAGE] =
+{
+    -1, /* Does not exist */
+    sizeof(VDAgentMouseState), /* VD_AGENT_MOUSE_STATE */
+    sizeof(VDAgentMonitorsConfig), /* VD_AGENT_MONITORS_CONFIG */
+    sizeof(VDAgentReply), /* VD_AGENT_REPLY */
+    sizeof(VDAgentClipboard), /* VD_AGENT_CLIPBOARD */
+    sizeof(VDAgentDisplayConfig), /* VD_AGENT_DISPLAY_CONFIG */
+    sizeof(VDAgentAnnounceCapabilities), /* VD_AGENT_ANNOUNCE_CAPABILITIES */
+    sizeof(VDAgentClipboardGrab), /* VD_AGENT_CLIPBOARD_GRAB */
+    sizeof(VDAgentClipboardRequest), /* VD_AGENT_CLIPBOARD_REQUEST */
+    sizeof(VDAgentClipboardRelease), /* VD_AGENT_CLIPBOARD_RELEASE */
+    sizeof(VDAgentFileXferStartMessage), /* VD_AGENT_FILE_XFER_START */
+    sizeof(VDAgentFileXferStatusMessage), /* VD_AGENT_FILE_XFER_STATUS */
+    sizeof(VDAgentFileXferDataMessage), /* VD_AGENT_FILE_XFER_DATA */
+    0, /* VD_AGENT_CLIENT_DISCONNECTED */
+    sizeof(VDAgentMaxClipboard), /* VD_AGENT_MAX_CLIPBOARD */
+    sizeof(VDAgentAudioVolumeSync), /* VD_AGENT_AUDIO_VOLUME_SYNC */
+    -1 /* VD_AGENT_END_MESSAGE */
+};
+
 static int virtio_port_read_complete(
         struct vdagent_virtio_port *vport,
         int port_nr,
@@ -354,21 +375,62 @@ static int virtio_port_read_complete(
         return 0;
     }
 
+    if (message_header->type >= VD_AGENT_END_MESSAGE) {
+        syslog(LOG_WARNING, "unknown message type %d, ignoring",
+               message_header->type);
+        return 0;
+    }
+
+    min_size = vdagent_message_min_size[message_header->type];
+    if (VD_AGENT_HAS_CAPABILITY(capabilities, capabilities_size,
+                                VD_AGENT_CAP_CLIPBOARD_SELECTION)) {
+        switch (message_header->type) {
+        case VD_AGENT_CLIPBOARD_GRAB:
+        case VD_AGENT_CLIPBOARD_REQUEST:
+        case VD_AGENT_CLIPBOARD:
+        case VD_AGENT_CLIPBOARD_RELEASE:
+          min_size += 4;
+        }
+    }
+    switch (message_header->type) {
+    case VD_AGENT_MONITORS_CONFIG:
+    case VD_AGENT_FILE_XFER_START:
+    case VD_AGENT_FILE_XFER_DATA:
+    case VD_AGENT_CLIPBOARD:
+    case VD_AGENT_CLIPBOARD_GRAB:
+    case VD_AGENT_AUDIO_VOLUME_SYNC:
+    case VD_AGENT_ANNOUNCE_CAPABILITIES:
+        if (message_header->size != min_size) {
+            syslog(LOG_ERR, "read: invalid message size: %u for message type: %u",
+                   message_header->size, message_header->type);
+            return 0;
+        }
+    case VD_AGENT_MOUSE_STATE:
+    case VD_AGENT_FILE_XFER_STATUS:
+    case VD_AGENT_DISPLAY_CONFIG:
+    case VD_AGENT_REPLY:
+    case VD_AGENT_CLIPBOARD_REQUEST:
+    case VD_AGENT_CLIPBOARD_RELEASE:
+    case VD_AGENT_MAX_CLIPBOARD:
+    case VD_AGENT_CLIENT_DISCONNECTED:
+        if (message_header->size < min_size) {
+            syslog(LOG_ERR, "read: invalid message size: %u for message type: %u",
+                   message_header->size, message_header->type);
+            return 0;
+        }
+    default:
+        g_warn_if_reached();
+    }
+
     switch (message_header->type) {
     case VD_AGENT_MOUSE_STATE:
-        if (message_header->size != sizeof(VDAgentMouseState))
-            goto size_error;
         do_client_mouse(&uinput, (VDAgentMouseState *)data);
         break;
     case VD_AGENT_MONITORS_CONFIG:
-        if (message_header->size < sizeof(VDAgentMonitorsConfig))
-            goto size_error;
         do_client_monitors(vport, port_nr, message_header,
                     (VDAgentMonitorsConfig *)data);
         break;
     case VD_AGENT_ANNOUNCE_CAPABILITIES:
-        if (message_header->size < sizeof(VDAgentAnnounceCapabilities))
-            goto size_error;
         do_client_capabilities(vport, message_header,
                         (VDAgentAnnounceCapabilities *)data);
         break;
@@ -388,9 +450,6 @@ static int virtio_port_read_complete(
                                     VD_AGENT_CAP_CLIPBOARD_SELECTION)) {
             min_size += 4;
         }
-        if (message_header->size < min_size) {
-            goto size_error;
-        }
         do_client_clipboard(vport, message_header, data);
         break;
     case VD_AGENT_FILE_XFER_START:
@@ -402,31 +461,21 @@ static int virtio_port_read_complete(
         vdagent_virtio_port_reset(vport, VDP_CLIENT_PORT);
         do_client_disconnect();
         break;
-    case VD_AGENT_MAX_CLIPBOARD:
-        if (message_header->size != sizeof(VDAgentMaxClipboard))
-            goto size_error;
+    case VD_AGENT_MAX_CLIPBOARD: {
         VDAgentMaxClipboard *msg = (VDAgentMaxClipboard *)data;
         syslog(LOG_DEBUG, "Set max clipboard: %d", msg->max);
         max_clipboard = msg->max;
         break;
+    }
     case VD_AGENT_AUDIO_VOLUME_SYNC:
-        if (message_header->size < sizeof(VDAgentAudioVolumeSync))
-            goto size_error;
-
         do_client_volume_sync(vport, port_nr, message_header,
                 (VDAgentAudioVolumeSync *)data);
         break;
     default:
-        syslog(LOG_WARNING, "unknown message type %d, ignoring",
-               message_header->type);
+        g_warn_if_reached();
     }
 
     return 0;
-
-size_error:
-    syslog(LOG_ERR, "read: invalid message size: %u for message type: %u",
-           message_header->size, message_header->type);
-    return 0;
 }
 
 static void virtio_write_clipboard(uint8_t selection, uint32_t msg_type,

commit 15dce8ca421d3daaf3c653093835f53e1cacbcd2
Author: Michal Suchanek <msuchanek@suse.de>
Date:   Tue Nov 8 16:47:07 2016 +0100

Do endian swapping.
    
    This allows running big endian and little endian guest side by side using
    cut & paste between them.
    
    There is a general design idea that swapping should come as close to
    virtio_read/virtio_write as possible. In particular, the protocol
    between vdagent and vdagentd is guest-specific and in native endian.
    With muliple layers of headers this is a bit tricky. A few message types
    have to be swapped fully before passing through vdagentd.
    
    Signed-off-by: Michal Suchanek <msuchanek@suse.de>
    
    ---
    v2:
     - introduce helper functions to swap (a portion of) a message wholesale
     - pollute fewer places with swapping sometimes at the cost of slightly
       more verbose code
    v3:
     - use glib byteswap macros in place of endian.h byteswap macros
     - move variable declaration out of case statement
     - reuse more of existing clipboard code
    v4:
     - also use glib byteswap for 64bit swaps
     - use file xfer message structure for swapping size
    v5:
     - rebase on top of vdagentd: early return on bad message size

diff --git a/src/vdagent-virtio-port.c b/src/vdagent-virtio-port.c
index 6267c74..2d1ee5b 100644
--- a/src/vdagent-virtio-port.c
+++ b/src/vdagent-virtio-port.c
@@ -28,6 +28,7 @@
 #include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <glib.h>
 
 #include "vdagent-virtio-port.h"
 
@@ -216,16 +217,16 @@ int vdagent_virtio_port_write_start(
         return -1;
     }
 
-    chunk_header.port = port_nr;
-    chunk_header.size = sizeof(message_header) + data_size;
+    chunk_header.port = GUINT32_TO_LE(port_nr);
+    chunk_header.size = GUINT32_TO_LE(sizeof(message_header) + data_size);
     memcpy(new_wbuf->buf + new_wbuf->write_pos, &chunk_header,
            sizeof(chunk_header));
     new_wbuf->write_pos += sizeof(chunk_header);
 
-    message_header.protocol = VD_AGENT_PROTOCOL;
-    message_header.type = message_type;
-    message_header.opaque = message_opaque;
-    message_header.size = data_size;
+    message_header.protocol = GUINT32_TO_LE(VD_AGENT_PROTOCOL);
+    message_header.type = GUINT32_TO_LE(message_type);
+    message_header.opaque = GUINT64_TO_LE(message_opaque);
+    message_header.size = GUINT32_TO_LE(data_size);
     memcpy(new_wbuf->buf + new_wbuf->write_pos, &message_header,
            sizeof(message_header));
     new_wbuf->write_pos += sizeof(message_header);
@@ -309,13 +310,20 @@ static void vdagent_virtio_port_do_chunk(struct vdagent_virtio_port **vportp)
         memcpy((uint8_t *)&port->message_header + port->message_header_read,
                vport->chunk_data, read);
         port->message_header_read += read;
-        if (port->message_header_read == sizeof(port->message_header) &&
-                port->message_header.size) {
-            port->message_data = malloc(port->message_header.size);
-            if (!port->message_data) {
-                syslog(LOG_ERR, "out of memory, disconnecting virtio");
-                vdagent_virtio_port_destroy(vportp);
-                return;
+        if (port->message_header_read == sizeof(port->message_header)) {
+
+            port->message_header.protocol = GUINT32_FROM_LE(port->message_header.protocol);
+            port->message_header.type = GUINT32_FROM_LE(port->message_header.type);
+            port->message_header.opaque = GUINT64_FROM_LE(port->message_header.opaque);
+            port->message_header.size = GUINT32_FROM_LE(port->message_header.size);
+
+            if (port->message_header.size) {
+                port->message_data = malloc(port->message_header.size);
+                if (!port->message_data) {
+                    syslog(LOG_ERR, "out of memory, disconnecting virtio");
+                    vdagent_virtio_port_destroy(vportp);
+                    return;
+                }
             }
         }
         pos = read;
@@ -420,6 +428,8 @@ static void vdagent_virtio_port_do_read(struct vdagent_virtio_port **vportp)
     if (vport->chunk_header_read < sizeof(vport->chunk_header)) {
         vport->chunk_header_read += n;
         if (vport->chunk_header_read == sizeof(vport->chunk_header)) {
+            vport->chunk_header.size = GUINT32_FROM_LE(vport->chunk_header.size);
+            vport->chunk_header.port = GUINT32_FROM_LE(vport->chunk_header.port);
             if (vport->chunk_header.size > VD_AGENT_MAX_DATA_SIZE) {
                 syslog(LOG_ERR, "chunk size %u too large",
                        vport->chunk_header.size);
diff --git a/src/vdagentd.c b/src/vdagentd.c
index 71cd1bc..e8eeef9 100644
--- a/src/vdagentd.c
+++ b/src/vdagentd.c
@@ -78,6 +78,34 @@ static int client_connected = 0;
 static int max_clipboard = -1;
 
 /* utility functions */
+static void virtio_msg_uint32_to_le(uint8_t *_msg, uint32_t size, uint32_t offset)
+{
+    uint32_t i, *msg = (uint32_t *)(_msg + offset);
+
+    /* offset - size % 4 should be 0 */
+    for (i = 0; i < (size - offset) / 4; i++)
+        msg[i] = GUINT32_TO_LE(msg[i]);
+}
+
+static void virtio_msg_uint32_from_le(uint8_t *_msg, uint32_t size, uint32_t offset)
+{
+    uint32_t i, *msg = (uint32_t *)(_msg + offset);
+
+    /* offset - size % 4 should be 0 */
+    for (i = 0; i < (size - offset) / 4; i++)
+        msg[i] = GUINT32_FROM_LE(msg[i]);
+}
+
+static void virtio_msg_uint16_from_le(uint8_t *_msg, uint32_t size, uint32_t offset)
+{
+    uint32_t i;
+    uint16_t *msg = (uint16_t *)(_msg + offset);
+
+    /* offset - size % 2 should be 0 */
+    for (i = 0; i < (size - offset) / 2; i++)
+        msg[i] = GUINT16_FROM_LE(msg[i]);
+}
+
 /* vdagentd <-> spice-client communication handling */
 static void send_capabilities(struct vdagent_virtio_port *vport,
     uint32_t request)
@@ -102,6 +130,7 @@ static void send_capabilities(struct vdagent_virtio_port *vport,
     VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_GUEST_LINEEND_LF);
     VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_MAX_CLIPBOARD);
     VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_AUDIO_VOLUME_SYNC);
+    virtio_msg_uint32_to_le((uint8_t *)caps, size, 0);
 
     vdagent_virtio_port_write(vport, VDP_CLIENT_PORT,
                               VD_AGENT_ANNOUNCE_CAPABILITIES, 0,
@@ -174,8 +203,8 @@ static void do_client_monitors(struct vdagent_virtio_port *vport, int port_nr,
                     (uint8_t *)mon_config, size);
 
     /* Acknowledge reception of monitors config to spice server / client */
-    reply.type  = VD_AGENT_MONITORS_CONFIG;
-    reply.error = VD_AGENT_SUCCESS;
+    reply.type  = GUINT32_TO_LE(VD_AGENT_MONITORS_CONFIG);
+    reply.error = GUINT32_TO_LE(VD_AGENT_SUCCESS);
     vdagent_virtio_port_write(vport, port_nr, VD_AGENT_REPLY, 0,
                               (uint8_t *)&reply, sizeof(reply));
 }
@@ -278,8 +307,8 @@ static void send_file_xfer_status(struct vdagent_virtio_port *vport,
                                   const char *msg, uint32_t id, uint32_t xfer_status)
 {
     VDAgentFileXferStatusMessage status = {
-        .id = id,
-        .result = xfer_status,
+        .id = GUINT32_TO_LE(id),
+        .result = GUINT32_TO_LE(xfer_status),
     };
     syslog(LOG_WARNING, msg, id);
     if (vport)
@@ -369,6 +398,8 @@ static int virtio_port_read_complete(
         uint8_t *data)
 {
     uint32_t min_size = 0;
+    uint32_t *data_type = (uint32_t *)data;
+    uint32_t *id = (uint32_t *)data;
 
     if (message_header->protocol != VD_AGENT_PROTOCOL) {
         syslog(LOG_ERR, "message with wrong protocol version ignoring");
@@ -424,13 +455,16 @@ static int virtio_port_read_complete(
 
     switch (message_header->type) {
     case VD_AGENT_MOUSE_STATE:
+        virtio_msg_uint32_from_le(data, message_header->size, 0);
         do_client_mouse(&uinput, (VDAgentMouseState *)data);
         break;
     case VD_AGENT_MONITORS_CONFIG:
+        virtio_msg_uint32_from_le(data, message_header->size, 0);
         do_client_monitors(vport, port_nr, message_header,
                     (VDAgentMonitorsConfig *)data);
         break;
     case VD_AGENT_ANNOUNCE_CAPABILITIES:
+        virtio_msg_uint32_from_le(data, message_header->size, 0);
         do_client_capabilities(vport, message_header,
                         (VDAgentAnnounceCapabilities *)data);
         break;
@@ -449,12 +483,34 @@ static int virtio_port_read_complete(
         if (VD_AGENT_HAS_CAPABILITY(capabilities, capabilities_size,
                                     VD_AGENT_CAP_CLIPBOARD_SELECTION)) {
             min_size += 4;
+            data_type++;
+        }
+        switch (message_header->type) {
+        case VD_AGENT_CLIPBOARD_REQUEST:
+        case VD_AGENT_CLIPBOARD:
+            *data_type = GUINT32_FROM_LE(*data_type);
+            break;
+        case VD_AGENT_CLIPBOARD_GRAB:
+            virtio_msg_uint32_from_le(data, message_header->size, min_size);
+            break;
         }
         do_client_clipboard(vport, message_header, data);
         break;
     case VD_AGENT_FILE_XFER_START:
     case VD_AGENT_FILE_XFER_STATUS:
     case VD_AGENT_FILE_XFER_DATA:
+        *id = GUINT32_FROM_LE(*id);
+        id++; /* status */
+        switch (message_header->type) {
+        case VD_AGENT_FILE_XFER_DATA: {
+            VDAgentFileXferDataMessage *msg = (VDAgentFileXferDataMessage *)data;
+            msg->size = GUINT64_FROM_LE(msg->size);
+            break;
+        }
+        case VD_AGENT_FILE_XFER_STATUS:
+            *id = GUINT32_FROM_LE(*id); /* status */
+            break;
+        }
         do_client_file_xfer(vport, message_header, data);
         break;
     case VD_AGENT_CLIENT_DISCONNECTED:
@@ -463,14 +519,18 @@ static int virtio_port_read_complete(
         break;
     case VD_AGENT_MAX_CLIPBOARD: {
         VDAgentMaxClipboard *msg = (VDAgentMaxClipboard *)data;
-        syslog(LOG_DEBUG, "Set max clipboard: %d", msg->max);
-        max_clipboard = msg->max;
+        syslog(LOG_DEBUG, "Set max clipboard: %d", GUINT32_FROM_LE(msg->max));
+        max_clipboard = GUINT32_FROM_LE(msg->max);
         break;
     }
-    case VD_AGENT_AUDIO_VOLUME_SYNC:
-        do_client_volume_sync(vport, port_nr, message_header,
-                (VDAgentAudioVolumeSync *)data);
+    case VD_AGENT_AUDIO_VOLUME_SYNC: {
+        VDAgentAudioVolumeSync *vdata = (VDAgentAudioVolumeSync *)data;
+        virtio_msg_uint16_from_le((uint8_t *)vdata, message_header->size,
+            offsetof(VDAgentAudioVolumeSync, volume));
+
+        do_client_volume_sync(vport, port_nr, message_header, vdata);
         break;
+    }
     default:
         g_warn_if_reached();
     }
@@ -479,7 +539,7 @@ static int virtio_port_read_complete(
 }
 
 static void virtio_write_clipboard(uint8_t selection, uint32_t msg_type,
-    uint32_t data_type, const uint8_t *data, uint32_t data_size)
+    uint32_t data_type, uint8_t *data, uint32_t data_size)
 {
     uint32_t size = data_size;
 
@@ -500,15 +560,18 @@ static void virtio_write_clipboard(uint8_t selection, uint32_t msg_type,
         vdagent_virtio_port_write_append(virtio_port, sel, 4);
     }
     if (data_type != -1) {
+        data_type = GUINT32_TO_LE(data_type);
         vdagent_virtio_port_write_append(virtio_port, (uint8_t*)&data_type, 4);
     }
 
+    if (msg_type == VD_AGENT_CLIPBOARD_GRAB)
+        virtio_msg_uint32_to_le(data, data_size, 0);
     vdagent_virtio_port_write_append(virtio_port, data, data_size);
 }
 
 /* vdagentd <-> vdagent communication handling */
 static int do_agent_clipboard(struct udscs_connection *conn,
-        struct udscs_message_header *header, const uint8_t *data)
+        struct udscs_message_header *header, uint8_t *data)
 {
     uint8_t selection = header->arg1;
     uint32_t msg_type = 0, data_type = -1, size = header->size;
@@ -822,8 +885,8 @@ static void agent_read_complete(struct udscs_connection **connp,
         break;
     case VDAGENTD_FILE_XFER_STATUS:{
         VDAgentFileXferStatusMessage status;
-        status.id = header->arg1;
-        status.result = header->arg2;
+        status.id = GUINT32_TO_LE(header->arg1);
+        status.result = GUINT32_TO_LE(header->arg2);
         vdagent_virtio_port_write(virtio_port, VDP_CLIENT_PORT,
                                   VD_AGENT_FILE_XFER_STATUS, 0,
                                   (uint8_t *)&status, sizeof(status));

commit aed1e33e00de594ae376911d312a448883146ddc
Author: Victor Toso <me@victortoso.com>
Date:   Fri Jan 20 15:31:54 2017 +0100

SQUASH: Move clipboard nested switch out
    
    Signed-off-by: Victor Toso <victortoso@redhat.com>

diff --git a/src/vdagentd.c b/src/vdagentd.c
index e8eeef9..9410eef 100644
--- a/src/vdagentd.c
+++ b/src/vdagentd.c
@@ -391,14 +391,37 @@ static gsize vdagent_message_min_size[VD_AGENT_END_MESSAGE] =
     -1 /* VD_AGENT_END_MESSAGE */
 };
 
+static void vdagent_message_clipboard_from_le(VDAgentMessage *message_header,
+        uint8_t *data)
+{
+    gsize min_size = vdagent_message_min_size[message_header->type];
+    uint32_t *data_type = (uint32_t *) data;
+
+    if (VD_AGENT_HAS_CAPABILITY(capabilities, capabilities_size,
+                                VD_AGENT_CAP_CLIPBOARD_SELECTION)) {
+        min_size += 4;
+        data_type++;
+    }
+
+    switch (message_header->type) {
+    case VD_AGENT_CLIPBOARD_REQUEST:
+    case VD_AGENT_CLIPBOARD:
+        *data_type = GUINT32_FROM_LE(*data_type);
+        break;
+    case VD_AGENT_CLIPBOARD_GRAB:
+        virtio_msg_uint32_from_le(data, message_header->size, min_size);
+        break;
+    default:
+        g_warn_if_reached();
+    }
+}
+
 static int virtio_port_read_complete(
         struct vdagent_virtio_port *vport,
         int port_nr,
         VDAgentMessage *message_header,
         uint8_t *data)
 {
-    uint32_t min_size = 0;
-    uint32_t *data_type = (uint32_t *)data;
     uint32_t *id = (uint32_t *)data;
 
     if (message_header->protocol != VD_AGENT_PROTOCOL) {
@@ -472,28 +495,7 @@ static int virtio_port_read_complete(
     case VD_AGENT_CLIPBOARD_REQUEST:
     case VD_AGENT_CLIPBOARD:
     case VD_AGENT_CLIPBOARD_RELEASE:
-        switch (message_header->type) {
-        case VD_AGENT_CLIPBOARD_GRAB:
-            min_size = sizeof(VDAgentClipboardGrab); break;
-        case VD_AGENT_CLIPBOARD_REQUEST:
-            min_size = sizeof(VDAgentClipboardRequest); break;
-        case VD_AGENT_CLIPBOARD:
-            min_size = sizeof(VDAgentClipboard); break;
-        }
-        if (VD_AGENT_HAS_CAPABILITY(capabilities, capabilities_size,
-                                    VD_AGENT_CAP_CLIPBOARD_SELECTION)) {
-            min_size += 4;
-            data_type++;
-        }
-        switch (message_header->type) {
-        case VD_AGENT_CLIPBOARD_REQUEST:
-        case VD_AGENT_CLIPBOARD:
-            *data_type = GUINT32_FROM_LE(*data_type);
-            break;
-        case VD_AGENT_CLIPBOARD_GRAB:
-            virtio_msg_uint32_from_le(data, message_header->size, min_size);
-            break;
-        }
+        vdagent_message_clipboard_from_le(message_header, data);
         do_client_clipboard(vport, message_header, data);
         break;
     case VD_AGENT_FILE_XFER_START:

commit 8d7ddd7b40e0fa7ac745c609912497127e57a456
Author: Victor Toso <me@victortoso.com>
Date:   Fri Jan 20 15:40:16 2017 +0100

SQUASH: Move file-xfer nested switch out
    
    Signed-off-by: Victor Toso <victortoso@redhat.com>

diff --git a/src/vdagentd.c b/src/vdagentd.c
index 9410eef..c8662bd 100644
--- a/src/vdagentd.c
+++ b/src/vdagentd.c
@@ -416,14 +416,31 @@ static void vdagent_message_clipboard_from_le(VDAgentMessage *message_header,
     }
 }
 
+static void vdagent_message_file_xfer_from_le(VDAgentMessage *message_header,
+        uint8_t *data)
+{
+    uint32_t *id = (uint32_t *)data;
+    *id = GUINT32_FROM_LE(*id);
+    id++; /* status */
+
+    switch (message_header->type) {
+    case VD_AGENT_FILE_XFER_DATA: {
+       VDAgentFileXferDataMessage *msg = (VDAgentFileXferDataMessage *)data;
+       msg->size = GUINT64_FROM_LE(msg->size);
+       break;
+    }
+    case VD_AGENT_FILE_XFER_STATUS:
+       *id = GUINT32_FROM_LE(*id); /* status */
+       break;
+    }
+}
+
 static int virtio_port_read_complete(
         struct vdagent_virtio_port *vport,
         int port_nr,
         VDAgentMessage *message_header,
         uint8_t *data)
 {
-    uint32_t *id = (uint32_t *)data;
-
     if (message_header->protocol != VD_AGENT_PROTOCOL) {
         syslog(LOG_ERR, "message with wrong protocol version ignoring");
         return 0;
@@ -501,18 +518,7 @@ static int virtio_port_read_complete(
     case VD_AGENT_FILE_XFER_START:
     case VD_AGENT_FILE_XFER_STATUS:
     case VD_AGENT_FILE_XFER_DATA:
-        *id = GUINT32_FROM_LE(*id);
-        id++; /* status */
-        switch (message_header->type) {
-        case VD_AGENT_FILE_XFER_DATA: {
-            VDAgentFileXferDataMessage *msg = (VDAgentFileXferDataMessage *)data;
-            msg->size = GUINT64_FROM_LE(msg->size);
-            break;
-        }
-        case VD_AGENT_FILE_XFER_STATUS:
-            *id = GUINT32_FROM_LE(*id); /* status */
-            break;
-        }
+        vdagent_message_file_xfer_from_le(message_header, data);
         do_client_file_xfer(vport, message_header, data);
         break;
     case VD_AGENT_CLIENT_DISCONNECTED:

Places

File do-endian-swapping.patch of Package spice-vdagent (Revision 3f3872197e3a1408eb15e0eec8dd7f37)

Places