• spice-gtk的spicy命令源码分析

    1、主函数入口 
    1. int main(int argc, char *argv[])
    2. {
    3.     GError *error = NULL;
    4.     GOptionContext *context;
    5.     spice_connection *conn;
    6.     gchar *conf_file, *conf;
    7.     char *host = NULL, *port = NULL, *tls_port = NULL, *unix_path = NULL;
    8.     keyfile = g_key_file_new();
    9.  
    10.     int mode = S_IRWXU;
    11.     conf_file = g_build_filename(g_get_user_config_dir(), "spicy", NULL);
    12.     if (g_mkdir_with_parents(conf_file, mode) == -1)
    13.         SPICE_DEBUG("failed to create config directory");
    14.     g_free(conf_file);
    15.  
    16.     conf_file = g_build_filename(g_get_user_config_dir(), "spicy", "settings", NULL);
    17.     if (!g_key_file_load_from_file(keyfile, conf_file,
    18.                                    G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, &error)) {
    19.         SPICE_DEBUG("Couldn't load configuration: %s", error->message);
    20.         g_clear_error(&error);
    21.     }
    22.  
    23.     /* parse opts */
    24.     gtk_init(&argc, &argv);
    25.     context = g_option_context_new("- spice client test application");
    26.     g_option_context_set_summary(context, "Gtk+ test client to connect to Spice servers.");
    27.     g_option_context_set_description(context, "Report bugs to " PACKAGE_BUGREPORT ".");
    28.     g_option_context_add_group(context, spice_get_option_group());
    29.     g_option_context_set_main_group(context, spice_cmdline_get_option_group());
    30.     g_option_context_add_main_entries(context, cmd_entries, NULL);
    31.     g_option_context_add_group(context, gtk_get_option_group(TRUE));
    32.     g_option_context_add_group(context, gst_init_get_option_group());
    33.     if (!g_option_context_parse (context, &argc, &argv, &error)) {
    34.         g_print("option parsing failed: %s\n", error->message);
    35.         exit(1);
    36.     }
    37.     g_option_context_free(context);
    38.     if (version) {
    39.         g_print("spicy " PACKAGE_VERSION "\n");
    40.         exit(0);
    41.     }
    42.  
    43.     mainloop = g_main_loop_new(NULL, false);
    44.     conn = connection_new();
    45.     spice_set_session_option(conn->session);
    46.     spice_cmdline_session_setup(conn->session);
    47.  
    48.     g_object_get(conn->session,"unix-path", &unix_path,"host", &host,"port", &port, "tls-port", &tls_port,NULL);
    49.     /* If user doesn't provide hostname and port, show the dialog window instead of connecting to server automatically */
    50.     if ((host == NULL || (port == NULL && tls_port == NULL)) && unix_path == NULL) {
    51.         if (!spicy_connect_dialog(conn->session)) {
    52.             exit(0);
    53.         }
    54.     }
    55.     g_free(host);
    56.     g_free(port);
    57.     g_free(tls_port);
    58.     g_free(unix_path);
    59.  
    60.     connection_connect(conn);
    61.     if (connections > 0)
    62.         g_main_loop_run(mainloop);
    63.     g_main_loop_unref(mainloop);
    64.  
    65.     if ((conf = g_key_file_to_data(keyfile, NULL, &error)) == NULL ||
    66.         !g_file_set_contents(conf_file, conf, -1, &error)) {
    67.         SPICE_DEBUG("Couldn't save configuration: %s", error->message);
    68.         g_error_free(error);
    69.         error = NULL;
    70.     }
    71.  
    72.     g_free(conf_file);
    73.     g_free(conf);
    74.     g_key_file_free(keyfile);
    75.     g_free(spicy_title);
    76.     setup_terminal(true);
    77.     gst_deinit();
    78.     return 0;
    79. }

    2、建立spice连接 
    1. static void connection_connect(spice_connection *conn)
    2. {
    3.     conn->disconnecting = false;
    4.     spice_session_connect(conn->session);
    5. }

    3、跳转到spice-session.c中，先断开连接，创建主通道，调用主通道建立连接 
    1. gboolean spice_session_connect(SpiceSession *session)
    2. {
    3.     SpiceSessionPrivate *s;
    4.     g_return_val_if_fail(SPICE_IS_SESSION(session), FALSE);
    5.     s = session->priv;
    6.     g_return_val_if_fail(!s->disconnecting, FALSE);
    7.  
    8.     session_disconnect(session, TRUE);
    9.     s->client_provided_sockets = FALSE;
    10.     if (s->cmain == NULL)
    11.         s->cmain = spice_channel_new(session, SPICE_CHANNEL_MAIN, 0);
    12.     glz_decoder_window_clear(s->glz_window);
    13.     return spice_channel_connect(s->cmain);
    14. }

    4、检查是否已经建立连接，调用channel_connect函数建立连接 
    1. gboolean spice_channel_connect(SpiceChannel *channel)
    2. {
    3.     g_return_val_if_fail(SPICE_IS_CHANNEL(channel), FALSE);
    4.     SpiceChannelPrivate *c = channel->priv;
    5.     if (c->state >= SPICE_CHANNEL_STATE_CONNECTING)
    6.         return TRUE;
    7.     g_return_val_if_fail(channel->priv->fd == -1, FALSE);
    8.     return channel_connect(channel, FALSE);
    9. }

    5、是否通过TLS建立连接，主线程空闲时通过connect_delayed函数去建立连接 
    1. static gboolean channel_connect(SpiceChannel *channel, gboolean tls)
    2. {
    3.     SpiceChannelPrivate *c = channel->priv;
    4.     g_return_val_if_fail(c != NULL, FALSE);
    5.     if (c->session == NULL || c->channel_type == -1 || c->channel_id == -1) {
    6.         /* unset properties or unknown channel type */
    7.         g_warning("%s: channel setup incomplete", __FUNCTION__);
    8.         return false;
    9.     }
    10.  
    11.     c->state = SPICE_CHANNEL_STATE_CONNECTING;
    12.     c->tls = tls;
    13.     if (spice_session_get_client_provided_socket(c->session)) {
    14.         if (c->fd == -1) {
    15.             CHANNEL_DEBUG(channel, "requesting fd");
    16.             /* FIXME: no way for client to provide fd atm. */
    17.             /* It could either chain on parent channel.. */
    18.             /* or register migration channel on parent session, or ? */
    19.             g_signal_emit(channel, signals[SPICE_CHANNEL_OPEN_FD], 0, c->tls);
    20.             return true;
    21.         }
    22.     }
    23.  
    24.     c->xmit_queue_blocked = FALSE;
    25.     g_return_val_if_fail(c->sock == NULL, FALSE);
    26.     g_object_ref(G_OBJECT(channel)); /* Unref'd when co-routine exits */
    27.     /* we connect in idle, to let previous coroutine exit, if present */
    28.     c->connect_delayed_id = g_idle_add(connect_delayed, channel);
    29.     return true;
    30. }

    6、创建协程，通过spice_channel_coroutine函数建立连接 
    1. static gboolean connect_delayed(gpointer data)
    2. {
    3.     SpiceChannel *channel = data;
    4.     SpiceChannelPrivate *c = channel->priv;
    5.     struct coroutine *co;
    6.  
    7.     CHANNEL_DEBUG(channel, "Open coroutine starting %p", channel);
    8.     c->connect_delayed_id = 0;
    9.     co = &c->coroutine.coroutine;
    10.     co->stack_size = 16 << 20; /* 16Mb */
    11.     co->entry = spice_channel_coroutine;
    12.     coroutine_init(co);
    13.     coroutine_yieldto(co, channel);
    14.     return FALSE;
    15. }

    7、通过socket连接到服务器的session会话中，如果启动TLS就完成TLS握手通信，完成认证后通过spice_channel_iterate函数监听socket消息 
    1. /* coroutine context */
    2. static void *spice_channel_coroutine(void *data)
    3. {
    4.     SpiceChannel *channel = SPICE_CHANNEL(data);
    5.     SpiceChannelPrivate *c = channel->priv;
    6.     guint verify;
    7.     int rc, delay_val = 1;
    8.     /* When some other SSL/TLS version becomes obsolete, add it to this variable. */
    9.     long ssl_options = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1;
    10.     CHANNEL_DEBUG(channel, "Started background coroutine %p", &c->coroutine);
    11.     if (spice_session_get_client_provided_socket(c->session)) {
    12.         if (c->fd < 0) {
    13.             g_critical("fd not provided!");
    14.             c->event = SPICE_CHANNEL_ERROR_CONNECT;
    15.             goto cleanup;
    16.         }
    17.  
    18.         if (!(c->sock = g_socket_new_from_fd(c->fd, NULL))) {
    19.                 CHANNEL_DEBUG(channel, "Failed to open socket from fd %d", c->fd);
    20.                 c->event = SPICE_CHANNEL_ERROR_CONNECT;
    21.                 goto cleanup;
    22.         }
    23.  
    24.         g_socket_set_blocking(c->sock, FALSE);
    25.         g_socket_set_keepalive(c->sock, TRUE);
    26.         c->conn = g_socket_connection_factory_create_connection(c->sock);
    27.         goto connected;
    28.     }
    29.  
    30. reconnect:
    31.     c->conn = spice_session_channel_open_host(c->session, channel, &c->tls, &c->error);
    32.     if (c->conn == NULL) {
    33.         if (!c->error && !c->tls) {
    34.             CHANNEL_DEBUG(channel, "trying with TLS port");
    35.             c->tls = true; /* FIXME: does that really work with provided fd */
    36.             goto reconnect;
    37.         } else {
    38.             CHANNEL_DEBUG(channel, "Connect error");
    39.             c->event = SPICE_CHANNEL_ERROR_CONNECT;
    40.             goto cleanup;
    41.         }
    42.     }
    43.     c->sock = g_object_ref(g_socket_connection_get_socket(c->conn));
    44.  
    45.     if (c->tls) {
    46.         c->ctx = SSL_CTX_new(SSLv23_method());
    47.         if (c->ctx == NULL) {
    48.             g_critical("SSL_CTX_new failed");
    49.             c->event = SPICE_CHANNEL_ERROR_TLS;
    50.             goto cleanup;
    51.         }
    52.         SSL_CTX_set_options(c->ctx, ssl_options);
    53.  
    54.         verify = spice_session_get_verify(c->session);
    55.         if (verify &
    56.             (SPICE_SESSION_VERIFY_SUBJECT | SPICE_SESSION_VERIFY_HOSTNAME)) {
    57.             rc = spice_channel_load_ca(channel);
    58.             if (rc == 0) {
    59.                 g_warning("no cert loaded");
    60.                 if (verify & SPICE_SESSION_VERIFY_PUBKEY) {
    61.                     g_warning("only pubkey active");
    62.                     verify = SPICE_SESSION_VERIFY_PUBKEY;
    63.                 } else {
    64.                     c->event = SPICE_CHANNEL_ERROR_TLS;
    65.                     goto cleanup;
    66.                 }
    67.             }
    68.         }
    69.  
    70.         {
    71.             const gchar *ciphers = spice_session_get_ciphers(c->session);
    72.             if (ciphers != NULL) {
    73.                 rc = SSL_CTX_set_cipher_list(c->ctx, ciphers);
    74.                 if (rc != 1)
    75.                     g_warning("loading cipher list %s failed", ciphers);
    76.             }
    77.         }
    78.  
    79.         c->ssl = SSL_new(c->ctx);
    80.         if (c->ssl == NULL) {
    81.             g_critical("SSL_new failed");
    82.             c->event = SPICE_CHANNEL_ERROR_TLS;
    83.             goto cleanup;
    84.         }
    85.  
    86.         BIO *bio = bio_new_giostream(G_IO_STREAM(c->conn));
    87.         SSL_set_bio(c->ssl, bio, bio);
    88.         {
    89.             guint8 *pubkey;
    90.             guint pubkey_len;
    91.             spice_session_get_pubkey(c->session, &pubkey, &pubkey_len);
    92.             c->sslverify = spice_openssl_verify_new(c->ssl, verify,
    93.                 spice_session_get_host(c->session),
    94.                 (char*)pubkey, pubkey_len,
    95.                 spice_session_get_cert_subject(c->session));
    96.         }
    97. #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
    98.         {
    99.             const char *hostname = spice_session_get_host(c->session);
    100.             // check is not an ip address
    101.             GInetAddress * ip = g_inet_address_new_from_string(hostname);
    102.             if (ip == NULL) {
    103.                 SSL_set_tlsext_host_name(c->ssl, hostname);
    104.             } else {
    105.                 g_object_unref(ip);
    106.             }
    107.         }
    108. #endif
    109. ssl_reconnect:
    110.         rc = SSL_connect(c->ssl);
    111.         if (rc <= 0) {
    112.             rc = SSL_get_error(c->ssl, rc);
    113.             if (rc == SSL_ERROR_WANT_READ || rc == SSL_ERROR_WANT_WRITE) {
    114.                 g_coroutine_socket_wait(&c->coroutine, c->sock, ssl_error_to_cond(rc));
    115.                 goto ssl_reconnect;
    116.             } else {
    117.                 g_warning("%s: SSL_connect: %s",
    118.                           c->name, ERR_error_string(rc, NULL));
    119.                 c->event = SPICE_CHANNEL_ERROR_TLS;
    120.                 goto cleanup;
    121.             }
    122.         }
    123.     }
    124.  
    125. connected:
    126.     c->has_error = FALSE;
    127.     c->in = g_io_stream_get_input_stream(G_IO_STREAM(c->conn));
    128.     c->out = g_io_stream_get_output_stream(G_IO_STREAM(c->conn));
    129.     rc = setsockopt(g_socket_get_fd(c->sock), IPPROTO_TCP, TCP_NODELAY,
    130.                     (const char*)&delay_val, sizeof(delay_val));
    131.     if ((rc != 0)
    132. #ifdef ENOTSUP
    133.         && (errno != ENOTSUP)
    134. #endif
    135.         ) {
    136.         g_warning("%s: could not set sockopt TCP_NODELAY: %s", c->name,strerror(errno));
    137.     }
    138.     spice_channel_send_link(channel);
    139.     if (!spice_channel_recv_link_hdr(channel) ||
    140.         !spice_channel_recv_link_msg(channel) ||
    141.         !spice_channel_recv_auth(channel))
    142.         goto cleanup;
    143.  
    144.     while (spice_channel_iterate(channel));
    145. cleanup:
    146.     CHANNEL_DEBUG(channel, "Coroutine exit %s", c->name);
    147.     spice_channel_reset(channel, FALSE);
    148.     if (c->state == SPICE_CHANNEL_STATE_RECONNECTING ||
    149.         c->state == SPICE_CHANNEL_STATE_SWITCHING) {
    150.         g_warn_if_fail(c->event == SPICE_CHANNEL_NONE);
    151.         if (channel_connect(channel, c->tls)) {
    152.             g_object_unref(channel);
    153.             return NULL;
    154.         }
    155.         c->event = SPICE_CHANNEL_ERROR_CONNECT;
    156.     }
    157.     g_idle_add(spice_channel_delayed_unref, channel);
    158.     /* Co-routine exits now - the SpiceChannel object may no longer exist,
    159.        so don't do anything else now unless you like SEGVs */
    160.     return NULL;
    161. }

    8、获取socket的读消息和者写消息，并调用相关的读函数iterate_write和写函数iterate_read 
    1. /* coroutine context */
    2. static gboolean spice_channel_iterate(SpiceChannel *channel)
    3. {
    4.     SpiceChannelPrivate *c = channel->priv;
    5.     if (c->state == SPICE_CHANNEL_STATE_MIGRATING &&
    6.         !g_coroutine_condition_wait(&c->coroutine, wait_migration, channel))
    7.         CHANNEL_DEBUG(channel, "migration wait cancelled");
    8.  
    9.     /* flush any pending write and read */
    10.     if (!c->has_error)
    11.         SPICE_CHANNEL_GET_CLASS(channel)->iterate_write(channel);
    12.     if (!c->has_error)
    13.         SPICE_CHANNEL_GET_CLASS(channel)->iterate_read(channel);
    14.     if (c->has_error) {
    15.         GIOCondition ret;
    16.         if (!c->sock)
    17.             return FALSE;
    18.  
    19.         /* We don't want to report an error if the socket was closed gracefully on the other end (VM shutdown) */
    20.         ret = g_socket_condition_check(c->sock, G_IO_IN | G_IO_ERR);
    21.         if (ret & G_IO_ERR) {
    22.             CHANNEL_DEBUG(channel, "channel got error");
    23.             if (c->state > SPICE_CHANNEL_STATE_CONNECTING) {
    24.                 if (c->state == SPICE_CHANNEL_STATE_READY)
    25.                     c->event = SPICE_CHANNEL_ERROR_IO;
    26.                 else
    27.                     c->event = SPICE_CHANNEL_ERROR_LINK;
    28.             }
    29.         }
    30.         return FALSE;
    31.     }
    32.     return TRUE;
    33. }

    9、设置的读写回调函数
    klass->iterate_write --> spice_channel_iterate_write
    klass->iterate_read -->spice_channel_iterate_read
    klass->handle_msg  --> spice_channel_handle_msg 
    1. static void spice_channel_class_init(SpiceChannelClass *klass)
    2. {
    3.     GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
    4.  
    5.     klass->iterate_write = spice_channel_iterate_write;
    6.     klass->iterate_read  = spice_channel_iterate_read;
    7.     klass->channel_reset = channel_reset;
    8.  
    9.     gobject_class->constructed  = spice_channel_constructed;
    10.     gobject_class->dispose      = spice_channel_dispose;
    11.     gobject_class->finalize     = spice_channel_finalize;
    12.     gobject_class->get_property = spice_channel_get_property;
    13.     gobject_class->set_property = spice_channel_set_property;
    14.     klass->handle_msg           = spice_channel_handle_msg;
    15.     ...
    16. }

    10、以读函数为例子，通过g_pollable_input_stream_is_readable获取到是否有可读的消息，如果有消息，调用spice_channel_recv_msg函数处理
    注意参数是一个函数指针：SPICE_CHANNEL_GET_CLASS(channel)->handle_msg  
    1. /* coroutine context */
    2. static void spice_channel_iterate_read(SpiceChannel *channel)
    3. {
    4.     SpiceChannelPrivate *c = channel->priv;
    5.     g_coroutine_socket_wait(&c->coroutine, c->sock, G_IO_IN);
    6.     /* treat all incoming data (block on message completion) */
    7.     while (!c->has_error &&
    8.            c->state != SPICE_CHANNEL_STATE_MIGRATING &&
    9.            (g_pollable_input_stream_is_readable(G_POLLABLE_INPUT_STREAM(c->in))
    10. #ifdef HAVE_SASL
    11.             /* flush the sasl buffer too */
    12.            || c->sasl_decoded != NULL
    13. #endif
    14.            )
    15.     ) {
    16.         spice_channel_recv_msg(channel, (handler_msg_in)SPICE_CHANNEL_GET_CLASS(channel)->handle_msg, NULL);
    17.     }
    18. }

    11、通过spice_channel_read读取消息，然后通过msg_handler函数处理消息，msg_handler是一个函数指针 
    1. /* coroutine context */
    2. G_GNUC_INTERNAL
    3. void spice_channel_recv_msg(SpiceChannel *channel,
    4.                             handler_msg_in msg_handler, gpointer data)
    5. {
    6.     SpiceChannelPrivate *c = channel->priv;
    7.     SpiceMsgIn *in;
    8.     int msg_size;
    9.     int msg_type;
    10.     int sub_list_offset = 0;
    11.     in = spice_msg_in_new(channel);
    12.  
    13.     /* receive message */
    14.     spice_channel_read(channel, in->header,spice_header_get_header_size(c->use_mini_header));
    15.     if (c->has_error)
    16.         goto end;
    17.  
    18.     msg_size = spice_header_get_msg_size(in->header, c->use_mini_header);
    19.     /* FIXME: do not allow others to take ref on in, and use realloc here? this would avoid malloc/free on each message? */
    20.     in->data = g_malloc0(msg_size);
    21.     spice_channel_read(channel, in->data, msg_size);
    22.     if (c->has_error)
    23.         goto end;
    24.     in->dpos = msg_size;
    25.     msg_type = spice_header_get_msg_type(in->header, c->use_mini_header);
    26.     sub_list_offset = spice_header_get_msg_sub_list(in->header, c->use_mini_header);
    27.  
    28.     if (msg_type == SPICE_MSG_LIST || sub_list_offset) {
    29.         SpiceSubMessageList *sub_list;
    30.         SpiceSubMessage *sub;
    31.         SpiceMsgIn *sub_in;
    32.         int i;
    33.         sub_list = (SpiceSubMessageList *)(in->data + sub_list_offset);
    34.         for (i = 0; i < sub_list->size; i++) {
    35.             sub = (SpiceSubMessage *)(in->data + sub_list->sub_messages[i]);
    36.             sub_in = spice_msg_in_sub_new(channel, in, sub);
    37.             sub_in->parsed = c->parser(sub_in->data, sub_in->data + sub_in->dpos,
    38.                                        spice_header_get_msg_type(sub_in->header,c->use_mini_header),
    39.                                        c->peer_hdr.minor_version,
    40.                                        &sub_in->psize, &sub_in->pfree);
    41.             if (sub_in->parsed == NULL) {
    42.                 g_critical("failed to parse sub-message: %s type %d",
    43.                            c->name, spice_header_get_msg_type(sub_in->header, c->use_mini_header));
    44.                 goto end;
    45.             }
    46.             msg_handler(channel, sub_in, data);
    47.             spice_msg_in_unref(sub_in);
    48.         }
    49.     }
    50.  
    51.     /* ack message */
    52.     if (c->message_ack_count) {
    53.         c->message_ack_count--;
    54.         if (!c->message_ack_count) {
    55.             SpiceMsgOut *out = spice_msg_out_new(channel, SPICE_MSGC_ACK);
    56.             spice_msg_out_send_internal(out);
    57.             c->message_ack_count = c->message_ack_window;
    58.         }
    59.     }
    60.  
    61.     if (msg_type == SPICE_MSG_LIST) {
    62.         goto end;
    63.     }
    64.     /* parse message */
    65.     in->parsed = c->parser(in->data, in->data + msg_size, msg_type,
    66.                            c->peer_hdr.minor_version, &in->psize, &in->pfree);
    67.     if (in->parsed == NULL) {
    68.         g_critical("failed to parse message: %s type %d",
    69.                    c->name, msg_type);
    70.         goto end;
    71.     }
    72.  
    73.     /* process message */
    74.     /* spice_msg_in_hexdump(in); */
    75.     msg_handler(channel, in, data);
    76.  
    77. end:
    78.     /* If the server uses full header, the serial is not necessarily equal
    79.      * to c->in_serial (the server can sometimes skip serials) */
    80.     c->last_message_serial = spice_header_get_in_msg_serial(in);
    81.     c->in_serial++;
    82.     spice_msg_in_unref(in);
    83. }

    12、msg_handler调用本质就是 spice_channel_handle_msg函数，而这个函数就是每个channel定义时会设置的const spice_msg_handler handlers[]函数指针数组。 
    1. /* coroutine context */
    2. static void spice_channel_handle_msg(SpiceChannel *channel, SpiceMsgIn *msg)
    3. {
    4.     SpiceChannelClass *klass = SPICE_CHANNEL_GET_CLASS(channel);
    5.     int type = spice_msg_in_type(msg);// SPICE_MSG_PLAYBACK_DATA
    6.     spice_msg_handler handler;
    7.  
    8.     g_return_if_fail(type < klass->priv->handlers->len);
    9.     if (type > SPICE_MSG_BASE_LAST && channel->priv->disable_channel_msg)
    10.         return;
    11.  
    12.     handler = g_array_index(klass->priv->handlers, spice_msg_handler, type); //获取回调函数
    13.     g_return_if_fail(handler != NULL);
    14.     handler(channel, msg); //调用相应的回到函数
    15. }

    13、通过spice_protocol协议定义了枚举数值来找到相应的回调函数，如下图  
    1. SPICE_MSG_PLAYBACK_DATA --> playback_handle_data
    2. enum {
    3.     SPICE_MSG_PLAYBACK_DATA = 101,
    4.     SPICE_MSG_PLAYBACK_MODE,
    5.     SPICE_MSG_PLAYBACK_START,
    6.     SPICE_MSG_PLAYBACK_STOP,
    7.     SPICE_MSG_PLAYBACK_VOLUME,
    8.     SPICE_MSG_PLAYBACK_MUTE,
    9.     SPICE_MSG_PLAYBACK_LATENCY,
    10.     SPICE_MSG_END_PLAYBACK
    11. };
    12.  
    13. static void channel_set_handlers(SpiceChannelClass *klass)
    14. {
    15.     static const spice_msg_handler handlers[] = {
    16.         [ SPICE_MSG_PLAYBACK_DATA ]            = playback_handle_data,
    17.         [ SPICE_MSG_PLAYBACK_MODE ]            = playback_handle_mode,
    18.         [ SPICE_MSG_PLAYBACK_START ]           = playback_handle_start,
    19.         [ SPICE_MSG_PLAYBACK_STOP ]            = playback_handle_stop,
    20.         [ SPICE_MSG_PLAYBACK_VOLUME ]          = playback_handle_set_volume,
    21.         [ SPICE_MSG_PLAYBACK_MUTE ]            = playback_handle_set_mute,
    22.         [ SPICE_MSG_PLAYBACK_LATENCY ]         = playback_handle_set_latency,
    23.     };
    24.     spice_channel_set_handlers(klass, handlers, G_N_ELEMENTS(handlers));
    25. }
  • 相关阅读:
    05-在Idea中编写Servlet程序
    HTML5期末考核大作业——学生网页设计作业源码HTML+CSS+JavaScript 中华美德6页面带音乐文化
    java 面试题 基础部分
    Vue根据屏幕分辨率计算div可以显示的数量，dom渲染在v-if之后造成的复杂处理
    UDP/TCP协议报头详细分析
    UWB室内定位系统全套源码 高精度人员定位系统源码
    搭建nacos集群，并通过nginx实现负载均衡
    window10下安装ubuntu系统以及docker使用
    web前端网页设计期末课程大作业：企业网页主题网站设计——舞蹈培训11页HTML+CSS+JavaScript
    spring Boot使用Mybatis实践
  • 原文地址：https://blog.csdn.net/cai742925624/article/details/126379167