int main(int argc, char *argv[])
{GError *error = NULL;GOptionContext *context;spice_connection *conn;gchar *conf_file, *conf;char *host = NULL, *port = NULL, *tls_port = NULL, *unix_path = NULL;keyfile = g_key_file_new();int mode = S_IRWXU;conf_file = g_build_filename(g_get_user_config_dir(), "spicy", NULL);if (g_mkdir_with_parents(conf_file, mode) == -1)SPICE_DEBUG("failed to create config directory");g_free(conf_file);conf_file = g_build_filename(g_get_user_config_dir(), "spicy", "settings", NULL);if (!g_key_file_load_from_file(keyfile, conf_file,G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, &error)) {SPICE_DEBUG("Couldn't load configuration: %s", error->message);g_clear_error(&error);}/* parse opts */gtk_init(&argc, &argv);context = g_option_context_new("- spice client test application");g_option_context_set_summary(context, "Gtk+ test client to connect to Spice servers.");g_option_context_set_description(context, "Report bugs to " PACKAGE_BUGREPORT ".");g_option_context_add_group(context, spice_get_option_group());g_option_context_set_main_group(context, spice_cmdline_get_option_group());g_option_context_add_main_entries(context, cmd_entries, NULL);g_option_context_add_group(context, gtk_get_option_group(TRUE));g_option_context_add_group(context, gst_init_get_option_group());if (!g_option_context_parse (context, &argc, &argv, &error)) {g_print("option parsing failed: %s\n", error->message);exit(1);}g_option_context_free(context);if (version) {g_print("spicy " PACKAGE_VERSION "\n");exit(0);}mainloop = g_main_loop_new(NULL, false);conn = connection_new();spice_set_session_option(conn->session);spice_cmdline_session_setup(conn->session);g_object_get(conn->session,"unix-path", &unix_path,"host", &host,"port", &port, "tls-port", &tls_port,NULL);/* If user doesn't provide hostname and port, show the dialog window instead of connecting to server automatically */if ((host == NULL || (port == NULL && tls_port == NULL)) && unix_path == NULL) {if (!spicy_connect_dialog(conn->session)) {exit(0);}}g_free(host);g_free(port);g_free(tls_port);g_free(unix_path);connection_connect(conn);if (connections > 0)g_main_loop_run(mainloop);g_main_loop_unref(mainloop);if ((conf = g_key_file_to_data(keyfile, NULL, &error)) == NULL ||!g_file_set_contents(conf_file, conf, -1, &error)) {SPICE_DEBUG("Couldn't save configuration: %s", error->message);g_error_free(error);error = NULL;}g_free(conf_file);g_free(conf);g_key_file_free(keyfile);g_free(spicy_title);setup_terminal(true);gst_deinit();return 0;
}

static void connection_connect(spice_connection *conn)
{conn->disconnecting = false;spice_session_connect(conn->session);
}

gboolean spice_session_connect(SpiceSession *session)
{SpiceSessionPrivate *s;g_return_val_if_fail(SPICE_IS_SESSION(session), FALSE);s = session->priv;g_return_val_if_fail(!s->disconnecting, FALSE);session_disconnect(session, TRUE);s->client_provided_sockets = FALSE;if (s->cmain == NULL)s->cmain = spice_channel_new(session, SPICE_CHANNEL_MAIN, 0);glz_decoder_window_clear(s->glz_window);return spice_channel_connect(s->cmain);
}

gboolean spice_channel_connect(SpiceChannel *channel)
{g_return_val_if_fail(SPICE_IS_CHANNEL(channel), FALSE);SpiceChannelPrivate *c = channel->priv;if (c->state >= SPICE_CHANNEL_STATE_CONNECTING)return TRUE;g_return_val_if_fail(channel->priv->fd == -1, FALSE);return channel_connect(channel, FALSE);
}

static gboolean channel_connect(SpiceChannel *channel, gboolean tls)
{SpiceChannelPrivate *c = channel->priv;g_return_val_if_fail(c != NULL, FALSE);if (c->session == NULL || c->channel_type == -1 || c->channel_id == -1) {/* unset properties or unknown channel type */g_warning("%s: channel setup incomplete", __FUNCTION__);return false;}c->state = SPICE_CHANNEL_STATE_CONNECTING;c->tls = tls;if (spice_session_get_client_provided_socket(c->session)) {if (c->fd == -1) {CHANNEL_DEBUG(channel, "requesting fd");/* FIXME: no way for client to provide fd atm. *//* It could either chain on parent channel.. *//* or register migration channel on parent session, or ? */g_signal_emit(channel, signals[SPICE_CHANNEL_OPEN_FD], 0, c->tls);return true;}}c->xmit_queue_blocked = FALSE;g_return_val_if_fail(c->sock == NULL, FALSE);g_object_ref(G_OBJECT(channel)); /* Unref'd when co-routine exits *//* we connect in idle, to let previous coroutine exit, if present */c->connect_delayed_id = g_idle_add(connect_delayed, channel);return true;
}

