Commit 6105683d authored by Laurent Vivier's avatar Laurent Vivier Committed by Gerd Hoffmann
Browse files

ui: add an embedded Barrier client 

This allows to receive mouse and keyboard events from
a Barrier server.

This is enabled by adding the following parameter on the
command line

    ... -object input-barrier,id=$id,name=$name ...

Where $name is the name declared in the screens section of barrier.conf

The barrier server (barriers) must be configured and must run on the
local host.

For instance:

  section: screens
      localhost:
          ...
      VM-1:
          ...
      end

  section: links
      localhost:
          right = VM-1
      VM-1:
          left = localhost
  end

Then on the QEMU command line:

    ... -object input-barrier,id=barrie0,name=VM-1 ...

When the mouse will move out of the screen of the local host on
the right, the mouse and the keyboard will be grabbed and all
related events will be send to the guest OS.

This is usefull when qemu is configured without emulated graphic card
but with a VFIO attached graphic card.

More information about Barrier can be found at:

  https://github.com/debauchee/barrier



This avoids to install the Barrier server in the guest OS,
for instance when it is not supported or during the installation.

Signed-off-by: default avatarLaurent Vivier <laurent@vivier.eu>
Message-id: 20190906083812.29487-1-laurent@vivier.eu
Signed-off-by: default avatarGerd Hoffmann <kraxel@redhat.com>
parent e1b3d477

docs/barrier.txt

0 → 100644
+370 −0
Original line number Diff line number Diff line 
                                QEMU Barrier Client





* About



    Barrier is a KVM (Keyboard-Video-Mouse) software forked from Symless's

    synergy 1.9 codebase.



    See https://github.com/debauchee/barrier



* QEMU usage



    Generally, mouse and keyboard are grabbed through the QEMU video

    interface emulation.



    But when we want to use a video graphic adapter via a PCI passthrough

    there is no way to provide the keyboard and mouse inputs to the VM

    except by plugging a second set of mouse and keyboard to the host

    or by installing a KVM software in the guest OS.



    The QEMU Barrier client avoids this by implementing directly the Barrier

    protocol into QEMU.



    This protocol is enabled by adding an input-barrier object to QEMU.



    Syntax: input-barrier,id=<object-id>,name=<guest display name>

            [,server=<barrier server address>][,port=<barrier server port>]

            [,x-origin=<x-origin>][,y-origin=<y-origin>]

            [,width=<width>][,height=<height>]



    The object can be added on the QEMU command line, for instance with:



        ... -object input-barrier,id=barrier0,name=VM-1 ...



    where VM-1 is the name the display configured int the Barrier server

    on the host providing the mouse and the keyboard events.



    by default <barrier server address> is "localhost", port is 24800,

    <x-origin> and <y-origin> are set to 0, <width> and <height> to

    1920 and 1080.



    If Barrier server is stopped QEMU needs to be reconnected manually,

    by removing and re-adding the input-barrier object, for instance

    with the help of the HMP monitor:



        (qemu) object_del barrier0

        (qemu) object_add input-barrier,id=barrier0,name=VM-1



* Message format



    Message format between the server and client is in two parts:



        1- the payload length is a 32bit integer in network endianness,

        2- the payload



    The payload starts with a 4byte string (without NUL) which is the

    command. The first command between the server and the client

    is the only command not encoded on 4 bytes ("Barrier").

    The remaining part of the payload is decoded according to the command.



