endif

INTROSPECTION_GIRS =

INTROSPECTION_COMPILER_ARGS = --includedir=$(builddir)

if HAVE_INTROSPECTION

SpiceClientGLib-2.0.gir: libspice-client-glib-2.0.la

SpiceClientGLib_2_0_gir_INCLUDES = GObject-2.0

/* coroutine context */

G_GNUC_INTERNAL

{

SpiceMsgSetAck* ack = spice_msg_in_parsed(in);

SpiceMsgcAckSync sync = {

.generation = ack->generation,

};

/* coroutine context */

G_GNUC_INTERNAL

{

SpiceMsgPing *ping = spice_msg_in_parsed(in);

c->marshallers->msgc_pong(pong->marshaller, ping);

spice_msg_out_send_internal(pong);

/* coroutine context */

G_GNUC_INTERNAL

{

static const char* severity_strings[] = {"info", "warn", "error"};

static const char* visibility_strings[] = {"!", "!!", "!!!"};

/* coroutine context */

G_GNUC_INTERNAL

{

SpiceMsgDisconnect *disconnect = spice_msg_in_parsed(in);

/* coroutine context */

G_GNUC_INTERNAL

{

SpiceMsgWaitForChannels *wfc = spice_msg_in_parsed(in); */

SPICE_DEBUG("%s TODO", __FUNCTION__);

}

static void

{

g_return_if_fail(msg != NULL);

g_return_if_fail(*msg == NULL);

/* coroutine context */

G_GNUC_INTERNAL

{

SpiceMsgMigrate *mig = spice_msg_in_parsed(in);

SPICE_DEBUG("%s: channel %s flags %u", __FUNCTION__, c->name, mig->flags);

if (mig->flags & SPICE_MIGRATE_NEED_FLUSH) {

*/

#define SPICE_CURSOR_CHANNEL_GET_PRIVATE(obj) \

typedef struct display_cursor display_cursor;

guint32 data[];

};

display_cache cursors;

gboolean init_done;

};

static guint signals[SPICE_CURSOR_LAST_SIGNAL];

static void delete_cursor_all(SpiceChannel *channel);

static display_cursor * display_cursor_ref(display_cursor *cursor);

static void display_cursor_unref(display_cursor *cursor);

static void spice_cursor_channel_init(SpiceCursorChannel *channel)

{

c = channel->priv = SPICE_CURSOR_CHANNEL_GET_PRIVATE(channel);

memset(c, 0, sizeof(*c));

G_TYPE_NONE,

0);

}

/* signal trampoline---------------------------------------------------------- */

static display_cursor *set_cursor(SpiceChannel *channel, SpiceCursor *scursor)

{

SpiceCursorHeader *hdr = &scursor->header;

display_cache_item *item;

display_cursor *cursor;

static void delete_cursor_one(SpiceChannel *channel, display_cache_item *item)

{

display_cursor_unref((display_cursor*)item->ptr);

cache_del(&c->cursors, item);

static void delete_cursor_all(SpiceChannel *channel)

{

display_cache_item *item;

for (;;) {

}

/* coroutine context */

{

SpiceMsgCursorInit *init = spice_msg_in_parsed(in);

display_cursor *cursor;

g_return_if_fail(c->init_done == FALSE);

}

/* coroutine context */

{

SPICE_DEBUG("%s, init_done: %d", __FUNCTION__, c->init_done);

}

/* coroutine context */

{

SpiceMsgCursorSet *set = spice_msg_in_parsed(in);

display_cursor *cursor;

g_return_if_fail(c->init_done == TRUE);

}

/* coroutine context */

{

SpiceMsgCursorMove *move = spice_msg_in_parsed(in);

g_return_if_fail(c->init_done == TRUE);

}

/* coroutine context */

{

#ifdef EXTRA_CHECKS

g_return_if_fail(c->init_done == TRUE);

#endif

}

/* coroutine context */

{

g_return_if_fail(c->init_done == TRUE);

}

/* coroutine context */

{

SpiceMsgDisplayInvalOne *zap = spice_msg_in_parsed(in);

display_cache_item *item;

}

/* coroutine context */

{

delete_cursor_all(channel);

}

};

/* coroutine context */

{

int type = spice_msg_in_type(msg);

SpiceChannelClass *parent_class;

typedef struct _SpiceCursorChannel SpiceCursorChannel;

typedef struct _SpiceCursorChannelClass SpiceCursorChannelClass;

struct _SpiceCursorChannel {

SpiceChannel parent;

/* Do not add fields to this struct */

};

} display_surface;

typedef struct display_stream {

/* from messages */

display_surface *surface;

*/

#define SPICE_DISPLAY_CHANNEL_GET_PRIVATE(obj) \

Ring surfaces;

display_cache *images;

display_cache *palettes;

static guint signals[SPICE_DISPLAY_LAST_SIGNAL];

static void spice_display_channel_init(SpiceDisplayChannel *channel);

static void spice_display_channel_up(SpiceChannel *channel);

static void clear_surfaces(SpiceChannel *channel);

static void clear_streams(SpiceChannel *channel);

static gboolean display_stream_render(display_stream *st);

/* ------------------------------------------------------------------ */

static void spice_display_channel_dispose(GObject *object)

{

if (c->mark_false_event_id != 0) {

g_source_remove(c->mark_false_event_id);

static void spice_display_channel_constructed(GObject *object)

{

SpiceSession *s = spice_channel_get_session(SPICE_CHANNEL(object));

g_return_if_fail(s != NULL);

GValue *value,

GParamSpec *pspec)

{

switch (prop_id) {

case PROP_WIDTH: {

1,

G_TYPE_INT);

sw_canvas_init();

quic_init();

static void image_put(SpiceImageCache *cache, uint64_t id, pixman_image_t *image)

{

display_cache_item *item;

item = cache_find(c->images, id);

static pixman_image_t *image_get(SpiceImageCache *cache, uint64_t id)

{

display_cache_item *item;

item = cache_find(c->images, id);

static void image_remove(SpiceImageCache *cache, uint64_t id)

{

display_cache_item *item;

item = cache_find(c->images, id);

static void palette_put(SpicePaletteCache *cache, SpicePalette *palette)

{

display_cache_item *item;

item = cache_add(c->palettes, palette->unique);

static SpicePalette *palette_get(SpicePaletteCache *cache, uint64_t id)

{

display_cache_item *item;

item = cache_find(c->palettes, id);

static void palette_remove(SpicePaletteCache *cache, uint32_t id)

{

display_cache_item *item;

item = cache_find(c->palettes, id);

static void image_put_lossy(SpiceImageCache *cache, uint64_t id,

pixman_image_t *surface)

{

display_cache_item *item;

#ifndef NDEBUG

static void image_replace_lossy(SpiceImageCache *cache, uint64_t id,

pixman_image_t *surface)

{

display_cache_item *item;

item = cache_find(c->images, id);

static pixman_image_t* image_get_lossless(SpiceImageCache *cache, uint64_t id)

{

display_cache_item *item;

item = cache_find(c->images, id);

SpiceCanvas *surfaces_get(SpiceImageSurfaces *surfaces,

uint32_t surface_id)

{

display_surface *s =

find_surface(c, surface_id);

static void spice_display_channel_init(SpiceDisplayChannel *channel)

{

c = channel->priv = SPICE_DISPLAY_CHANNEL_GET_PRIVATE(channel);

memset(c, 0, sizeof(*c));

static int create_canvas(SpiceChannel *channel, display_surface *surface)

{

if (surface->primary) {

SPICE_DEBUG("display: create primary canvas");

surface->canvas = NULL;

}

{

display_surface *surface;

RingItem *item;

static void clear_surfaces(SpiceChannel *channel)

{

display_surface *surface;

RingItem *item;

/* coroutine context */

static void spice_display_channel_up(SpiceChannel *channel)

{

SpiceMsgcDisplayInit init = {

.pixmap_cache_id = 1,

.pixmap_cache_size = DISPLAY_PIXMAP_CACHE,

}

/* coroutine context */

{

SpiceMsgDisplayMode *mode = spice_msg_in_parsed(in);

display_surface *surface = find_surface(c, 0);

}

/* coroutine context */

{

display_surface *surface = find_surface(c, 0);

SPICE_DEBUG("%s", __FUNCTION__);

}

/* coroutine context */

{

display_surface *surface = find_surface(c, 0);

SPICE_DEBUG("%s: TODO detach_from_screen", __FUNCTION__);

}

/* coroutine context */

{

SpiceMsgDisplayCopyBits *op = spice_msg_in_parsed(in);

display_surface *surface = find_surface(c, op->base.surface_id);

g_return_if_fail(surface != NULL);

}

/* coroutine context */

{

SpiceResourceList *list = spice_msg_in_parsed(in);

int i;

}

/* coroutine context */

{

spice_session_images_clear(spice_channel_get_session(channel));

}

/* coroutine context */

{

SpiceMsgDisplayInvalOne* op = spice_msg_in_parsed(in);

palette_remove(&c->palette_cache, op->id);

}

/* coroutine context */

{

spice_session_palettes_clear(spice_channel_get_session(channel));

}

}

/* coroutine context */

{

SpiceMsgDisplayStreamCreate *op = spice_msg_in_parsed(in);

display_stream *st;

{

guint32 time, d;

SpiceMsgDisplayStreamData *op;

if (st->timeout)

return TRUE;

/* main context */

static gboolean display_stream_render(display_stream *st)

{

st->timeout = 0;

do {

}

/* coroutine context */

{

SpiceMsgDisplayStreamData *op = spice_msg_in_parsed(in);

display_stream *st = c->streams[op->id];

guint32 mmtime;

}

/* coroutine context */

{

SpiceMsgDisplayStreamClip *op = spice_msg_in_parsed(in);

display_stream *st = c->streams[op->id];

static void destroy_stream(SpiceChannel *channel, int id)

{

display_stream *st;

g_return_if_fail(c != NULL);

static void clear_streams(SpiceChannel *channel)

{

int i;

for (i = 0; i < c->nstreams; i++) {

}

/* coroutine context */

{

SpiceMsgDisplayStreamDestroy *op = spice_msg_in_parsed(in);

}

/* coroutine context */

{

clear_streams(channel);

}

/* ------------------------------------------------------------------ */

/* coroutine context */

{

SpiceMsgDisplayDrawFill *op = spice_msg_in_parsed(in);

DRAW(fill);

}

/* coroutine context */

{

SpiceMsgDisplayDrawOpaque *op = spice_msg_in_parsed(in);

DRAW(opaque);

}

/* coroutine context */

{

SpiceMsgDisplayDrawCopy *op = spice_msg_in_parsed(in);

DRAW(copy);

}

/* coroutine context */

{

SpiceMsgDisplayDrawBlend *op = spice_msg_in_parsed(in);

DRAW(blend);

}

/* coroutine context */

{

SpiceMsgDisplayDrawBlackness *op = spice_msg_in_parsed(in);

DRAW(blackness);

}

{

SpiceMsgDisplayDrawWhiteness *op = spice_msg_in_parsed(in);

DRAW(whiteness);

}

/* coroutine context */

{

SpiceMsgDisplayDrawInvers *op = spice_msg_in_parsed(in);

DRAW(invers);

}

/* coroutine context */

{

SpiceMsgDisplayDrawRop3 *op = spice_msg_in_parsed(in);

DRAW(rop3);

}

/* coroutine context */

{

SpiceMsgDisplayDrawStroke *op = spice_msg_in_parsed(in);

DRAW(stroke);

}

/* coroutine context */

{

SpiceMsgDisplayDrawText *op = spice_msg_in_parsed(in);

DRAW(text);

}

/* coroutine context */

{

SpiceMsgDisplayDrawTransparent *op = spice_msg_in_parsed(in);

DRAW(transparent);

}

/* coroutine context */

{

SpiceMsgDisplayDrawAlphaBlend *op = spice_msg_in_parsed(in);

DRAW(alpha_blend);

}

/* coroutine context */

{

SpiceMsgSurfaceCreate *create = spice_msg_in_parsed(in);

display_surface *surface = spice_new0(display_surface, 1);

static gboolean display_mark_false(gpointer data)

{

SpiceChannel *channel = data;

c->mark = FALSE;

g_signal_emit(channel, signals[SPICE_DISPLAY_MARK], 0, FALSE);

}

/* coroutine context */

{

SpiceMsgSurfaceDestroy *destroy = spice_msg_in_parsed(in);

display_surface *surface;

g_return_if_fail(destroy != NULL);

};

/* coroutine context */

{

int type = spice_msg_in_type(msg);

SpiceChannelClass *parent_class;

typedef struct _SpiceDisplayChannel SpiceDisplayChannel;

typedef struct _SpiceDisplayChannelClass SpiceDisplayChannelClass;

struct _SpiceDisplayChannel {

SpiceChannel parent;

/* Do not add fields to this struct */

};

*/

#define SPICE_INPUTS_CHANNEL_GET_PRIVATE(obj) \

int bs;

int dx, dy;

unsigned int x, y, dpy;

static guint signals[SPICE_INPUTS_LAST_SIGNAL];

static void spice_inputs_channel_up(SpiceChannel *channel);

/* ------------------------------------------------------------------ */

static void spice_inputs_channel_init(SpiceInputsChannel *channel)

{

c = channel->priv = SPICE_INPUTS_CHANNEL_GET_PRIVATE(channel);

memset(c, 0, sizeof(*c));

GValue *value,

GParamSpec *pspec)

{

switch (prop_id) {

case PROP_KEY_MODIFIERS:

G_TYPE_NONE,

0);

}

/* signal trampoline---------------------------------------------------------- */

/* ------------------------------------------------------------------ */

{

SpiceMsgcMouseMotion motion;

if (!c->dx && !c->dy)

return NULL;

return msg;

}

{

SpiceMsgcMousePosition position;

if (c->dpy == -1)

return NULL;

/* main context */

static void send_position(SpiceInputsChannel *channel)

{

msg = mouse_position(channel);

if (!msg) /* if no motion */

/* main context */

static void send_motion(SpiceInputsChannel *channel)

{

msg = mouse_motion(channel);

if (!msg) /* if no motion */

}

/* coroutine context */

{

SpiceMsgInputsInit *init = spice_msg_in_parsed(in);

c->modifiers = init->keyboard_modifiers;

}

/* coroutine context */

{

SpiceMsgInputsKeyModifiers *modifiers = spice_msg_in_parsed(in);

c->modifiers = modifiers->modifiers;

}

/* coroutine context */

{

c->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH;

};

/* coroutine context */

{

int type = spice_msg_in_type(msg);

SpiceChannelClass *parent_class;

void spice_inputs_motion(SpiceInputsChannel *channel, gint dx, gint dy,

gint button_state)

{

g_return_if_fail(channel != NULL);

g_return_if_fail(SPICE_CHANNEL(channel)->priv->state != SPICE_CHANNEL_STATE_UNCONNECTED);

void spice_inputs_position(SpiceInputsChannel *channel, gint x, gint y,

gint display, gint button_state)

{

g_return_if_fail(channel != NULL);

void spice_inputs_button_press(SpiceInputsChannel *channel, gint button,

gint button_state)

{

SpiceMsgcMousePress press;

g_return_if_fail(channel != NULL);

void spice_inputs_button_release(SpiceInputsChannel *channel, gint button,

gint button_state)

{

SpiceMsgcMouseRelease release;

g_return_if_fail(channel != NULL);

void spice_inputs_key_press(SpiceInputsChannel *channel, guint scancode)

{

SpiceMsgcKeyDown down;

g_return_if_fail(channel != NULL);

g_return_if_fail(SPICE_CHANNEL(channel)->priv->state != SPICE_CHANNEL_STATE_UNCONNECTED);

void spice_inputs_key_release(SpiceInputsChannel *channel, guint scancode)

{

SpiceMsgcKeyUp up;

g_return_if_fail(channel != NULL);

g_return_if_fail(SPICE_CHANNEL(channel)->priv->state != SPICE_CHANNEL_STATE_UNCONNECTED);

}

/* main or coroutine context */

{

SpiceMsgcKeyModifiers modifiers;

g_return_val_if_fail(SPICE_IS_INPUTS_CHANNEL(channel), NULL);

**/

void spice_inputs_set_key_locks(SpiceInputsChannel *channel, guint locks)

{

msg = set_key_locks(channel, locks);

if (!msg) /* you can set_key_locks() even if the channel is not ready */

/* coroutine context */

static void spice_inputs_channel_up(SpiceChannel *channel)

{

msg = set_key_locks(SPICE_INPUTS_CHANNEL(channel), c->locks);

spice_msg_out_send_internal(msg);

typedef struct _SpiceInputsChannel SpiceInputsChannel;

typedef struct _SpiceInputsChannelClass SpiceInputsChannelClass;

typedef enum {

SPICE_INPUTS_SCROLL_LOCK = (1 << 0),

struct _SpiceInputsChannel {

SpiceChannel parent;

/* Do not add fields to this struct */

};

gint button_state);

void spice_inputs_button_release(SpiceInputsChannel *channel, gint button,

gint button_state);

void spice_inputs_set_key_locks(SpiceInputsChannel *channel, guint locks);

G_END_DECLS

*/

#define SPICE_MAIN_CHANNEL_GET_PRIVATE(obj) \

#define MAX_DISPLAY 16

enum SpiceMouseMode mouse_mode;

bool agent_connected;

bool agent_caps_received;

static guint signals[SPICE_MAIN_LAST_SIGNAL];

static void agent_send_msg_queue(SpiceMainChannel *channel);

static void migrate_channel_event_cb(SpiceChannel *channel, SpiceChannelEvent event,

gpointer data);

static void spice_main_channel_init(SpiceMainChannel *channel)

{

c = channel->priv = SPICE_MAIN_CHANNEL_GET_PRIVATE(channel);

memset(c, 0, sizeof(*c));

GValue *value,

GParamSpec *pspec)

{

switch (prop_id) {

case PROP_MOUSE_MODE:

static void spice_main_set_property(GObject *gobject, guint prop_id,

const GValue *value, GParamSpec *pspec)

{

switch (prop_id) {

case PROP_DISPLAY_DISABLE_WALLPAPER:

static void spice_main_channel_dispose(GObject *obj)

{

if (c->timer_id) {

g_source_remove(c->timer_id);

static void spice_main_channel_finalize(GObject *obj)

{

g_free(c->agent_msg_data);

g_queue_free(c->agent_msg_queue);

G_TYPE_OBJECT);

}

/* signal trampoline---------------------------------------------------------- */

/* coroutine context */

static void agent_send_msg_queue(SpiceMainChannel *channel)

{

while (c->agent_tokens > 0 &&

!g_queue_is_empty(c->agent_msg_queue)) {

you can wakeup() the channel coroutine or send_msg_queue() */

static void agent_msg_queue(SpiceMainChannel *channel, int type, int size, void *data)

{

VDAgentMessage msg;

void *payload;

guint32 paysize;

you can wakeup() the channel coroutine or send_msg_queue() */

gboolean spice_main_send_monitor_config(SpiceMainChannel *channel)

{

VDAgentMonitorsConfig *mon;

int i, j, monitors;

size_t size;

you can wakeup() the channel coroutine or send_msg_queue() */

static void agent_display_config(SpiceMainChannel *channel)

{

VDAgentDisplayConfig config = { 0, };

if (c->display_disable_wallpaper) {

you can wakeup() the channel coroutine or send_msg_queue() */

static void agent_announce_caps(SpiceMainChannel *channel)

{

VDAgentAnnounceCapabilities *caps;

size_t size;

static void agent_clipboard_grab(SpiceMainChannel *channel, guint selection,

guint32 *types, int ntypes)

{

guint8 *msg;

VDAgentClipboardGrab *grab;

size_t size;

static void agent_clipboard_notify(SpiceMainChannel *channel, guint selection,

guint32 type, const guchar *data, size_t size)

{

VDAgentClipboard *cb;

guint8 *msg;

size_t msgsize;

you can wakeup() the channel coroutine or send_msg_queue() */

static void agent_clipboard_request(SpiceMainChannel *channel, guint selection, guint32 type)

{

VDAgentClipboardRequest *request;

guint8 *msg;

size_t msgsize;

you can wakeup() the channel coroutine or send_msg_queue() */

static void agent_clipboard_release(SpiceMainChannel *channel, guint selection)

{

guint8 msg[4] = { 0, };

guint8 msgsize = 0;

/* coroutine context */

static void agent_start(SpiceMainChannel *channel)

{

SpiceMsgcMainAgentStart agent_start = {

.num_tokens = ~0,

};

c->agent_connected = true;

c->agent_caps_received = false;

/* coroutine context */

static void agent_stopped(SpiceMainChannel *channel)

{

c->agent_connected = false;

c->agent_caps_received = false;

/* coroutine context */

static void set_mouse_mode(SpiceMainChannel *channel, uint32_t supported, uint32_t current)

{

if (c->mouse_mode != current) {

c->mouse_mode = current;

SpiceMsgcMainMouseModeRequest req = {

.mode = SPICE_MOUSE_MODE_CLIENT,

};

out = spice_msg_out_new(SPICE_CHANNEL(channel), SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST);

out->marshallers->msgc_main_mouse_mode_request(out->marshaller, &req);

spice_msg_out_send_internal(out);

}

/* coroutine context */

{

SpiceMsgMainInit *init = spice_msg_in_parsed(in);

SpiceSession *session;

session = spice_channel_get_session(channel);

spice_session_set_connection_id(session, init->session_id);

}

/* coroutine context */

{

SpiceSession *session;

SpiceMsgMainMultiMediaTime *msg = spice_msg_in_parsed(in);

}

/* coroutine context */

{

SpiceMsgChannels *msg = spice_msg_in_parsed(in);

SpiceSession *session;

}

/* coroutine context */

{

SpiceMsgMainMouseMode *msg = spice_msg_in_parsed(in);

set_mouse_mode(SPICE_MAIN_CHANNEL(channel), msg->supported_modes, msg->current_mode);

}

/* coroutine context */

{

agent_start(SPICE_MAIN_CHANNEL(channel));

}

/* coroutine context */

{

agent_stopped(SPICE_MAIN_CHANNEL(channel));

}

static void main_agent_handle_msg(SpiceChannel *channel,

VDAgentMessage *msg, gpointer payload)

{

guint8 selection = VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD;

g_return_if_fail(msg->protocol == VD_AGENT_PROTOCOL);

/* coroutine context */

static void main_handle_agent_data_msg(SpiceChannel* channel, int* msg_size, guchar** msg_pos)

{

int n;

if (c->agent_msg_pos < sizeof(VDAgentMessage)) {

}

/* coroutine context */

{

guint8 *data;

int len;

}

/* coroutine context */

{

SpiceMsgMainAgentTokens *tokens = spice_msg_in_parsed(in);

c->agent_tokens = tokens->num_tokens;

agent_send_msg_queue(SPICE_MAIN_CHANNEL(channel));

gpointer data)

{

spice_migrate *mig = data;

SpiceSession *session;

g_return_if_fail(mig->nchannels > 0);

GList *channels, *l;

l = channels = spice_session_get_channels(session);

while (l != NULL) {

l = l->next;

if (curc->channel_type == SPICE_CHANNEL_MAIN)

continue;

static gboolean migrate_connect(gpointer data)

{

spice_migrate *mig = data;

int port, sport;

const char *host;

SpiceSession *session;

}

/* coroutine context */

{

SpiceMsgMainMigrationBegin *msg = spice_msg_in_parsed(in);

spice_migrate mig = { 0, };

int reply_type;

mig.channel = channel;

{

SpiceChannel *channel = data;

SpiceSession *session;

g_warn_if_fail(c->switch_host_delayed_id != 0);

c->switch_host_delayed_id = 0;

}

/* coroutine context */

{

SpiceMsgMainMigrationSwitchHost *mig = spice_msg_in_parsed(in);

SpiceSession *session;

char *host = (char *)mig->host_data;

char *subject = NULL;

g_return_if_fail(host[mig->host_size - 1] == '\0');

/* coroutine context */

static void main_handle_migrate_cancel(SpiceChannel *channel,

{

SpiceSession *session;

};

/* coroutine context */

{

int type = spice_msg_in_type(msg);

SpiceChannelClass *parent_class;

static gboolean timer_set_display(gpointer data)

{

SpiceChannel *channel = data;

c->timer_id = 0;

if (c->agent_connected)

void spice_main_set_display(SpiceMainChannel *channel, int id,

int x, int y, int width, int height)

{

g_return_if_fail(channel != NULL);

g_return_if_fail(SPICE_IS_MAIN_CHANNEL(channel));

g_return_if_fail(channel != NULL);

g_return_if_fail(SPICE_IS_MAIN_CHANNEL(channel));

if (!c->agent_connected)

return;

/**

* spice_main_set_display_enabled:

* @id: display channel ID

* @enabled: wether display @id is enabled

*

* When sending monitor configuration to agent guest, don't set

* configuration is sent.

*

* Since: 0.6

g_return_if_fail(channel != NULL);

g_return_if_fail(SPICE_IS_MAIN_CHANNEL(channel));

c->display[id].enabled = enabled;

}

typedef struct _SpiceMainChannel SpiceMainChannel;

typedef struct _SpiceMainChannelClass SpiceMainChannelClass;

struct _SpiceMainChannel {

SpiceChannel parent;

/* Do not add fields to this struct */

};

*/

#define SPICE_PLAYBACK_CHANNEL_GET_PRIVATE(obj) \

int mode;

CELTMode *celt_mode;

CELTDecoder *celt_decoder;

static guint signals[SPICE_PLAYBACK_LAST_SIGNAL];

/* ------------------------------------------------------------------ */

static void spice_playback_channel_init(SpicePlaybackChannel *channel)

{

c = channel->priv = SPICE_PLAYBACK_CHANNEL_GET_PRIVATE(channel);

memset(c, 0, sizeof(*c));

static void spice_playback_channel_finalize(GObject *obj)

{

if (c->celt_decoder) {

celt051_decoder_destroy(c->celt_decoder);

GParamSpec *pspec)

{

SpicePlaybackChannel *channel = SPICE_PLAYBACK_CHANNEL(gobject);

switch (prop_id) {

case PROP_VOLUME:

G_TYPE_NONE,

0);

}

/* signal trampoline---------------------------------------------------------- */

/* ------------------------------------------------------------------ */

/* coroutine context */

{

SpiceMsgPlaybackPacket *packet = spice_msg_in_parsed(in);

#ifdef DEBUG

}

/* coroutine context */

{

SpiceMsgPlaybackMode *mode = spice_msg_in_parsed(in);

SPICE_DEBUG("%s: time %d mode %d data %p size %d", __FUNCTION__,

}

/* coroutine context */

{

SpiceMsgPlaybackStart *start = spice_msg_in_parsed(in);

int celt_mode_err;

}

/* coroutine context */

{

emit_main_context(channel, SPICE_PLAYBACK_STOP);

}

/* coroutine context */

{

SpiceMsgAudioVolume *vol = spice_msg_in_parsed(in);

g_free(c->volume);

}

/* coroutine context */

{

SpiceMsgAudioMute *m = spice_msg_in_parsed(in);

c->mute = m->mute;

};

/* coroutine context */

{

int type = spice_msg_in_type(msg);

SpiceChannelClass *parent_class;

void spice_playback_channel_set_delay(SpicePlaybackChannel *channel, guint32 delay_ms)

{

g_return_if_fail(SPICE_IS_PLAYBACK_CHANNEL(channel));

typedef struct _SpicePlaybackChannel SpicePlaybackChannel;

typedef struct _SpicePlaybackChannelClass SpicePlaybackChannelClass;

struct _SpicePlaybackChannel {

SpiceChannel parent;

/* Do not add fields to this struct */

};

*/

#define SPICE_RECORD_CHANNEL_GET_PRIVATE(obj) \

int mode;

gboolean started;

CELTMode *celt_mode;

static guint signals[SPICE_RECORD_LAST_SIGNAL];

static void channel_up(SpiceChannel *channel);

#define FRAME_SIZE 256

static void spice_record_channel_init(SpiceRecordChannel *channel)

{

c = channel->priv = SPICE_RECORD_CHANNEL_GET_PRIVATE(channel);

memset(c, 0, sizeof(*c));

static void spice_record_channel_finalize(GObject *obj)

{

g_free(c->last_frame);

c->last_frame = NULL;

GParamSpec *pspec)

{

SpiceRecordChannel *channel = SPICE_RECORD_CHANNEL(gobject);

switch (prop_id) {

case PROP_VOLUME:

G_TYPE_NONE,

0);

}

/* signal trampoline---------------------------------------------------------- */

uint32_t mode, uint8_t *data, uint32_t data_size)

{

SpiceMsgcRecordMode m = {0, };

g_return_if_fail(channel != NULL);

/* coroutine context */

static void channel_up(SpiceChannel *channel)

{

rc = SPICE_RECORD_CHANNEL(channel)->priv;

if (spice_channel_test_capability(channel, SPICE_RECORD_CAP_CELT_0_5_1)) {

static void spice_record_start_mark(SpiceRecordChannel *channel, uint32_t time)

{

SpiceMsgcRecordStartMark m = {0, };

g_return_if_fail(channel != NULL);

void spice_record_send_data(SpiceRecordChannel *channel, gpointer data,

gsize bytes, uint32_t time)

{

SpiceMsgcRecordPacket p = {0, };

int celt_compressed_frame_bytes = FRAME_SIZE * CELT_BIT_RATE / 44100 / 8;

uint8_t *celt_buf = NULL;

while (bytes > 0) {

gsize n, frame_size;

uint8_t *frame;

if (rc->last_frame_current > 0) {

/* ------------------------------------------------------------------ */

/* coroutine context */

{

SpiceMsgRecordStart *start = spice_msg_in_parsed(in);

SPICE_DEBUG("%s: fmt %d channels %d freq %d", __FUNCTION__,

}

/* coroutine context */

{

emit_main_context(channel, SPICE_RECORD_STOP);

rc->started = FALSE;

}

/* coroutine context */

{

SpiceMsgAudioVolume *vol = spice_msg_in_parsed(in);

g_free(c->volume);

}

/* coroutine context */

{

SpiceMsgAudioMute *m = spice_msg_in_parsed(in);

c->mute = m->mute;

};

/* coroutine context */

{

int type = spice_msg_in_type(msg);

typedef struct _SpiceRecordChannel SpiceRecordChannel;

typedef struct _SpiceRecordChannelClass SpiceRecordChannelClass;

struct _SpiceRecordChannel {

SpiceChannel parent;

/* Do not add fields to this struct */

};

GType spice_record_channel_get_type(void);

void spice_record_send_data(SpiceRecordChannel *channel, gpointer data,

G_END_DECLS

*/

#define SPICE_SMARTCARD_CHANNEL_GET_PRIVATE(obj) \

struct _SpiceSmartcardChannelMessage {

#ifdef USE_SMARTCARD

VSCMsgType message_type;

#endif

};

typedef struct _SpiceSmartcardChannelMessage SpiceSmartcardChannelMessage;

/* track readers that have been added but for which we didn't receive

* an ack from the spice server yet. We rely on the fact that the

* readers in this list are ordered by the time we sent the request to

SPICE_SMARTCARD_LAST_SIGNAL,

};

static void spice_smartcard_channel_up(SpiceChannel *channel);

static void smartcard_message_free(SpiceSmartcardChannelMessage *message);

/* ------------------------------------------------------------------ */

static void spice_smartcard_channel_init(SpiceSmartcardChannel *channel)

{

channel->priv = SPICE_SMARTCARD_CHANNEL_GET_PRIVATE(channel);

priv = channel->priv;

channel_class->handle_msg = spice_smartcard_handle_msg;

channel_class->channel_up = spice_smartcard_channel_up;

}

static const spice_msg_handler smartcard_handlers[] = {

}

static SpiceSmartcardChannelMessage *

{

SpiceSmartcardChannelMessage *message;

static void smartcard_message_send(SpiceSmartcardChannel *channel,

VSCMsgType msg_type,

{

SpiceSmartcardChannelMessage *message;

const uint8_t *data, gsize data_len,

gboolean serialize_msg)

{

VSCMsgHeader header = {

.type = msg_type,

.length = data_len

#endif /* USE_SMARTCARD */

/* coroutine context */

{

int type = spice_msg_in_type(msg);

SpiceChannelClass *parent_class;

g_object_unref(session);

}

{

#ifdef USE_SMARTCARD

SpiceMsgSmartcard *msg = spice_msg_in_parsed(in);

VReader *reader;

typedef struct _SpiceSmartcardChannel SpiceSmartcardChannel;

typedef struct _SpiceSmartcardChannelClass SpiceSmartcardChannelClass;

struct _SpiceSmartcardChannel {

SpiceChannel parent;

/*< private >*/

/* Do not add fields to this struct */

};

G_BEGIN_DECLS

int refcount;

SpiceChannel *channel;

SpiceMessageMarshallers *marshallers;

SpiceDataHeader *header;

};

int refcount;

SpiceChannel *channel;

SpiceDataHeader header;

uint8_t *parsed;

size_t psize;

message_destructor_t pfree;

};

enum spice_channel_state {

SPICE_CHANNEL_STATE_MIGRATING,

};

/* swapped on migration */

SSL_CTX *ctx;

SSL *ssl;

SpiceLinkReply* peer_msg;

int peer_pos;

int message_ack_window;

int message_ack_count;

gsize total_read_bytes;

};

SpiceSubMessage *sub);

void spice_channel_up(SpiceChannel *channel);

void spice_channel_wakeup(SpiceChannel *channel);

SpiceSession* spice_channel_get_session(SpiceChannel *channel);

/* coroutine context */

void spice_channel_recv_msg(SpiceChannel *channel, handler_msg_in handler, gpointer data);

/* channel-base.c */

/* coroutine context */

gint spice_channel_get_channel_id(SpiceChannel *channel);

gint spice_channel_get_channel_type(SpiceChannel *channel);

#include "gio-coroutine.h"

static void spice_channel_send_link(SpiceChannel *channel);

static void channel_disconnect(SpiceChannel *channel);

/* gobject glue */

#define SPICE_CHANNEL_GET_PRIVATE(obj) \

G_DEFINE_TYPE(SpiceChannel, spice_channel, G_TYPE_OBJECT);

static void spice_channel_init(SpiceChannel *channel)

{

c = channel->priv = SPICE_CHANNEL_GET_PRIVATE(channel);

static void spice_channel_constructed(GObject *gobject)

{

SpiceChannel *channel = SPICE_CHANNEL(gobject);

const char *desc = spice_channel_type_to_string(c->channel_type);

snprintf(c->name, sizeof(c->name), "%s-%d:%d",

static void spice_channel_dispose(GObject *gobject)

{

SpiceChannel *channel = SPICE_CHANNEL(gobject);

SPICE_DEBUG("%s: %s %p", c->name, __FUNCTION__, gobject);

static void spice_channel_finalize(GObject *gobject)

{

SpiceChannel *channel = SPICE_CHANNEL(gobject);

SPICE_DEBUG("%s: %s %p", c->name, __FUNCTION__, gobject);

GParamSpec *pspec)

{

SpiceChannel *channel = SPICE_CHANNEL(gobject);

switch (prop_id) {

case PROP_SESSION:

G_GNUC_INTERNAL

gint spice_channel_get_channel_id(SpiceChannel *channel)

{

g_return_val_if_fail(c != NULL, 0);

return c->channel_id;

G_GNUC_INTERNAL

gint spice_channel_get_channel_type(SpiceChannel *channel)

{

g_return_val_if_fail(c != NULL, 0);

return c->channel_type;

GParamSpec *pspec)

{

SpiceChannel *channel = SPICE_CHANNEL(gobject);

switch (prop_id) {

case PROP_SESSION:

1,

G_TYPE_INT);

SSL_library_init();

SSL_load_error_strings();

/* private msg api */

G_GNUC_INTERNAL

{

g_return_val_if_fail(channel != NULL, NULL);

in->refcount = 1;

in->channel = channel;

return in;

}

G_GNUC_INTERNAL

SpiceSubMessage *sub)

{

g_return_val_if_fail(channel != NULL, NULL);

}

G_GNUC_INTERNAL

{

g_return_if_fail(in != NULL);

}

G_GNUC_INTERNAL

{

g_return_if_fail(in != NULL);

}

G_GNUC_INTERNAL

{

g_return_val_if_fail(in != NULL, -1);

}

G_GNUC_INTERNAL

{

g_return_val_if_fail(in != NULL, NULL);

}

G_GNUC_INTERNAL

{

g_return_val_if_fail(in != NULL, NULL);

g_return_val_if_fail(len != NULL, NULL);

}

G_GNUC_INTERNAL

{

fprintf(stderr, "--\n<< hdr: %s serial %" PRIu64 " type %d size %d sub-list %d\n",

c->name, in->header.serial, in->header.type,

}

G_GNUC_INTERNAL

{

fprintf(stderr, "--\n>> hdr: %s serial %" PRIu64 " type %d size %d sub-list %d\n",

c->name, out->header->serial, out->header->type,

}

G_GNUC_INTERNAL

{

g_return_val_if_fail(c != NULL, NULL);

out->refcount = 1;

out->channel = channel;

}

G_GNUC_INTERNAL

{

g_return_if_fail(out != NULL);

}

G_GNUC_INTERNAL

{

g_return_if_fail(out != NULL);

/* system context */

G_GNUC_INTERNAL

{

g_return_if_fail(out != NULL);

/* coroutine context */

G_GNUC_INTERNAL

{

g_return_if_fail(out != NULL);

const void *data,

size_t datalen)

{

const char *ptr = data;

size_t offset = 0;

GIOCondition cond;

*/

static void spice_channel_flush_sasl(SpiceChannel *channel, const void *data, size_t len)

{

const char *output;

unsigned int outputlen;

int err;

static void spice_channel_write(SpiceChannel *channel, const void *data, size_t len)

{

#if HAVE_SASL

if (c->sasl_conn)

spice_channel_flush_sasl(channel, data, len);

/* coroutine context */

static int spice_channel_read_wire(SpiceChannel *channel, void *data, size_t len)

{

int ret;

GIOCondition cond;

*/

static int spice_channel_read_sasl(SpiceChannel *channel, void *data, size_t len)

{

/* SPICE_DEBUG("Read %lu SASL %p size %d offset %d", len, c->sasl_decoded, */

/* c->sasl_decoded_length, c->sasl_decoded_offset); */

/* coroutine context */

static int spice_channel_read(SpiceChannel *channel, void *data, size_t length)

{

gsize len = length;

int ret;

/* coroutine context */

static void spice_channel_send_spice_ticket(SpiceChannel *channel)

{

EVP_PKEY *pubkey;

int nRSASize;

BIO *bioKey;

/* coroutine context */

static void spice_channel_recv_auth(SpiceChannel *channel)

{

uint32_t link_res;

int rc;

G_GNUC_INTERNAL

void spice_channel_up(SpiceChannel *channel)

{

SPICE_DEBUG("%s: channel up, state %d", c->name, c->state);

/* coroutine context */

static void spice_channel_send_link(SpiceChannel *channel)

{

uint8_t *buffer, *p;

int protocol, i;

/* coroutine context */

static void spice_channel_recv_link_hdr(SpiceChannel *channel)

{

int rc;

rc = spice_channel_read(channel, &c->peer_hdr, sizeof(c->peer_hdr));

spice_channel_gather_sasl_credentials(SpiceChannel *channel,

sasl_interact_t *interact)

{

int ninteract;

g_return_val_if_fail(channel != NULL, FALSE);

*/

static gboolean spice_channel_perform_auth_sasl(SpiceChannel *channel)

{

sasl_conn_t *saslconn = NULL;

sasl_security_properties_t secprops;

const char *clientout;

/* coroutine context */

static void spice_channel_recv_link_msg(SpiceChannel *channel)

{

int rc, num_caps, i;

g_return_if_fail(channel != NULL);

/* system context */

static void spice_channel_buffered_write(SpiceChannel *channel, const void *data, size_t size)

{

size_t left;

left = c->xmit_buffer_capacity - c->xmit_buffer_size;

G_GNUC_INTERNAL

void spice_channel_wakeup(SpiceChannel *channel)

{

g_io_wakeup(&c->wait);

}

/* coroutine context if @buffered is FALSE,

system context if @buffered is TRUE */

{

uint8_t *data;

int free_data;

void spice_channel_recv_msg(SpiceChannel *channel,

handler_msg_in msg_handler, gpointer data)

{

int rc;

if (!c->msg_in) {

if (in->header.sub_list) {

SpiceSubMessageList *sub_list;

SpiceSubMessage *sub;

int i;

sub_list = (SpiceSubMessageList *)(in->data + in->header.sub_list);

if (c->message_ack_count) {

c->message_ack_count--;

if (!c->message_ack_count) {

spice_msg_out_send_internal(out);

spice_msg_out_unref(out);

c->message_ack_count = c->message_ack_window;

/**

* spice_channel_new:

* @s: the @SpiceSession the channel is linked to

* @id: the channel-id

*

* Create a new #SpiceChannel of type @type, and channel ID @id.

/* coroutine context */

static void spice_channel_iterate_write(SpiceChannel *channel)

{

if (c->xmit_buffer_size) {

spice_channel_write(channel, c->xmit_buffer, c->xmit_buffer_size);

/* coroutine context */

static void spice_channel_iterate_read(SpiceChannel *channel)

{

/* TODO: get rid of state, and use coroutine state */

switch (c->state) {

/* coroutine context */

static gboolean spice_channel_iterate(SpiceChannel *channel)

{

GIOCondition ret;

do {

static gboolean spice_channel_delayed_unref(gpointer data)

{

SpiceChannel *channel = SPICE_CHANNEL(data);

g_return_val_if_fail(channel != NULL, FALSE);

SPICE_DEBUG("Delayed unref channel %s %p", c->name, channel);

static void *spice_channel_coroutine(void *data)

{

SpiceChannel *channel = SPICE_CHANNEL(data);

guint verify;

SPICE_DEBUG("Started background coroutine %p for %s", &c->coroutine, c->name);

static gboolean connect_delayed(gpointer data)

{

SpiceChannel *channel = data;

struct coroutine *co;

SPICE_DEBUG("Open coroutine starting %p", channel);

static gboolean channel_connect(SpiceChannel *channel)

{

g_return_val_if_fail(c != NULL, FALSE);

gboolean spice_channel_connect(SpiceChannel *channel)

{

g_return_val_if_fail(SPICE_IS_CHANNEL(channel), FALSE);

if (c->state == SPICE_CHANNEL_STATE_CONNECTING)

return TRUE;

**/

gboolean spice_channel_open_fd(SpiceChannel *channel, int fd)

{

g_return_val_if_fail(c != NULL, FALSE);

g_return_val_if_fail(fd >= 0, FALSE);

/* system or coroutine context */

static void channel_disconnect(SpiceChannel *channel)

{

g_return_if_fail(c != NULL);

**/

void spice_channel_disconnect(SpiceChannel *channel, SpiceChannelEvent reason)

{

g_return_if_fail(c != NULL);

**/

gboolean spice_channel_test_capability(SpiceChannel *self, guint32 cap)

{

g_return_val_if_fail(SPICE_IS_CHANNEL(self), FALSE);

**/

gboolean spice_channel_test_common_capability(SpiceChannel *self, guint32 cap)

{

g_return_val_if_fail(SPICE_IS_CHANNEL(self), FALSE);

/* FIXME: we may want to make caps read only from outside */

void spice_channel_set_capability(SpiceChannel *channel, guint32 cap)

{

g_return_if_fail(SPICE_IS_CHANNEL(channel));

G_GNUC_INTERNAL

void spice_channel_set_common_capability(SpiceChannel *channel, guint32 cap)

{

g_return_if_fail(SPICE_IS_CHANNEL(channel));

G_GNUC_INTERNAL

void spice_channel_swap(SpiceChannel *channel, SpiceChannel *swap)

{

g_return_if_fail(c != NULL);

g_return_if_fail(s != NULL);

};

/* coroutine context */

{

int type = spice_msg_in_type(msg);

#define SPICE_IS_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SPICE_TYPE_CHANNEL))

#define SPICE_CHANNEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SPICE_TYPE_CHANNEL, SpiceChannelClass))

/**

* SpiceChannelEvent:

struct _SpiceChannel

{

GObject parent;

/* Do not add fields to this struct */

};

/*< private >*/

/* virtual methods, coroutine context */

void (*channel_up)(SpiceChannel *channel);

void (*iterate_write)(SpiceChannel *channel);

void (*iterate_read)(SpiceChannel *channel);

GType spice_channel_get_type(void);

SpiceChannel *spice_channel_new(SpiceSession *s, int type, int id);

void spice_channel_destroy(SpiceChannel *channel);

gboolean spice_channel_connect(SpiceChannel *channel);

gboolean spice_channel_open_fd(SpiceChannel *channel, int fd);

gboolean spice_channel_test_capability(SpiceChannel *channel, guint32 cap);

gboolean spice_channel_test_common_capability(SpiceChannel *channel, guint32 cap);

void spice_channel_set_capability(SpiceChannel *channel, guint32 cap);

#include "spice-types.h"

#include "spice-session.h"

#include "spice-channel.h"

#include "channel-main.h"

#include "channel-display.h"

/**

* spice_grab_sequence_copy:

*

**/

SpiceGrabSequence *spice_grab_sequence_copy(SpiceGrabSequence *srcSequence)

{

/**

* spice_get_option_group:

*

**/

GOptionGroup* spice_get_option_group(void)

{

RingItem link;

};

char *host;

char *port;

char *tls_port;

/* gobject glue */

#define SPICE_SESSION_GET_PRIVATE(obj) \

G_DEFINE_TYPE (SpiceSession, spice_session, G_TYPE_OBJECT);

static void spice_session_init(SpiceSession *session)

{

SPICE_DEBUG("New session (compiled from package " PACKAGE_STRING ")");

s = session->priv = SPICE_SESSION_GET_PRIVATE(session);

spice_session_dispose(GObject *gobject)

{

SpiceSession *session = SPICE_SESSION(gobject);

SPICE_DEBUG("session dispose");

G_GNUC_INTERNAL

void spice_session_palettes_clear(SpiceSession *session)

{

g_return_if_fail(s != NULL);

for (;;) {

G_GNUC_INTERNAL

void spice_session_images_clear(SpiceSession *session)

{

g_return_if_fail(s != NULL);

for (;;) {

spice_session_finalize(GObject *gobject)

{

SpiceSession *session = SPICE_SESSION(gobject);

/* release stuff */

g_free(s->host);

static int spice_uri_create(SpiceSession *session, char *dest, int len)

{

int pos = 0;

if (s->host == NULL || (s->port == NULL && s->tls_port == NULL)) {

static int spice_uri_parse(SpiceSession *session, const char *original_uri)

{

char host[128], key[32], value[128];

char *port = NULL, *tls_port = NULL, *uri = NULL, *password = NULL;

int len, pos = 0;

GParamSpec *pspec)

{

SpiceSession *session = SPICE_SESSION(gobject);

char buf[256];

int len;

GParamSpec *pspec)

{

SpiceSession *session = SPICE_SESSION(gobject);

const char *str;

switch (prop_id) {

1,

SPICE_TYPE_CHANNEL);

}

/* ------------------------------------------------------------------ */

"host", NULL,

"ca-file", NULL,

NULL));

g_warn_if_fail (c->host == NULL);

g_warn_if_fail (c->tls_port == NULL);

**/

gboolean spice_session_connect(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, FALSE);

**/

gboolean spice_session_open_fd(SpiceSession *session, int fd)

{

g_return_val_if_fail(s != NULL, FALSE);

g_return_val_if_fail(fd >= 0, FALSE);

G_GNUC_INTERNAL

gboolean spice_session_get_client_provided_socket(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, FALSE);

return s->client_provided_sockets;

G_GNUC_INTERNAL

void spice_session_switching_disconnect(SpiceSession *session)

{

struct channel *item;

RingItem *ring, *next;

G_GNUC_INTERNAL

void spice_session_set_migration(SpiceSession *session, SpiceSession *migration)

{

gchar *tmp;

g_return_if_fail(s != NULL);

gint id, gint type)

{

RingItem *ring, *next;

struct channel *c;

g_return_val_if_fail(s != NULL, NULL);

G_GNUC_INTERNAL

void spice_session_abort_migration(SpiceSession *session)

{

RingItem *ring, *next;

struct channel *c;

G_GNUC_INTERNAL

void spice_session_channel_migrate(SpiceSession *session, SpiceChannel *channel)

{

SpiceChannel *c;

gint id, type;

**/

void spice_session_disconnect(SpiceSession *session)

{

struct channel *item;

RingItem *ring, *next;

/**

* spice_session_get_channels:

*

* Get the list of current channels associated with this @session.

*

**/

GList *spice_session_get_channels(SpiceSession *session)

{

struct channel *item;

GList *list = NULL;

RingItem *ring;

G_GNUC_INTERNAL

GSocket* spice_session_channel_open_host(SpiceSession *session, gboolean use_tls)

{

GSocketConnectable *addr;

GSocketAddressEnumerator *enumerator;

GSocketAddress *sockaddr;

G_GNUC_INTERNAL

void spice_session_channel_new(SpiceSession *session, SpiceChannel *channel)

{

struct channel *item;

g_return_if_fail(s != NULL);

G_GNUC_INTERNAL

void spice_session_channel_destroy(SpiceSession *session, SpiceChannel *channel)

{

struct channel *item = NULL;

RingItem *ring, *next;

G_GNUC_INTERNAL

void spice_session_set_connection_id(SpiceSession *session, int id)

{

g_return_if_fail(s != NULL);

G_GNUC_INTERNAL

int spice_session_get_connection_id(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, -1);

G_GNUC_INTERNAL

guint32 spice_session_get_mm_time(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, 0);

G_GNUC_INTERNAL

void spice_session_set_mm_time(SpiceSession *session, guint32 time)

{

g_return_if_fail(s != NULL);

G_GNUC_INTERNAL

void spice_session_get_pubkey(SpiceSession *session, guint8 **pubkey, guint *size)

{

g_return_if_fail(s != NULL);

g_return_if_fail(pubkey != NULL);

G_GNUC_INTERNAL

guint spice_session_get_verify(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, 0);

return s->verify;

G_GNUC_INTERNAL

void spice_session_set_migration_state(SpiceSession *session, SpiceSessionMigration state)

{

g_return_if_fail(s != NULL);

s->migration_state = state;

G_GNUC_INTERNAL

const gchar* spice_session_get_password(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, NULL);

return s->password;

G_GNUC_INTERNAL

const gchar* spice_session_get_host(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, NULL);

return s->host;

G_GNUC_INTERNAL

const gchar* spice_session_get_cert_subject(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, NULL);

return s->cert_subject;

G_GNUC_INTERNAL

const gchar* spice_session_get_ciphers(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, NULL);

return s->ciphers;

G_GNUC_INTERNAL

const gchar* spice_session_get_ca_file(SpiceSession *session)

{

g_return_val_if_fail(s != NULL, NULL);

return s->ca_file;

display_cache **palettes,

SpiceGlzDecoderWindow **glz_window)

{

g_return_if_fail(s != NULL);

struct _SpiceSession

{

GObject parent;

/* Do not add fields to this struct */

};

/* SpiceSession */

typedef struct _SpiceSession SpiceSession;

typedef struct _SpiceSessionClass SpiceSessionClass;

/* SpiceChannel */

typedef struct _SpiceChannel SpiceChannel;

typedef struct _SpiceChannelClass SpiceChannelClass;

G_END_DECLS

G_GNUC_INTERNAL

int spicex_image_create(SpiceDisplay *display)

{

if (d->format == SPICE_SURFACE_FMT_16_555 ||

d->format == SPICE_SURFACE_FMT_16_565) {

G_GNUC_INTERNAL

void spicex_image_destroy(SpiceDisplay *display)

{

if (d->ximage) {

cairo_surface_finish(d->ximage);

G_GNUC_INTERNAL

void spicex_draw_event(SpiceDisplay *display, cairo_t *cr)

{

int fbw = d->width, fbh = d->height;

int mx = 0, my = 0;

int ww, wh;

void spicex_image_invalidate(SpiceDisplay *display,

gint *x, gint *y, gint *w, gint *h)

{

int ww, wh;

gdk_drawable_get_size(gtk_widget_get_window(GTK_WIDGET(display)), &ww, &wh);

G_GNUC_INTERNAL

gboolean spicex_is_scaled(SpiceDisplay *display)

{

return d->allow_scaling;

}

#include <spice/vd_agent.h>

#define SPICE_DISPLAY_GET_PRIVATE(obj) \

#define CLIPBOARD_LAST (VD_AGENT_CLIPBOARD_SELECTION_SECONDARY + 1)

gint channel_id;

/* options */

G_GNUC_INTERNAL

int spicex_image_create(SpiceDisplay *display)

{

GdkDrawable *window = gtk_widget_get_window(GTK_WIDGET(display));

GdkDisplay *gtkdpy = gdk_drawable_get_display(window);

void *old_handler = NULL;

G_GNUC_INTERNAL

void spicex_image_destroy(SpiceDisplay *display)

{

if (d->ximage) {

/* avoid XDestroy to free shared memory, owned and freed by

void spicex_expose_event(SpiceDisplay *display, GdkEventExpose *expose)

{

GdkDrawable *window = gtk_widget_get_window(GTK_WIDGET(display));

if (expose->area.x >= d->mx &&

expose->area.y >= d->my &&

void spicex_image_invalidate (SpiceDisplay *display,

gint *x, gint *y, gint *w, gint *h)

{

/* Offset the Spice region to produce expose region */

*x += d->mx;

*y += d->my;

GParamSpec *pspec)

{

SpiceDisplay *display = SPICE_DISPLAY(object);

switch (prop_id) {

case PROP_KEYBOARD_GRAB:

GParamSpec *pspec)

{

SpiceDisplay *display = SPICE_DISPLAY(object);

switch (prop_id) {

case PROP_KEYBOARD_GRAB:

static void spice_display_dispose(GObject *obj)

{

SpiceDisplay *display = SPICE_DISPLAY(obj);

SPICE_DEBUG("spice display dispose");

static void spice_display_finalize(GObject *obj)

{

SpiceDisplay *display = SPICE_DISPLAY(obj);

int i;

SPICE_DEBUG("Finalize spice display");

static void spice_display_init(SpiceDisplay *display)

{

GtkWidget *widget = GTK_WIDGET(display);

d = display->priv = SPICE_DISPLAY_GET_PRIVATE(display);

memset(d, 0, sizeof(*d));

**/

void spice_display_set_grab_keys(SpiceDisplay *display, SpiceGrabSequence *seq)

{

g_return_if_fail(d != NULL);

if (d->grabseq) {

**/

SpiceGrabSequence *spice_display_get_grab_keys(SpiceDisplay *display)

{

g_return_val_if_fail(d != NULL, NULL);

return d->grabseq;

static void try_keyboard_grab(SpiceDisplay *display)

{

GtkWidget *widget = GTK_WIDGET(display);

time_t now;

GdkGrabStatus status;

static void try_keyboard_ungrab(SpiceDisplay *display)

{

GtkWidget *widget = GTK_WIDGET(display);

if (!d->keyboard_grab_active)

static GdkGrabStatus do_pointer_grab(SpiceDisplay *display)

{

GdkWindow *window = GDK_WINDOW(gtk_widget_get_window(GTK_WIDGET(display)));

GdkGrabStatus status;

static void update_mouse_pointer(SpiceDisplay *display)

{

GdkWindow *window = GDK_WINDOW(gtk_widget_get_window(GTK_WIDGET(display)));

if (!window)

static void try_mouse_grab(GtkWidget *widget)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

if (!d->mouse_grab_enable)

return;

static void mouse_check_edges(GtkWidget *widget, GdkEventMotion *motion)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

GdkScreen *screen = gtk_widget_get_screen(widget);

int x = (int)motion->x_root;

int y = (int)motion->y_root;

static void try_mouse_ungrab(GtkWidget *widget)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

if (!d->mouse_grab_active)

return;

static void recalc_geometry(GtkWidget *widget, gboolean set_display)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

d->mx = 0;

d->my = 0;

static gboolean do_color_convert(SpiceDisplay *display,

gint x, gint y, gint w, gint h)

{

int i, j, maxy, maxx, miny, minx;

guint32 *dest = d->data;

guint16 *src = d->data_origin;

static gboolean draw_event(GtkWidget *widget, cairo_t *cr)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

if (d->mark == 0 || d->data == NULL)

return false;

static gboolean expose_event(GtkWidget *widget, GdkEventExpose *expose)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

if (d->mark == 0 || d->data == NULL)

return false;

static void send_key(SpiceDisplay *display, int scancode, int down)

{

uint32_t i, b, m;

if (!d->inputs)

static void release_keys(SpiceDisplay *display)

{

uint32_t i, b;

SPICE_DEBUG("%s", __FUNCTION__);

static gboolean check_for_grab_key(SpiceDisplay *display, int type, int keyval)

{

int i;

if (!d->grabseq->nkeysyms)

static gboolean key_event(GtkWidget *widget, GdkEventKey *key)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

int scancode;

SPICE_DEBUG("%s %s: keycode: %d state: %d group %d",

static guint get_scancode_from_keyval(SpiceDisplay *display, guint keyval)

{

guint keycode = 0;

GdkKeymapKey *keys = NULL;

gint n_keys = 0;

static gboolean enter_event(GtkWidget *widget, GdkEventCrossing *crossing G_GNUC_UNUSED)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

SPICE_DEBUG("%s", __FUNCTION__);

d->mouse_have_pointer = true;

static gboolean leave_event(GtkWidget *widget, GdkEventCrossing *crossing G_GNUC_UNUSED)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

SPICE_DEBUG("%s", __FUNCTION__);

d->mouse_have_pointer = false;

static gboolean focus_in_event(GtkWidget *widget, GdkEventFocus *focus G_GNUC_UNUSED)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

SPICE_DEBUG("%s", __FUNCTION__);

release_keys(display);

static gboolean focus_out_event(GtkWidget *widget, GdkEventFocus *focus G_GNUC_UNUSED)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

SPICE_DEBUG("%s", __FUNCTION__);

d->keyboard_have_focus = false;

static gboolean motion_event(GtkWidget *widget, GdkEventMotion *motion)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

int ww, wh;

if (!d->inputs)

{

int button;

SpiceDisplay *display = SPICE_DISPLAY(widget);

SPICE_DEBUG("%s", __FUNCTION__);

static gboolean button_event(GtkWidget *widget, GdkEventButton *button)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

SPICE_DEBUG("%s %s: button %d, state 0x%x", __FUNCTION__,

button->type == GDK_BUTTON_PRESS ? "press" : "release",

static gboolean configure_event(GtkWidget *widget, GdkEventConfigure *conf)

{

SpiceDisplay *display = SPICE_DISPLAY(widget);

if (conf->width != d->ww || conf->height != d->wh) {

d->ww = conf->width;

/* ---------------------------------------------------------------- */

{

if (selection == VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD) {

return d->clipboard;

}

}

{

if (cb == d->clipboard) {

return VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD;

gpointer data)

{

SpiceDisplay *display = data;

guint32 types[SPICE_N_ELEMENTS(atom2agent)];

char *name;

int a, m, t;

gpointer data)

{

SpiceDisplay *display = data;

int selection;

selection = get_selection_from_clipboard(d, clipboard);

G_TYPE_NONE,

0);

}

/* ---------------------------------------------------------------- */

static void mouse_update(SpiceChannel *channel, gpointer data)

{

SpiceDisplay *display = data;

g_object_get(channel, "mouse-mode", &d->mouse_mode, NULL);

SPICE_DEBUG("mouse mode %d", d->mouse_mode);

gint shmid, gpointer imgdata, gpointer data)

{

SpiceDisplay *display = data;

gboolean set_display = FALSE;

d->format = format;

static void primary_destroy(SpiceChannel *channel, gpointer data)

{

SpiceDisplay *display = SPICE_DISPLAY(data);

spicex_image_destroy(display);

d->format = 0;

static void mark(SpiceChannel *channel, gint mark, gpointer data)

{

SpiceDisplay *display = data;

SPICE_DEBUG("widget mark: %d, channel %d", mark, d->channel_id);

d->mark = mark;

gpointer rgba, gpointer data)

{

SpiceDisplay *display = data;

if (d->mouse_cursor) {

gdk_cursor_unref(d->mouse_cursor);

static void cursor_hide(SpiceCursorChannel *channel, gpointer data)

{

SpiceDisplay *display = data;

if (d->show_cursor != NULL) /* then we are already hidden */

return;

static void cursor_move(SpiceCursorChannel *channel, gint x, gint y, gpointer data)

{

SpiceDisplay *display = data;

GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(display));

int wx, wy;

static void disconnect_main(SpiceDisplay *display)

{

gint i;

if (d->main == NULL)

static void disconnect_display(SpiceDisplay *display)

{

if (d->display == NULL)

return;

static void disconnect_cursor(SpiceDisplay *display)

{

if (d->cursor == NULL)

return;

guint info, gpointer display)

{

RunInfo ri = { NULL, };

gulong clipboard_handler;

SPICE_DEBUG("clipboard get");

guint32* types, guint32 ntypes, gpointer display)

{

int m, n, i;

GtkTargetEntry targets[SPICE_N_ELEMENTS(atom2agent)];

gboolean target_selected[SPICE_N_ELEMENTS(atom2agent)] = { FALSE, };

gboolean found;

GtkSelectionData *selection_data,

gpointer display)

{

gint len = 0, m;

guint32 type = VD_AGENT_CLIPBOARD_NONE;

gchar* name;

static gboolean clipboard_request(SpiceMainChannel *main, guint selection,

guint type, gpointer display)

{

int m;

GdkAtom atom;

static void clipboard_release(SpiceMainChannel *main, guint selection, gpointer data)

{

GtkClipboard* clipboard = get_clipboard_from_selection(d, selection);

if (!clipboard)

return;

static void channel_new(SpiceSession *s, SpiceChannel *channel, gpointer data)

{

SpiceDisplay *display = data;

int id;

g_object_get(channel, "channel-id", &id, NULL);

static void channel_destroy(SpiceSession *s, SpiceChannel *channel, gpointer data)

{

SpiceDisplay *display = data;

int id;

g_object_get(channel, "channel-id", &id, NULL);

SpiceDisplay *spice_display_new(SpiceSession *session, int id)

{

SpiceDisplay *display;

GList *list;

GList *it;

**/

void spice_display_copy_to_guest(SpiceDisplay *display)

{

int selection = VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD;

if (d->clip_hasdata[selection] && !d->clip_grabbed[selection]) {

void spice_display_paste_from_guest(SpiceDisplay *display)

{

int selection = VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD;

if (d->nclip_targets[selection] == 0) {

*

* Take a screenshot of the display.

*

**/

GdkPixbuf *spice_display_get_pixbuf(SpiceDisplay *display)

{

GdkPixbuf *pixbuf;

int x, y;

guchar *src, *data, *dest;

static void sync_keyboard_lock_modifiers(SpiceDisplay *display)

{

Display *x_display;

guint32 modifiers;

GdkWindow *w;

typedef struct _SpiceDisplay SpiceDisplay;

typedef struct _SpiceDisplayClass SpiceDisplayClass;

struct _SpiceDisplay {

GtkDrawingArea parent;

/* Do not add fields to this struct */

};