Spice工作原理及代码剖析：03 Channel：客户端与服务器通信机制.docx

〇、基本原理

目前的Channel类型枚举值定义如下：

enum {
    SPICE_CHANNEL_MAIN = 1,
    SPICE_CHANNEL_DISPLAY,
    SPICE_CHANNEL_INPUTS,
    SPICE_CHANNEL_CURSOR,
    SPICE_CHANNEL_PLAYBACK,
    SPICE_CHANNEL_RECORD,
    SPICE_CHANNEL_TUNNEL, // 没定义USE_TUNNEL，则此Channel无效

    SPICE_END_CHANNEL
};

每个Channel就是客户端与服务端一个的网络连接。

客户端将每个Channel实现为一个单独的线程，实现方式是定义一个以单独线程运转的RedChannel基类，然后从此基类中派生所需要的具体功能类，客户端Channel类包括：RedClient、DisplayChannel、CursorChannel、InputsChannel、PlaybackChannel、RecordChannel、TunnelChannel。

服务端Channel的工作相对复杂一点，部分Channel工作在Qemu主线程，另一部分在工作在libspice的单独线程中，服务端的网络模型参见文档02。

客户端启动后会首先与服务器建立连接，此连接即为MAIN_CHANNEL，MAIN_CHANNEL建立起来之后，客户端首先向服务器发送查询命令，请求服务器支持的Channel类型，然后客户端对所有支持的Channel一一创建对应的Channel类实例，每个实例都会开启自己的工作线程并向服务端发起连接请求，建立网络连接，下面是大致的工作流程及相关代码：

1、客户端首先会与服务器之间建立一个MAIN_CHANNEL，客户端一侧表现为RedClient，此Channel由客户端主动发起创建：

     Application构造函数初始化时会初始化其RedClient成员_client，RedClient初始化时就会启动RedChannel类的start函数来创建工作线程，

     具体的网络连接操作在工作线程的主循环内部完成，具体由RedChannelBase基类实现的connect、link两个函数来实现网络连接的建立和Channel link的建立。工作线程的主循环只处理简单的几个事件，其余消息处理交给其成员ProcessLoop的消息循环来完成。

2、MAIN_CHANNEL建立后，客户端RedClient进入其ProcessLoop的消息循环，等待服务端消息。服务端完成MAIN_CHANNEL相关工作的初始化（主要就是向Qemu注册一个网络消息处理结点，具体参见select网络模型中关于Watch的讲解）后，会通过此Channel发送SPICE_MSG_MAIN_INIT消息，告知客户端可以进行后续的初始化工作了。

3、客户端执行初始化工作后，会发送消息请求支持的Channel列表，服务端将注册（参见下面Server端Channel实现）的Channel列表发送给客户端，并通知客户端创建Channel。

4、客户端其余Channel的创建都通过一个统一的接口，从工厂类中生产各个Channel类实例。参见具体实现如下(略去部分检查代码)：

void RedClient::create_channel(uint32_t type, uint32_t id)

{

    ChannelFactory* factory = find_factory(type);

    RedChannel* channel = factory->construct(*this, id);

    _channels.push_back(channel);

 

    channel->start();   // 启动RedChannel类的工作线程

    channel->connect(); // 激活condition

 

    _migrate.add_channel(new MigChannel(type, id, channel->get_common_caps(), channel->get_caps()));

}

建立Channel的详细步骤及消息传递流程如下：（s表示server代码，c表示client代码）

s: reds_init_net, 创建listen socket，增加监听watch_add(reds_accept)

c: RedChannel::run-》RedChannelBase::connect() -》RedPeer::connect_unsecure发送连接请求，等待服务端accept

s: reds_accept-》reds_accept_connection，

            reds_handle_new_link-》obj->done = reds_handle_read_header_done，

                            async_read_handler-》cb_read 堵塞，等待客户端发送link消息

c: RedChannelBase::link() -》link_mess.channel_type = _type，send 发送link请求，recive等待

s: obj->done -》reds_handle_read_header_done

            -》(read_header完了，继续从流中读取数据)obj->done = reds_handle_read_link_done，async_read_handler

            -》cb_read，obj->done(reds_handle_read_link_done) -》   obj->done = reds_handle_ticket，async_read_handler

            -》cb_read，obj->done(reds_handle_ticket) {

                case channel_type of SPICE_CHANNEL_MAIN：reds_handle_main_link

                otherwise：reds_handle_other_links

              }        

 