static gboolean connect_delayed(gpointer data)
{SpiceChannel *channel = data;SpiceChannelPrivate *c = channel->priv;struct coroutine *co;CHANNEL_DEBUG(channel, "Open coroutine starting %p", channel);c->connect_delayed_id = 0;co = &c->coroutine.coroutine;co->stack_size = 16 << 20; /* 16Mb */co->entry = spice_channel_coroutine;coroutine_init(co);coroutine_yieldto(co, channel);return FALSE;
}

/* coroutine context */
static void *spice_channel_coroutine(void *data)
{SpiceChannel *channel = SPICE_CHANNEL(data);SpiceChannelPrivate *c = channel->priv;guint verify;int rc, delay_val = 1;/* When some other SSL/TLS version becomes obsolete, add it to this variable. */long ssl_options = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1;CHANNEL_DEBUG(channel, "Started background coroutine %p", &c->coroutine);if (spice_session_get_client_provided_socket(c->session)) {if (c->fd < 0) {g_critical("fd not provided!");c->event = SPICE_CHANNEL_ERROR_CONNECT;goto cleanup;}if (!(c->sock = g_socket_new_from_fd(c->fd, NULL))) {CHANNEL_DEBUG(channel, "Failed to open socket from fd %d", c->fd);c->event = SPICE_CHANNEL_ERROR_CONNECT;goto cleanup;}g_socket_set_blocking(c->sock, FALSE);g_socket_set_keepalive(c->sock, TRUE);c->conn = g_socket_connection_factory_create_connection(c->sock);goto connected;}reconnect:c->conn = spice_session_channel_open_host(c->session, channel, &c->tls, &c->error);if (c->conn == NULL) {if (!c->error && !c->tls) {CHANNEL_DEBUG(channel, "trying with TLS port");c->tls = true; /* FIXME: does that really work with provided fd */goto reconnect;} else {CHANNEL_DEBUG(channel, "Connect error");c->event = SPICE_CHANNEL_ERROR_CONNECT;goto cleanup;}}c->sock = g_object_ref(g_socket_connection_get_socket(c->conn));if (c->tls) {c->ctx = SSL_CTX_new(SSLv23_method());if (c->ctx == NULL) {g_critical("SSL_CTX_new failed");c->event = SPICE_CHANNEL_ERROR_TLS;goto cleanup;}SSL_CTX_set_options(c->ctx, ssl_options);verify = spice_session_get_verify(c->session);if (verify &(SPICE_SESSION_VERIFY_SUBJECT | SPICE_SESSION_VERIFY_HOSTNAME)) {rc = spice_channel_load_ca(channel);if (rc == 0) {g_warning("no cert loaded");if (verify & SPICE_SESSION_VERIFY_PUBKEY) {g_warning("only pubkey active");verify = SPICE_SESSION_VERIFY_PUBKEY;} else {c->event = SPICE_CHANNEL_ERROR_TLS;goto cleanup;}}}{const gchar *ciphers = spice_session_get_ciphers(c->session);if (ciphers != NULL) {rc = SSL_CTX_set_cipher_list(c->ctx, ciphers);if (rc != 1)g_warning("loading cipher list %s failed", ciphers);}}c->ssl = SSL_new(c->ctx);if (c->ssl == NULL) {g_critical("SSL_new failed");c->event = SPICE_CHANNEL_ERROR_TLS;goto cleanup;}BIO *bio = bio_new_giostream(G_IO_STREAM(c->conn));SSL_set_bio(c->ssl, bio, bio);{guint8 *pubkey;guint pubkey_len;spice_session_get_pubkey(c->session, &pubkey, &pubkey_len);c->sslverify = spice_openssl_verify_new(c->ssl, verify,spice_session_get_host(c->session),(char*)pubkey, pubkey_len,spice_session_get_cert_subject(c->session));}
#if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT){const char *hostname = spice_session_get_host(c->session);// check is not an ip addressGInetAddress * ip = g_inet_address_new_from_string(hostname);if (ip == NULL) {SSL_set_tlsext_host_name(c->ssl, hostname);} else {g_object_unref(ip);}}
#endif
ssl_reconnect:rc = SSL_connect(c->ssl);if (rc <= 0) {rc = SSL_get_error(c->ssl, rc);if (rc == SSL_ERROR_WANT_READ || rc == SSL_ERROR_WANT_WRITE) {g_coroutine_socket_wait(&c->coroutine, c->sock, ssl_error_to_cond(rc));goto ssl_reconnect;} else {g_warning("%s: SSL_connect: %s",c->name, ERR_error_string(rc, NULL));c->event = SPICE_CHANNEL_ERROR_TLS;goto cleanup;}}}connected:c->has_error = FALSE;c->in = g_io_stream_get_input_stream(G_IO_STREAM(c->conn));c->out = g_io_stream_get_output_stream(G_IO_STREAM(c->conn));rc = setsockopt(g_socket_get_fd(c->sock), IPPROTO_TCP, TCP_NODELAY,(const char*)&delay_val, sizeof(delay_val));if ((rc != 0)
#ifdef ENOTSUP&& (errno != ENOTSUP)
#endif) {g_warning("%s: could not set sockopt TCP_NODELAY: %s", c->name,strerror(errno));}spice_channel_send_link(channel);if (!spice_channel_recv_link_hdr(channel) ||!spice_channel_recv_link_msg(channel) ||!spice_channel_recv_auth(channel))goto cleanup;while (spice_channel_iterate(channel));
cleanup:CHANNEL_DEBUG(channel, "Coroutine exit %s", c->name);spice_channel_reset(channel, FALSE);if (c->state == SPICE_CHANNEL_STATE_RECONNECTING ||c->state == SPICE_CHANNEL_STATE_SWITCHING) {g_warn_if_fail(c->event == SPICE_CHANNEL_NONE);if (channel_connect(channel, c->tls)) {g_object_unref(channel);return NULL;}c->event = SPICE_CHANNEL_ERROR_CONNECT;}g_idle_add(spice_channel_delayed_unref, channel);/* Co-routine exits now - the SpiceChannel object may no longer exist,so don't do anything else now unless you like SEGVs */return NULL;
}

/* coroutine context */
static gboolean spice_channel_iterate(SpiceChannel *channel)
{SpiceChannelPrivate *c = channel->priv;if (c->state == SPICE_CHANNEL_STATE_MIGRATING &&!g_coroutine_condition_wait(&c->coroutine, wait_migration, channel))CHANNEL_DEBUG(channel, "migration wait cancelled");/* flush any pending write and read */if (!c->has_error)SPICE_CHANNEL_GET_CLASS(channel)->iterate_write(channel);if (!c->has_error)SPICE_CHANNEL_GET_CLASS(channel)->iterate_read(channel);if (c->has_error) {GIOCondition ret;if (!c->sock)return FALSE;/* We don't want to report an error if the socket was closed gracefully on the other end (VM shutdown) */ret = g_socket_condition_check(c->sock, G_IO_IN | G_IO_ERR);if (ret & G_IO_ERR) {CHANNEL_DEBUG(channel, "channel got error");if (c->state > SPICE_CHANNEL_STATE_CONNECTING) {if (c->state == SPICE_CHANNEL_STATE_READY)c->event = SPICE_CHANNEL_ERROR_IO;elsec->event = SPICE_CHANNEL_ERROR_LINK;}}return FALSE;}return TRUE;
}

static void spice_channel_class_init(SpiceChannelClass *klass)
{GObjectClass *gobject_class = G_OBJECT_CLASS (klass);klass->iterate_write = spice_channel_iterate_write;klass->iterate_read  = spice_channel_iterate_read;klass->channel_reset = channel_reset;gobject_class->constructed  = spice_channel_constructed;gobject_class->dispose      = spice_channel_dispose;gobject_class->finalize     = spice_channel_finalize;gobject_class->get_property = spice_channel_get_property;gobject_class->set_property = spice_channel_set_property;klass->handle_msg           = spice_channel_handle_msg;...
}

/* coroutine context */
static void spice_channel_iterate_read(SpiceChannel *channel)
{SpiceChannelPrivate *c = channel->priv;g_coroutine_socket_wait(&c->coroutine, c->sock, G_IO_IN);/* treat all incoming data (block on message completion) */while (!c->has_error &&c->state != SPICE_CHANNEL_STATE_MIGRATING &&(g_pollable_input_stream_is_readable(G_POLLABLE_INPUT_STREAM(c->in))
#ifdef HAVE_SASL/* flush the sasl buffer too */|| c->sasl_decoded != NULL
#endif)) {spice_channel_recv_msg(channel, (handler_msg_in)SPICE_CHANNEL_GET_CLASS(channel)->handle_msg, NULL);}
}

/* coroutine context */
G_GNUC_INTERNAL
void spice_channel_recv_msg(SpiceChannel *channel,handler_msg_in msg_handler, gpointer data)
{SpiceChannelPrivate *c = channel->priv;SpiceMsgIn *in;int msg_size;int msg_type;int sub_list_offset = 0;in = spice_msg_in_new(channel);/* receive message */spice_channel_read(channel, in->header,spice_header_get_header_size(c->use_mini_header));if (c->has_error)goto end;msg_size = spice_header_get_msg_size(in->header, c->use_mini_header);/* FIXME: do not allow others to take ref on in, and use realloc here? this would avoid malloc/free on each message? */in->data = g_malloc0(msg_size);spice_channel_read(channel, in->data, msg_size);if (c->has_error)goto end;in->dpos = msg_size;msg_type = spice_header_get_msg_type(in->header, c->use_mini_header);sub_list_offset = spice_header_get_msg_sub_list(in->header, c->use_mini_header);if (msg_type == SPICE_MSG_LIST || sub_list_offset) {SpiceSubMessageList *sub_list;SpiceSubMessage *sub;SpiceMsgIn *sub_in;int i;sub_list = (SpiceSubMessageList *)(in->data + sub_list_offset);for (i = 0; i < sub_list->size; i++) {sub = (SpiceSubMessage *)(in->data + sub_list->sub_messages[i]);sub_in = spice_msg_in_sub_new(channel, in, sub);sub_in->parsed = c->parser(sub_in->data, sub_in->data + sub_in->dpos,spice_header_get_msg_type(sub_in->header,c->use_mini_header),c->peer_hdr.minor_version,&sub_in->psize, &sub_in->pfree);if (sub_in->parsed == NULL) {g_critical("failed to parse sub-message: %s type %d",c->name, spice_header_get_msg_type(sub_in->header, c->use_mini_header));goto end;}msg_handler(channel, sub_in, data);spice_msg_in_unref(sub_in);}}/* ack message */if (c->message_ack_count) {c->message_ack_count--;if (!c->message_ack_count) {SpiceMsgOut *out = spice_msg_out_new(channel, SPICE_MSGC_ACK);spice_msg_out_send_internal(out);c->message_ack_count = c->message_ack_window;}}if (msg_type == SPICE_MSG_LIST) {goto end;}/* parse message */in->parsed = c->parser(in->data, in->data + msg_size, msg_type,c->peer_hdr.minor_version, &in->psize, &in->pfree);if (in->parsed == NULL) {g_critical("failed to parse message: %s type %d",c->name, msg_type);goto end;}/* process message *//* spice_msg_in_hexdump(in); */msg_handler(channel, in, data);end:/* If the server uses full header, the serial is not necessarily equal* to c->in_serial (the server can sometimes skip serials) */c->last_message_serial = spice_header_get_in_msg_serial(in);c->in_serial++;spice_msg_in_unref(in);
}

/* coroutine context */
static void spice_channel_handle_msg(SpiceChannel *channel, SpiceMsgIn *msg)
{SpiceChannelClass *klass = SPICE_CHANNEL_GET_CLASS(channel);int type = spice_msg_in_type(msg);// SPICE_MSG_PLAYBACK_DATAspice_msg_handler handler;g_return_if_fail(type < klass->priv->handlers->len);if (type > SPICE_MSG_BASE_LAST && channel->priv->disable_channel_msg)return;handler = g_array_index(klass->priv->handlers, spice_msg_handler, type); //获取回调函数g_return_if_fail(handler != NULL);handler(channel, msg); //调用相应的回到函数
}

SPICE_MSG_PLAYBACK_DATA --> playback_handle_data
enum {SPICE_MSG_PLAYBACK_DATA = 101,SPICE_MSG_PLAYBACK_MODE,SPICE_MSG_PLAYBACK_START,SPICE_MSG_PLAYBACK_STOP,SPICE_MSG_PLAYBACK_VOLUME,SPICE_MSG_PLAYBACK_MUTE,SPICE_MSG_PLAYBACK_LATENCY,SPICE_MSG_END_PLAYBACK
};static void channel_set_handlers(SpiceChannelClass *klass)
{static const spice_msg_handler handlers[] = {[ SPICE_MSG_PLAYBACK_DATA ]            = playback_handle_data,[ SPICE_MSG_PLAYBACK_MODE ]            = playback_handle_mode,[ SPICE_MSG_PLAYBACK_START ]           = playback_handle_start,[ SPICE_MSG_PLAYBACK_STOP ]            = playback_handle_stop,[ SPICE_MSG_PLAYBACK_VOLUME ]          = playback_handle_set_volume,[ SPICE_MSG_PLAYBACK_MUTE ]            = playback_handle_set_mute,[ SPICE_MSG_PLAYBACK_LATENCY ]         = playback_handle_set_latency,};spice_channel_set_handlers(klass, handlers, G_N_ELEMENTS(handlers));
}