* Protocol Description (from barrier/src/lib/barrier/protocol_types.h)



    - barrierCmdHello          "Barrier"



      Direction:  server -> client

      Parameters: { int16_t minor, int16_t major }

      Description:



          Say hello to client

          minor = protocol major version number supported by server

          major = protocol minor version number supported by server



    - barrierCmdHelloBack      "Barrier"



      Direction:  client ->server

      Parameters: { int16_t minor, int16_t major, char *name}

      Description:



          Respond to hello from server

          minor = protocol major version number supported by client

          major = protocol minor version number supported by client

          name  = client name



    - barrierCmdDInfo          "DINF"



      Direction:  client ->server

      Parameters: { int16_t x_origin, int16_t y_origin, int16_t width, int16_t height, int16_t x, int16_t y}

      Description:



          The client screen must send this message in response to the

          barrierCmdQInfo message.  It must also send this message when the

          screen's resolution changes.  In this case, the client screen should

          ignore any barrierCmdDMouseMove messages until it receives a

          barrierCmdCInfoAck in order to prevent attempts to move the mouse off

          the new screen area.



    - barrierCmdCNoop          "CNOP"



      Direction:  client -> server

      Parameters: None

      Description:



          No operation



    - barrierCmdCClose         "CBYE"



      Direction:  server -> client

      Parameters: None

      Description:



          Close connection



    - barrierCmdCEnter         "CINN"



      Direction:  server -> client

      Parameters: { int16_t x, int16_t y, int32_t seq, int16_t modifier }

      Description:



          Enter screen.

          x,y      = entering screen absolute coordinates

          seq      = sequence number, which is used to order messages between

                     screens.  the secondary screen must return this number

                     with some messages

          modifier = modifier key mask.  this will have bits set for each

                     toggle modifier key that is activated on entry to the

                     screen.  the secondary screen should adjust its toggle

                     modifiers to reflect that state.



    - barrierCmdCLeave         "COUT"



      Direction:  server -> client

      Parameters: None

      Description:



          Leaving screen.  the secondary screen should send clipboard data in

          response to this message for those clipboards that it has grabbed

          (i.e. has sent a barrierCmdCClipboard for and has not received a

          barrierCmdCClipboard for with a greater sequence number) and that

          were grabbed or have changed since the last leave.



    - barrierCmdCClipboard     "CCLP"



      Direction:  server -> client

      Parameters: { int8_t id, int32_t seq }

      Description:



          Grab clipboard. Sent by screen when some other app on that screen

          grabs a clipboard.

          id  = the clipboard identifier

          seq = sequence number. Client must use the sequence number passed in

                the most recent barrierCmdCEnter.  the server always sends 0.



    - barrierCmdCScreenSaver   "CSEC"



      Direction:  server -> client

      Parameters: { int8_t started }

      Description:



          Screensaver change.

          started = Screensaver on primary has started (1) or closed (0)



    - barrierCmdCResetOptions  "CROP"



      Direction:  server -> client

      Parameters: None

      Description:



          Reset options. Client should reset all of its options to their

          defaults.



    - barrierCmdCInfoAck       "CIAK"



      Direction:  server -> client

      Parameters: None

      Description:



          Resolution change acknowledgment. Sent by server in response to a

          client screen's barrierCmdDInfo. This is sent for every

          barrierCmdDInfo, whether or not the server had sent a barrierCmdQInfo.



    - barrierCmdCKeepAlive     "CALV"



      Direction:  server -> client

      Parameters: None

      Description:



          Keep connection alive. Sent by the server periodically to verify

          that connections are still up and running.  clients must reply in

          kind on receipt.  if the server gets an error sending the message or

          does not receive a reply within a reasonable time then the server

          disconnects the client.  if the client doesn't receive these (or any

          message) periodically then it should disconnect from the server.  the

          appropriate interval is defined by an option.



    - barrierCmdDKeyDown       "DKDN"



      Direction:  server -> client

      Parameters: { int16_t keyid, int16_t modifier [,int16_t button] }

      Description:



          Key pressed.

          keyid    = X11 key id

          modified = modified mask

          button   = X11 Xkb keycode (optional)



    - barrierCmdDKeyRepeat     "DKRP"



      Direction:  server -> client

      Parameters: { int16_t keyid, int16_t modifier, int16_t repeat [,int16_t button] }

      Description:



          Key auto-repeat.

          keyid    = X11 key id

          modified = modified mask

          repeat   = number of repeats

          button   = X11 Xkb keycode (optional)



    - barrierCmdDKeyUp         "DKUP"



      Direction:  server -> client

      Parameters: { int16_t keyid, int16_t modifier [,int16_t button] }

      Description:



          Key released.

          keyid    = X11 key id

          modified = modified mask

          button   = X11 Xkb keycode (optional)



    - barrierCmdDMouseDown     "DMDN"



      Direction:  server -> client

      Parameters: { int8_t button }

      Description:



          Mouse button pressed.

          button = button id



    - barrierCmdDMouseUp       "DMUP"



      Direction:  server -> client

      Parameters: { int8_t button }

      Description:



          Mouse button release.

          button = button id



    - barrierCmdDMouseMove     "DMMV"



      Direction:  server -> client

      Parameters: { int16_t x, int16_t y }

      Description:



          Absolute mouse moved.

          x,y = absolute screen coordinates



    - barrierCmdDMouseRelMove  "DMRM"



      Direction:  server -> client

      Parameters: { int16_t x, int16_t y }

      Description:



          Relative mouse moved.

          x,y = r relative screen coordinates



    - barrierCmdDMouseWheel    "DMWM"



      Direction:  server -> client

      Parameters: { int16_t x , int16_t y } or { int16_t y }

      Description:



          Mouse scroll. The delta should be +120 for one tick forward (away

          from the user) or right and -120 for one tick backward (toward the

          user) or left.

          x = x delta

          y = y delta



    - barrierCmdDClipboard     "DCLP"



      Direction:  server -> client

      Parameters: { int8_t id, int32_t seq, int8_t mark, char *data }

      Description:



          Clipboard data.

          id  = clipboard id

          seq = sequence number. The sequence number is 0 when sent by the

                server.  Client screens should use the/ sequence number from

                the most recent barrierCmdCEnter.



    - barrierCmdDSetOptions    "DSOP"



      Direction:  server -> client

      Parameters: { int32 t nb, { int32_t id, int32_t val }[] }

      Description:



          Set options. Client should set the given option/value pairs.

          nb  = numbers of { id, val } entries

          id  = option id

          val = option new value



    - barrierCmdDFileTransfer  "DFTR"



      Direction:  server -> client

      Parameters: { int8_t mark, char *content }

      Description:



          Transfer file data.

          mark = 0 means the content followed is the file size

                 1 means the content followed is the chunk data

                 2 means the file transfer is finished



    - barrierCmdDDragInfo      "DDRG" int16_t char *



      Direction:  server -> client

      Parameters: { int16_t nb, char *content }

      Description:



          Drag information.

          nb      = number of dragging objects

          content = object's directory



    - barrierCmdQInfo          "QINF"



      Direction:  server -> client

      Parameters: None

      Description:



          Query screen info

          Client should reply with a barrierCmdDInfo



    - barrierCmdEIncompatible  "EICV"



      Direction:  server -> client

      Parameters: { int16_t nb, major *minor }

      Description:



          Incompatible version.

          major = major version

          minor = minor version



    - barrierCmdEBusy          "EBSY"



      Direction:  server -> client

      Parameters: None

      Description:



          Name provided when connecting is already in use.



    - barrierCmdEUnknown       "EUNK"



      Direction:  server -> client

      Parameters: None

      Description:



          Unknown client. Name provided when connecting is not in primary's

           screen configuration map.



    - barrierCmdEBad           "EBAD"



      Direction:  server -> client

      Parameters: None

      Description:



          Protocol violation. Server should disconnect after sending this

          message.