c->s: SPICE_CHANNEL_MAIN s: reds_handle_main_link，此过程的详细步骤如上

s->c: SPICE_MSG_MAIN_INIT, c: handle_init

c->s: SPICE_MSGC_MAIN_ATTACH_CHANNELS s: reds_send_channels

s->c: SPICE_MSG_MAIN_CHANNELS_LIST c: handle_channels

 

一、Server端 Channel 实现

1、服务端注册Channel。

服务端最关键的数据结构为RedsState，又有一个别名叫SpiceServer，Server端会维护一个全局的RedsState变量，用来存储全局数据。该全局数据结构在CoreInterface初始化时由Qemu负责发起创建，并通过VDI接口将此对象传递给libspice。

RedsState中一个数据成员为Channel* channels，Server端通过此变量来维护一个Channel链表，所有Server端支持的Channel都需要通过reds_register_channel注册到此链表。除了InputChannle是在spice_server_init中注册的外（即：在CoreInterface初始化时注册的），其余Channel都是在Qemu进行虚拟设备初始化时，通过调用spice_server_add_interface函数注册VDI时注册的，列举如下：

// spice_server_init

inputs_init 中注册：SPICE_CHANNEL_INPUTS   

// spice_server_add_interface(SPICE_INTERFACE_QXL)

red_dispatcher_init 中注册：SPICE_CHANNEL_DISPLAY、SPICE_CHANNEL_CURSOR

// spice_server_add_interface(SPICE_INTERFACE_PLAYBACK)                

snd_attach_playback 中注册：SPICE_CHANNEL_PLAYBACK     

// spice_server_add_interface(SPICE_INTERFACE_RECORD)      

snd_attach_record 中注册：SPICE_CHANNEL_RECORD 

// spice_server_add_interface(SPICE_INTERFACE_NET_WIRE)            

red_tunnel_attach 中注册：SPICE_CHANNEL_TUNNEL                 

所谓注册Channel，就是初始化一个Channel对象，然后将其插入到RedsState的channels链表中供后续的访问处理。Channel结构定义如下：

typedef struct Channel {

    struct Channel *next;

    uint32_t type;

    uint32_t id;

    int num_common_caps;

    uint32_t *common_caps;

    int num_caps;

    uint32_t *caps;

    void (*link)(struct Channel *, RedsStreamContext *peer, int migration, int num_common_caps,

                 uint32_t *common_caps, int num_caps, uint32_t *caps);

    void (*shutdown)(struct Channel *);

    void (*migrate)(struct Channel *);

    void *data;

} Channel;

Channel注册主要是初始化Channel的数据和三个回调函数：link、shutdown、migrate，用来对Channel进行操作。其中数据成员type就是最开始我们列出的枚举值，用以标识当前Channel类型。下面是Spice中Display Channel初始化的代码：

   

reds_channel = spice_new0(Channel, 1);

    reds_channel->type = SPICE_CHANNEL_DISPLAY;

    reds_channel->id = qxl->id;

    reds_channel->link = red_dispatcher_set_peer;

    reds_channel->shutdown = red_dispatcher_shutdown_peer;

    reds_channel->migrate = red_dispatcher_migrate;

    reds_channel->data = dispatcher;

reds_register_channel(reds_channel);

2、Channel的三个回调函数：link、shutdown、migrate，其中link是在客户端与服务端建立Channel连接的时候被调用的，下面对其进行详细解说

    首先，客户端Channel的工作线程启动后，发起link()操作，服务端在reds_handle_new_link中响应，最终会调用各个注册的Channel的link()函数完成link操作。这个过程中，Server端利用了一种异步消息处理机制，主要是通过一个结构加一个处理函数来实现，简单介绍一下此消息处理机制：

   AsyncRead是此消息处理机制的一个非常重要的辅助结构体，定义如下：

   typedef struct AsyncRead {

    RedsStreamContext *peer; // 用来处理网络数据流的数据对象

    void *opaque;  // 传递数据用的，通常作为done函数的参数

    uint8_t *now;  // 数据起始，用来保存接收数据

    uint8_t *end;  // 数据结束，通常用来计算数据长度

    void (*done)(void *opaque); // 消息处理函数

    void (*error)(void *opaque, int err); // 错误处理函数

   } AsyncRead;

   // 异步消息处理函数，最主要的参数就是data，是一个AsyncRead指针（省略异常处理，具体异常处理方法参考源代码）

  

 static void async_read_handler(int fd, int event, void *data)

{

    AsyncRead *obj = (AsyncRead *)data;

 

    for (;;) {

        int n = obj->end - obj->now;

        if ((n = obj->peer->cb_read(obj->peer->ctx, obj->now, n)) <= 0) {

           // 异常处理省略……

        } else { // 正常情况处理

            obj->now += n;

            if (obj->now == obj->end) { // 接收数据完毕了就执行done，否则继续循环接收数据

                async_read_clear_handlers(obj);

                obj->done(obj->opaque);

                return;

            }

        }

    }

}

利用上面的消息处理机制，Server端的reds_handle_new_link函数最终会找到具体的new_link（即：Channel）类型，然后调用此Channel注册时注册的的link回调函数。

 

link函数的主要工作

对于不同的Channel，link的工作不同，并且Display、Cursor的实现又与其他Channel有些差异，各个Channel对应的link函数如下：

SPICE_CHANNEL_DISPLAY   red_dispatcher_set_peer

SPICE_CHANNEL_CURSOR        red_dispatcher_set_cursor_peer

SPICE_CHANNEL_INPUTS        inputs_link

SPICE_CHANNEL_PLAYBACK snd_set_playback_peer

SPICE_CHANNEL_RECORD        snd_set_record_peer

link最主要的工作之一就是网络连接的处理，即选择网络事件处理模型，设置网络事件响应函数等。spice用了两种模型：select、epoll

 

1）DisplayChannel的link实现：

Display的实现中引入了一个dispatcher，实现了各种对外的接口，接口本身大都不做实际工作，主要负责消息转发。

QXL_INTERFACE的初始化函数red_dispatcher_init会启动一个专门的工作线程red_worker_main，此线程有三个职责，其中之一就是接收dispatcher接口转发过来的消息，并进行实际的消息处理工作。dispatcher和工作线程之间的通信是通过一个socketpair，利用epoll模型机型通信。

此处link函数的实现同样也是通过dispatcher接口red_dispatcher_set_peer将RED_WORKER_MESSAGE_DISPLAY_CONNECT消息发送给red_worker_main，

red_worker_main中，epoll_wait等待事件，然后调用具体事件处理函数来处理，此处会调用handle_dev_input函数。handle_dev_input函数响应RED_WORKER_MESSAGE_DISPLAY_CONNECT消息，调用handle_new_display_channel进行具体link工作（简化版本）：

static void handle_new_display_channel(RedWorker *worker, RedsStreamContext *peer, int migrate)

{

    DisplayChannel *display_channel;

    size_t stream_buf_size;

 

     // 先断开原来的Channel连接，所做工作基本与此函数后面的工作相反

    red_disconnect_display((RedChannel *)worker->display_channel);

 

    // __new_channel函数会new一个RedChannel，并用该函数的参数初始化RedChannel的成员

    // RedChannel数据成员比较多，只拣最主要的说明一下：

// struct RedChannel {

//     EventListener listener;     // 事件触发器，网络事件处理用

//     spice_parse_channel_func_t parser; // 用途待查，网络通信解码器？？

//     struct RedWorker *worker; // 用以保存RedWorker指针

//     RedsStreamContext *peer;  // 用以保存RedsStreamContext指针，此指针在响应客户端连接时创建，网络通信的主要处理对象

//

//     Ring pipe; // 用途待查明，声明为Ring，表明是一个链表，而非一个链表内的一项。如果声明为RingItem，表明其容器为一个Item

//

//     disconnect_channel_proc disconnect;  // 下面四个是回调函数

//     hold_item_proc hold_item;       // 针对不同的Channel有不同的实现

//     release_item_proc release_item;    // 通过__new_channel函数

//     handle_message_proc handle_message; // 的参数传入来初始化

// };

// 初始化上述结构后，__new_channel调用

// epoll_ctl(worker->epoll, EPOLL_CTL_ADD, peer->socket, &event)

// 将该channel对应的网络连接socket加入到red_worker_main的epoll事件监听// 列表中，以在red_worker_main中处理此Channel的网络事件

if (!(display_channel = (DisplayChannel *)__new_channel(worker,

 sizeof(*display_channel),SPICE_CHANNEL_DISPLAY, peer,migrate,

 handle_channel_events,

red_disconnect_display,

display_channel_hold_item,

display_channel_release_item,

display_channel_handle_message))) {

        return;

    }

 

    ring_init(&display_channel->palette_cache_lru);

    red_display_init_streams(display_channel);

    red_display_share_stream_buf(display_channel);

    red_display_init_glz_data(display_channel);

    worker->display_channel = display_channel;

 

    on_new_display_channel(worker);

}