* TO DO



    - Enable SSL

    - Manage SetOptions/ResetOptions commands

ui/Makefile.objs

+1 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ vnc-obj-y += vnc-jobs.o 


common-obj-y += keymaps.o console.o cursor.o qemu-pixman.o

common-obj-y += input.o input-keymap.o input-legacy.o kbd-state.o

common-obj-y += input-barrier.o

common-obj-$(CONFIG_LINUX) += input-linux.o

common-obj-$(CONFIG_SPICE) += spice-core.o spice-input.o spice-display.o

common-obj-$(CONFIG_COCOA) += cocoa.o

ui/input-barrier.c

0 → 100644
+750 −0

File added.

Preview size limit exceeded, changes collapsed.

ui/input-barrier.h

0 → 100644
+112 −0
Original line number Diff line number Diff line 
/*

 * SPDX-License-Identifier: GPL-2.0-or-later

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 */



#ifndef UI_INPUT_BARRIER_H

#define UI_INPUT_BARRIER_H



/* Barrier protocol */

#define BARRIER_VERSION_MAJOR 1

#define BARRIER_VERSION_MINOR 6



enum barrierCmd {

    barrierCmdCNoop,

    barrierCmdCClose,

    barrierCmdCEnter,

    barrierCmdCLeave,

    barrierCmdCClipboard,

    barrierCmdCScreenSaver,

    barrierCmdCResetOptions,

    barrierCmdCInfoAck,

    barrierCmdCKeepAlive,

    barrierCmdDKeyDown,

    barrierCmdDKeyRepeat,

    barrierCmdDKeyUp,

    barrierCmdDMouseDown,

    barrierCmdDMouseUp,

    barrierCmdDMouseMove,

    barrierCmdDMouseRelMove,

    barrierCmdDMouseWheel,

    barrierCmdDClipboard,

    barrierCmdDInfo,

    barrierCmdDSetOptions,

    barrierCmdDFileTransfer,

    barrierCmdDDragInfo,

    barrierCmdQInfo,

    barrierCmdEIncompatible,

    barrierCmdEBusy,

    barrierCmdEUnknown,

    barrierCmdEBad,

    /* connection sequence */

    barrierCmdHello,

    barrierCmdHelloBack,

};



enum {

   barrierButtonNone,

   barrierButtonLeft,

   barrierButtonMiddle,

   barrierButtonRight,

   barrierButtonExtra0

};



struct barrierVersion {

    int16_t major;

    int16_t minor;

};



struct barrierMouseButton {

    int8_t buttonid;

};



struct barrierEnter {

    int16_t x;

    int16_t y;

    int32_t seqn;

    int16_t modifier;

};



struct barrierMousePos {

    int16_t x;

    int16_t y;

};



struct barrierKey {

    int16_t keyid;

    int16_t modifier;

    int16_t button;

};



struct barrierRepeat {

    int16_t keyid;

    int16_t modifier;

    int16_t repeat;

    int16_t button;

};



#define BARRIER_MAX_OPTIONS 32

struct barrierSet {

    int nb;

    struct {

        int id;

        char nul;

        int value;

    } option[BARRIER_MAX_OPTIONS];

};



struct barrierMsg {

    enum barrierCmd cmd;

    union {

        struct barrierVersion version;

        struct barrierMouseButton mousebutton;

        struct barrierMousePos mousepos;

        struct barrierEnter enter;

        struct barrierKey key;

        struct barrierRepeat repeat;

        struct barrierSet set;

    };

};

#endif