2）CursorChannel的link实现：

工作流程与DisplayChannel一样，通过dispatcher将消息发送给工作线程处理。

消息：RED_WORKER_MESSAGE_CURSOR_CONNECT

处理函数：red_connect_cursor，所做工作基本一样：

 

static void red_connect_cursor(RedWorker *worker, RedsStreamContext *peer, int migrate)

{

    CursorChannel *channel;

    red_disconnect_cursor((RedChannel *)worker->cursor_channel);

if (!(channel = (CursorChannel *)__new_channel(worker, sizeof(*channel),

           SPICE_CHANNEL_CURSOR, peer, migrate,

handle_channel_events,

red_disconnect_cursor,

cursor_channel_hold_item,

cursor_channel_release_item,

channel_handle_message))) {

        return;

    }

 

    ring_init(&channel->cursor_cache_lru);

    worker->cursor_channel = channel;

    on_new_cursor_channel(worker);

}

3）InputChannel的link实现：

与上述两者不同的是，InputChannel的网络处理放在了主循环的select模型中处理：

static void inputs_link(Channel *channel, RedsStreamContext *peer,

int migration,int num_common_caps, uint32_t *common_caps, int num_caps,

uint32_t *caps)

{

    InputsState *inputs_state;

    inputs_state = spice_new0(InputsState, 1);

 

    // 一些初始化……

 

    peer->watch = core->watch_add(peer->socket, SPICE_WATCH_EVENT_READ,

                                  inputs_event, inputs_state);

 

    SpiceMarshaller *m;

    SpiceMsgInputsInit inputs_init;

    m = marshaller_new_for_outgoing(inputs_state, SPICE_MSG_INPUTS_INIT);

    inputs_init.keyboard_modifiers = kbd_get_leds(keyboard);

    spice_marshall_msg_inputs_init(m, &inputs_init);

}

4）PLAYBACK、Record Channel的link实现：

大致流程与Display一样，但网络处理与InputChannel一样，是通过watch_add方式采用select模型。

static void snd_set_record_peer(Channel *channel, RedsStreamContext *peer,

int migration, int num_common_caps, uint32_t *common_caps, int num_caps,

                                uint32_t *caps)

{

    snd_disconnect_channel(worker->connection);

if (!(record_channel = (RecordChannel *)__new_channel(worker,

 sizeof(*record_channel),SPICE_CHANNEL_RECORD,peer,migration,

        snd_record_send,

snd_record_handle_message,

snd_record_on_message_done,

snd_record_cleanup))) {

        goto error_2;

    }

 

    on_new_record_channel(worker);

 

    if (worker->active) {

        spice_server_record_start(st->sin);

    }

    snd_record_send(worker->connection);

    return;

}

3、Channel建立起来之后，服务端开始推送数据到客户端，同时响应客户端的请求，这里涉及到两大类不同的交互：用户交互请求、实时数据推送

1）用户交互请求

用户交互请求都通过InputChannel进行网络数据收发处理，上面分析过，InputChannel是通过watch_add的方式利用select模型在主循环中收发网络信息的。

   InputChannel link建立时，向系统注册了自己的消息处理函数：

   watch_add(peer->socket, SPICE_WATCH_EVENT_READ, inputs_event,

 inputs_state) // 从第二个参数可以看出，InputChannel只关心读事件

   网络事件到达时，系统将调用input_event函数，同时将inputs_state作为其opaque参数传入。

   input_event中对于输入、输出事件分别调用handle_incoming、handle_outgoing来进行处理，因此inputs_state比较重要的成员包括InComingHandler和OutGoinghandler，以及负责网络通信的RedsStreamContext。对于InputChannel来说，OutGoinghandler目前是没有用的。

   InComingHandler中最主要的成员是handle_message函数，此处对应于inputs_handle_input，主要响应客户端发来的键盘鼠标消息：

static void inputs_handle_input(void *opaque, size_t size, uint32_t type, void *message)

{

    InputsState *state = (InputsState *)opaque;

    uint8_t *buf = (uint8_t *)message;

    SpiceMarshaller *m;

 

    switch (type) {

    case SPICE_MSGC_INPUTS_KEY_DOWN:    

    case SPICE_MSGC_INPUTS_KEY_UP:

    case SPICE_MSGC_INPUTS_MOUSE_MOTION:

    case SPICE_MSGC_INPUTS_MOUSE_POSITION:

    case SPICE_MSGC_INPUTS_MOUSE_PRESS:

    case SPICE_MSGC_INPUTS_MOUSE_RELEASE:

    case SPICE_MSGC_INPUTS_KEY_MODIFIERS:

    case SPICE_MSGC_DISCONNECTING:

        break;

    default:

        red_printf("unexpected type %d", type);

    }

}

   2）实时数据推送

   主要是音频、视频数据从Server端实时推送到Client。

   视频包括两部分：Screen、Cursor

   音频包括两部分：Playback、Record(Record属于Client -> Server)  

   Server端视频部分涉及到三大模块：Qxl Qemu device、Qxl Guest OS driver、Channel处理线程red_worker_man

   关于Qxl Device、Qxl Driver将单独分析，此处只关注Channel部分，即red_worker_main的工作。

   Server端音频部分相对简单一些，应该全部都在音频设备中完成：（这里只关注了ac97，其他音频设备工作机制类似）

   AUD_register_card() ->

   audio_init() ->qemu_new_timer (vm_clock, audio_timer, s)

// 注意，audio_init 调用qemu_new_timer只是初始化glob_audio_state的timer，而不

// 是立即执行audio_timer函数，因为此时glob_audio_state这个关键的全局数据对象

// 还没有初始化完，audio_timer函数执行时所需要的很多信息要等glob_audio_state

// 初始化完后才能正常访问。

   ac97_on_reset() -> ac97_on_reset() -> mixer_reset() -> reset_voices() ->

        {open_voice(这里注册VDI接口), AUD_set_active_out/in}

->audio_reset_timer() 激活timer

 

   AUD_register_card 和 ac97_on_reset 是在ac97_initfn函数中顺序调用的，即：

    AUD_register_card()：先做初始化，主要是初始化全局对象，glob_audio_state

    ac97_on_reset() ：然后开始干活，包括注册VDI，注册/激活timer等

 

   audio_timer() -> audio_run() --> audio_run_out() --> >pcm_ops->run_out --> line_out_run/line_in_run

  （注意，timer函数本身不是一个循环，而是被循环调用，关于timer工作机制参照文档02）

 

   具体的执行部分在line_out_run/line_in_run  

   音频、视频的工作线程：red_worker_main、line_out_run/line_in_run

      1) 音频输出：line_out_run

      音频部分会调用spice的几个接口：

void spice_server_playback_start(SpicePlaybackInstance *sin);

void spice_server_playback_stop(SpicePlaybackInstance *sin);

void spice_server_playback_get_buffer(SpicePlaybackInstance *sin, uint32_t **samples, uint32_t *nsamples);

void spice_server_playback_put_samples(SpicePlaybackInstance *sin, uint32_t *samples);

AUD_set_active_out 时会调用 spice_server_playback_start

main_loop循环执行timer，timer调用line_out_run函数，此函数大致流程如下：

static int line_out_run (HWVoiceOut *hw, int live)

{

    SpiceVoiceOut *out = container_of (hw, SpiceVoiceOut, hw);

    decr = rate_get_samples (&hw->info, &out->rate);

 

    while (samples) {

        if (!out->frame) {

            spice_server_playback_get_buffer (&out->sin, &out->frame, &out->fsize); // 从spice中获取缓冲区

            out->fpos = out->frame;

        }

        if (out->frame) {

            hw->clip (out->fpos, hw->mix_buf + rpos, len); // 虚拟声卡捕获音频数据应该是放在mix_buf中

            out->fsize -= len;

            out->fpos  += len;

            if (out->fsize == 0) {

                spice_server_playback_put_samples (&out->sin, out->frame);

// 往缓冲区写数据，实际会将数据发送到客户端

                out->frame = out->fpos = NULL;

            }

        }

        rpos = (rpos + len) % hw->samples;

        samples -= len;

    }

}

    2) 视频输出：

    A、red_worker_main （on spice server）

   

 void *red_worker_main(void *arg)

{

    RedWorker worker;

 

    red_init(&worker, (WorkerInitData *)arg);

    red_init_quic(&worker);

    red_init_lz(&worker);

    red_init_jpeg(&worker);

    red_init_zlib(&worker);

    worker.epoll_timeout = INF_EPOLL_WAIT;

    for (;;) {

        num_events = epoll_wait(worker.epoll, events, MAX_EPOLL_SOURCES, worker.epoll_timeout);

        red_handle_streams_timout(&worker);

 

        if (worker.display_channel && worker.display_channel->glz_dict) {

              red_display_handle_glz_drawables_to_free(worker.display_channel);

        }

 

for (event = events, end = event + num_events; event < end; event++) {

            EventListener *evt_listener = (EventListener *)event->data.ptr;

 

            if (evt_listener->refs > 1) {

                evt_listener->action(evt_listener, event->events);

                if (--evt_listener->refs) {

                    continue;

                }

            }

            free(evt_listener); // refs == 0 , release it!

        }

 

        if (worker.running) {

            int ring_is_empty;

// 处理Cursor command，从虚拟设备中获取数据

            red_process_cursor(&worker, MAX_PIPE_SIZE, &ring_is_empty);

// 处理Display command，从虚拟设备中获取实时数据

            red_process_commands(&worker, MAX_PIPE_SIZE,

&ring_is_empty);

}

        red_push(&worker); // 往客户端push显示命令

    }

    red_printf("exit");

    return 0;

}

二、客户端Channel实现

1、Channel类介绍

客户端Channel通过基类RedChannel进行了基本功能的封装，该基类的继承层也非常深：

RedChannel: public RedChannelBase: public RedPeer: protected EventSources::Socket: public EventSource

其他具体的Channel则派生于RedChannel，各基类的功能函数如下（竖排）：

RedChannel:public RedChannelBase:  public RedPeer:  protected EventSources::Socket:public EventSource

start         get_type        connect_unsecure     get_socket() = 0       action

connect       get_id          connect_secure  

disconnect    connect         disconnect

recive                        do_send

post_message                  send

get_message_handler           recive

worker_main                     

Message处理：_message_handler

run

可以简单区分一下每个基类的职责：

RedChannel：开启工作线程，分发、处理消息

RedChannelBase：维护type、id信息，连接网络

RedPeer：网络数据收发处理

EventSources::Socket：Socket类型的事件虚基类

EventSources：事件资源公共基类

 

2、消息处理

客户端内部实现了消息处理机制，不看懂消息处理机制，无法真正理解Client的执行流程，下面是消息处理实现相关的类：

基类：

class RedChannel::MessageHandler {

public:

    MessageHandler() {}

    virtual ~MessageHandler() {}

    virtual void handle_message(RedPeer::CompoundInMessage& message) = 0;

};

消息模板：

template <class HandlerClass, unsigned int channel_id>

class MessageHandlerImp: public RedChannel::MessageHandler {

public:

    MessageHandlerImp(HandlerClass& obj);

    ~MessageHandlerImp() { delete [] _handlers; };

    virtual void handle_message(RedPeer::CompoundInMessage& message);

    typedef void (HandlerClass::*Handler)(RedPeer::InMessage* message);

    void set_handler(unsigned int id, Handler handler);

 

private:

    HandlerClass& _obj;

    unsigned int _max_messages;

    spice_parse_channel_func_t _parser;

    Handler *_handlers;

};

消息实例：

class MainChannelLoop: public MessageHandlerImp<RedClient, SPICE_CHANNEL_MAIN> {

public:

    MainChannelLoop(RedClient& client): MessageHandlerImp<RedClient, SPICE_CHANNEL_MAIN>(client) {}

};

模板类中封装了消息处理的公共函数，对于不同的Channel，需要实例化自己的消息处理类，以MAIN_CHANNLE为例，看看Client的Channel建立及消息处理机制实现。Client中MAIN_CHANNEL通过RedClient类进行封装，其建立及消息机制初始化过程如下：

1） Application默认构造函数执行时，构造其RedClient成员_client

2）实例化基类的 RedChannel::_message_handler

       RedClient::RedClient(Application& application)

        : RedChannel(*this, SPICE_CHANNEL_MAIN,0, new MainChannelLoop(*this)) …

3）初始化MessageHandler的回调函数

MainChannelLoop* message_loop =

             static_cast<MainChannelLoop*>(get_message_handler());

      message_loop->set_handler(MSG_MIGRATE, &RedClient::handle_migrate);

      message_loop->set_handler(MSG_LIST, &RedClient::handle_channels);

       ……

4） 启动工作线程

start(){

            _worker = new Thread(RedChannel::worker_main, this);

            ……

      }

5） 工作线程中处理消息

工作线程起来后会wait condition，RedClient的condition由LoginDialog的handle_connect函数调用application().connect来激活。

注：LoginDialog是用CEGUI库写的界面，button 响应函数的写法如下：

    add_bottom_button(wnd, // 父窗

res_get_string(STR_BUTTON_CONNECT),                         CEGUI::Event::Subscriber(&LoginDialog::handle_connect, this),//响应函数

        x_pos);

工作线程详细执行流程：

RedChannel::worker_main(){

        RedChannel::run(){

       // 这里用了condition 相关的pthread库函数来进行信号控制

// pthread_cond_signal、pthread_cond_wait……

       // 工作线程启动后会等待RedClient的connect、disconnect、quit等操作

       // RedClient的connect会pthread_cond_signal(cond)

       _action_cond.wait --》 pthread_cond_wait(cond) // 等吧

 

       // _action 用来标识等来的是个什么操作，一共有三个：

// CONNECT_ACTION、DISCONNECT_ACTION、QUIT_ACTION

       // 后面两个是做一些清理工作，主要是第一个：CONNECT_ACTION

       case _action of CONNECT_ACTION:{

          RedChannelBase::connect // 调用基类的connect，进行网络连接

          _marshallers = spice_message_marshallers_get // 初始化marshallers

          on_connect --> _migrate.add_channel()

          on_event {send_messages,recive_messages}

       

          // ProcessLoop 消息循环

          _loop.add_socket(*this); // --> add_event, 往_loop中的

// _event_sources增加event，以进行监听……

// 注意了：上面使用了EventSources中的socket类，用于网络事件的监听

// 具体方法参见代码：

// HANDLE event = CreateEvent(NULL, FALSE, FALSE, NULL); // 创建一个Event，然后：

// WSAEventSelect(socket.get_socket(), event,FD_READ | FD_WRITE | FD_CLOSE)

// 上面这个函数将event 与 socket绑定，当socket上有事件被激活时，event也将被激活

 

       _loop.run() {

           _event_sources.wait_events(){

            DWORD wait_res = MsgWaitForMultipleObjectsEx(_handles.size(),  &_handles[0], timeout_ms,                                                 QS_ALLINPUT, 0); // 此函数用来等待事件，对于同步事件，此函数返回前会修改事件状态

                       

            int event_index = wait_res - WAIT_OBJECT_0;

            _events[event_index]->action() --> RedChannel::on_event{

               send_messages(){

                get_outgoing_message

                send

               }

               recive_messages(){

                RedPeer::recive()

                on_message_recived()

                _message_handler->handle_message(*(*message)){

                   (_obj.*_handlers[type])(&main_message); // 通过实例调用其成员函数，与SetHandler是所赋的成员函数对象一致

                }

               }

            }

           }   

    3、DisplayChannel、CursorChannel、InputChannel的创建启动过程

    1）注册ChannelFactory

void Application::register_channels()

{

    if (_enabled_channels[SPICE_CHANNEL_DISPLAY]) { //注册channelFactory

        _client.register_channel_factory(DisplayChannel::Factory());

    }

    ……

}

2） 创建：响应服务端发过来的SPICE_MSG_MAIN_CHANNELS_LIST消息，调用handle_channels，创建各个channel

void RedClient::handle_channels(RedPeer::InMessage* message)

{

    SpiceMsgChannels *init = (SpiceMsgChannels *)message->data();

    SpiceChannelId* channels = init->channels;

    for (unsigned int i = 0; i < init->num_of_channels; i++) {

        create_channel(channels[i].type, channels[i].id);

    }

}

3）启动：与RedClient类似，这里在create_channel中，创建channel后，调用start函数启动channel主线程worker_main

void RedClient::create_channel(uint32_t type, uint32_t id)

{

    ChannelFactory* factory = find_factory(type);

    RedChannel* channel = factory->construct(*this, id);

    _channels.push_back(channel);

    channel->start();   // 创建工作线程

    channel->connect(); // 工作线程会等待CONNECT_ACTION condition来激活线程

_migrate.add_channel(new MigChannel(type, id, channel->get_common_caps(), channel->get_caps()));

}