summaryrefslogtreecommitdiffstats
path: root/server/reds.c
diff options
context:
space:
mode:
Diffstat (limited to 'server/reds.c')
-rw-r--r--server/reds.c4996
1 files changed, 4996 insertions, 0 deletions
diff --git a/server/reds.c b/server/reds.c
new file mode 100644
index 00000000..067304d7
--- /dev/null
+++ b/server/reds.c
@@ -0,0 +1,4996 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <limits.h>
+#include <time.h>
+#include <pthread.h>
+#include <sys/mman.h>
+#include <sys/user.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include <openssl/bio.h>
+#include <openssl/pem.h>
+#include <openssl/bn.h>
+#include <openssl/rsa.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+#include "spice.h"
+#include "reds.h"
+#include "red.h"
+#include "vd_agent.h"
+
+#include "red_common.h"
+#include "red_dispatcher.h"
+#include "snd_worker.h"
+#include "reds_stat.h"
+#include "stat.h"
+#include "ring.h"
+#include "config.h"
+
+CoreInterface *core = NULL;
+static MigrationInterface *mig = NULL;
+static KeyboardInterface *keyboard = NULL;
+static MouseInterface *mouse = NULL;
+static TabletInterface *tablet = NULL;
+static VDIPortInterface *vdagent = NULL;
+
+#define MIGRATION_NOTIFY_SPICE_KEY "spice_mig_ext"
+
+#define REDS_MIG_VERSION 1
+#define REDS_MIG_CONTINUE 1
+#define REDS_MIG_ABORT 2
+
+#define REDS_AGENT_WINDOW_SIZE 10
+#define REDS_TOKENS_TO_SEND 5
+#define REDS_NUM_INTERNAL_AGENT_MESSAGES 1
+#define REDS_VDI_PORT_NUM_RECIVE_BUFFS 5
+#define REDS_MAX_SEND_IOVEC 100
+
+#define NET_TEST_WARMUP_BYTES 0
+#define NET_TEST_BYTES (1024 * 250)
+
+static int spice_port = -1;
+static int spice_secure_port = -1;
+
+static struct in_addr spice_addr = {INADDR_ANY};
+static int ticketing_enabled = 1; //Ticketing is enabled by default
+static pthread_mutex_t *lock_cs;
+static long *lock_count;
+uint32_t streaming_video = TRUE;
+image_compression_t image_compression = IMAGE_COMPRESS_AUTO_GLZ;
+int agent_mouse = TRUE;
+
+static void openssl_init();
+
+#define MIGRATE_TIMEOUT (1000 * 10) /* 10sec */
+#define PING_INTERVAL (1000 * 10)
+#define KEY_MODIFIERS_TTL (1000 * 2) /*2sec*/
+#define MM_TIMER_GRANULARITY_MS (1000 / 30)
+#define MM_TIME_DELTA 400 /*ms*/
+
+// approximate max recive message size
+#define RECIVE_BUF_SIZE \
+ (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) * RED_AGENT_MAX_DATA_SIZE)
+
+#define SEND_BUF_SIZE 4096
+
+#define SCROLL_LOCK_SCAN_CODE 0x46
+#define NUM_LOCK_SCAN_CODE 0x45
+#define CAPS_LOCK_SCAN_CODE 0x3a
+
+typedef struct IncomingHandler {
+ void *opaque;
+ int shut;
+ uint8_t buf[RECIVE_BUF_SIZE];
+ uint32_t end_pos;
+ void (*handle_message)(void *opaque, RedDataHeader *message);
+} IncomingHandler;
+
+typedef struct OutgoingHandler {
+ void *opaque;
+ uint8_t buf[SEND_BUF_SIZE];
+ uint8_t *now;
+ uint32_t length;
+ void (*select)(void *opaque, int select);
+ void (*may_write)(void *opaque);
+} OutgoingHandler;
+
+typedef struct TicketAuthentication {
+ char password[RED_MAX_PASSWORD_LENGTH];
+ time_t expiration_time;
+} TicketAuthentication;
+
+static TicketAuthentication taTicket;
+
+typedef struct TicketInfo {
+ RSA *rsa;
+ int rsa_size;
+ BIGNUM *bn;
+ RedLinkEncryptedTicket encrypted_ticket;
+} TicketInfo;
+
+typedef struct MonitorMode {
+ uint32_t x_res;
+ uint32_t y_res;
+} MonitorMode;
+
+typedef struct RedsOutItem RedsOutItem;
+struct RedsOutItem {
+ RingItem link;
+ void (*prepare)(RedsOutItem *item, struct iovec* vec, int *len);
+ void (*release)(RedsOutItem *item);
+};
+
+typedef struct VDIReadBuf {
+ RedsOutItem out_item;
+ int len;
+ RedDataHeader header;
+ uint8_t data[RED_AGENT_MAX_DATA_SIZE];
+} VDIReadBuf;
+
+enum {
+ VDI_PORT_READ_STATE_READ_HADER,
+ VDI_PORT_READ_STATE_GET_BUFF,
+ VDI_PORT_READ_STATE_READ_DATA,
+};
+
+enum {
+ VDP_CLIENT_PORT = 1,
+ VDP_SERVER_PORT,
+};
+
+typedef struct __attribute__ ((__packed__)) VDIChunkHeader {
+ uint32_t port;
+ uint32_t size;
+} VDIChunkHeader;
+
+typedef struct VDIPortState {
+ VDIPortPlug plug;
+ VDObjectRef plug_ref;
+ uint32_t plug_generation;
+
+ uint32_t num_tokens;
+ uint32_t num_client_tokens;
+ Ring external_bufs;
+ Ring internal_bufs;
+ Ring write_queue;
+
+ Ring read_bufs;
+ uint32_t read_state;
+ uint32_t message_recive_len;
+ uint8_t *recive_pos;
+ uint32_t recive_len;
+ VDIReadBuf *current_read_buf;
+
+ VDIChunkHeader vdi_chunk_header;
+
+ int client_agent_started;
+ uint32_t send_tokens;
+} VDIPortState;
+
+typedef struct InputsState {
+ Channel *channel;
+ RedsStreamContext *peer;
+ uint8_t buf[RECIVE_BUF_SIZE];
+ uint32_t end_pos;
+ IncomingHandler in_handler;
+ OutgoingHandler out_handler;
+ VDAgentMouseState mouse_state;
+ int pending_mouse_event;
+ uint32_t motion_count;
+ uint64_t serial; //migrate me
+} InputsState;
+
+typedef struct RedsOutgoingData {
+ Ring pipe;
+ RedsOutItem *item;
+ int vec_size;
+ struct iovec vec_buf[REDS_MAX_SEND_IOVEC];
+ struct iovec *vec;
+} RedsOutgoingData;
+
+enum NetTestStage {
+ NET_TEST_STAGE_INVALID,
+ NET_TEST_STAGE_WARMUP,
+ NET_TEST_STAGE_LATENCY,
+ NET_TEST_STAGE_RATE,
+};
+
+#ifdef RED_STATISTICS
+
+#define REDS_MAX_STAT_NODES 100
+#define REDS_STAT_SHM_SIZE (sizeof(RedsStat) + REDS_MAX_STAT_NODES * sizeof(StatNode))
+
+typedef struct RedsStatValue {
+ uint32_t value;
+ uint32_t min;
+ uint32_t max;
+ uint32_t average;
+ uint32_t count;
+} RedsStatValue;
+
+#endif
+
+typedef struct RedsState {
+ int listen_socket;
+ int secure_listen_socket;
+ RedsStreamContext *peer;
+ int disconnecting;
+ uint32_t link_id;
+ uint64_t serial; //migrate me
+ VDIPortState agent_state;
+ InputsState *inputs_state;
+
+ VDObjectRef mig_notifier;
+ int mig_wait_connect;
+ int mig_wait_disconnect;
+ int mig_inprogress;
+ int mig_target;
+ int num_of_channels;
+ IncomingHandler in_handler;
+ RedsOutgoingData outgoing;
+ Channel *channels;
+ int mouse_mode;
+ int is_client_mouse_allowed;
+ int dispatcher_allows_client_mouse;
+ MonitorMode monitor_mode;
+ VDObjectRef mig_timer;
+ VDObjectRef key_modifiers_timer;
+ VDObjectRef mm_timer;
+
+ TicketAuthentication taTicket;
+ SSL_CTX *ctx;
+
+#ifdef RED_STATISTICS
+ char *stat_shm_name;
+ RedsStat *stat;
+ pthread_mutex_t stat_lock;
+ RedsStatValue roundtrip_stat;
+ VDObjectRef ping_timer;
+ int ping_interval;
+#endif
+ uint32_t ping_id;
+ uint32_t net_test_id;
+ int net_test_stage;
+} RedsState;
+
+uint64_t bitrate_per_sec = ~0;
+static uint64_t letancy = 0;
+
+static RedsState *reds = NULL;
+
+typedef struct AsyncRead {
+ RedsStreamContext *peer;
+ void *opaque;
+ uint8_t *now;
+ uint8_t *end;
+ int active_file_handlers;
+ void (*done)(void *opaque);
+ void (*error)(void *opaque, int err);
+} AsyncRead;
+
+typedef struct RedLinkInfo {
+ RedsStreamContext *peer;
+ AsyncRead asyc_read;
+ RedLinkHeader link_header;
+ RedLinkMess *link_mess;
+ int mess_pos;
+ TicketInfo tiTicketing;
+} RedLinkInfo;
+
+typedef struct VDIPortBuf VDIPortBuf;
+struct __attribute__ ((__packed__)) VDIPortBuf {
+ RingItem link;
+ uint8_t *now;
+ int write_len;
+ void (*free)(VDIPortBuf *buf);
+ VDIChunkHeader chunk_header; //start send from &chunk_header
+};
+
+typedef struct __attribute__ ((__packed__)) VDAgentExtBuf {
+ VDIPortBuf base;
+ uint8_t buf[RED_AGENT_MAX_DATA_SIZE];
+ VDIChunkHeader migrate_overflow;
+} VDAgentExtBuf;
+
+typedef struct __attribute__ ((__packed__)) VDInternalBuf {
+ VDIPortBuf base;
+ VDAgentMessage header;
+ union {
+ VDAgentMouseState mouse_state;
+ }
+ u;
+ VDIChunkHeader migrate_overflow;
+} VDInternalBuf;
+
+typedef struct RedSSLParameters {
+ char keyfile_password[256];
+ char certs_file[256];
+ char private_key_file[256];
+ char ca_certificate_file[256];
+ char dh_key_file[256];
+ char ciphersuite[256];
+} RedSSLParameters;
+
+#define CHANNEL_SECURITY_NON (1 << 0)
+#define CHANNEL_SECURITY_SSL (1 << 1)
+
+typedef struct ChannelSecurityOptions ChannelSecurityOptions;
+struct ChannelSecurityOptions {
+ uint32_t channel_id;
+ uint32_t options;
+ ChannelSecurityOptions *next;
+};
+
+typedef struct PingItem {
+ RedsOutItem base;
+ RedDataHeader header;
+ RedPing ping;
+ int size;
+} PingItem;
+
+static uint8_t zero_page[PAGE_SIZE] = {0};
+
+static void reds_main_write(void *data);
+static void reds_push();
+
+static ChannelSecurityOptions *channels_security = NULL;
+static int default_channel_security = CHANNEL_SECURITY_NON | CHANNEL_SECURITY_SSL;
+
+static RedSSLParameters ssl_parameters;
+
+
+void (*log_proc)(CoreInterface *core, LogLevel level, const char* component,
+ const char* format, ...) = NULL;
+
+#define LOG_MESSAGE(level, format, ...) { \
+ if (log_proc) { \
+ log_proc(core, level, "spice", format, ## __VA_ARGS__ ); \
+ } \
+}
+
+static ChannelSecurityOptions *find_channel_security(int id)
+{
+ ChannelSecurityOptions *now = channels_security;
+ while (now && now->channel_id != id) {
+ now = now->next;
+ }
+ return now;
+}
+
+static int reds_write(void *ctx, void *buf, size_t size)
+{
+ int return_code;
+ int sock = (long)ctx;
+ size_t count = size;
+
+ return_code = write(sock, buf, count);
+
+ return (return_code);
+}
+
+static int reds_read(void *ctx, void *buf, size_t size)
+{
+ int return_code;
+ int sock = (long)ctx;
+ size_t count = size;
+
+ return_code = read(sock, buf, count);
+
+ return (return_code);
+}
+
+static int reds_free(RedsStreamContext *peer)
+{
+ close(peer->socket);
+ free(peer);
+ return 0;
+}
+
+static int reds_ssl_write(void *ctx, void *buf, size_t size)
+{
+ int return_code;
+ int ssl_error;
+ SSL *ssl = ctx;
+
+ return_code = SSL_write(ssl, buf, size);
+
+ if (return_code < 0) {
+ ssl_error = SSL_get_error(ssl, return_code);
+ }
+
+ return (return_code);
+}
+
+static int reds_ssl_read(void *ctx, void *buf, size_t size)
+{
+ int return_code;
+ int ssl_error;
+ SSL *ssl = ctx;
+
+ return_code = SSL_read(ssl, buf, size);
+
+ if (return_code < 0) {
+ ssl_error = SSL_get_error(ssl, return_code);
+ }
+
+ return (return_code);
+}
+
+static int reds_ssl_writev(void *ctx, const struct iovec *vector, int count)
+{
+ int i;
+ int n;
+ int return_code = 0;
+ int ssl_error;
+ SSL *ssl = ctx;
+
+ for (i = 0; i < count; ++i) {
+ n = SSL_write(ssl, vector[i].iov_base, vector[i].iov_len);
+ if (n <= 0) {
+ ssl_error = SSL_get_error(ssl, n);
+ if (return_code <= 0) {
+ return n;
+ } else {
+ break;
+ }
+ } else {
+ return_code += n;
+ }
+ }
+
+ return return_code;
+}
+
+static int reds_ssl_free(RedsStreamContext *peer)
+{
+ SSL_free(peer->ssl);
+ close(peer->socket);
+ free(peer);
+ return 0;
+}
+
+static void __reds_release_link(RedLinkInfo *link)
+{
+ ASSERT(link->peer);
+ core->set_file_handlers(core, link->peer->socket, NULL, NULL, NULL);
+ free(link->link_mess);
+ BN_free(link->tiTicketing.bn);
+ if (link->tiTicketing.rsa) {
+ RSA_free(link->tiTicketing.rsa);
+ }
+ free(link);
+}
+
+static inline void reds_release_link(RedLinkInfo *link)
+{
+ RedsStreamContext *peer = link->peer;
+ __reds_release_link(link);
+ peer->cb_free(peer);
+}
+
+static void reds_do_disable_ticketing(void)
+{
+ ticketing_enabled = 0;
+ memset(taTicket.password, 0, sizeof(taTicket.password));
+ core->term_printf(core, "Ticketing is now disabled.\n");
+}
+
+static char *base64decode(const char *input, int length)
+{
+ BIO *b64;
+ BIO *bmem;
+ int n;
+ char *buffer = (char *)malloc(length);
+ memset(buffer, 0, length);
+
+ char *inbuffer = (char *)malloc(length + 1);
+ memset(inbuffer, 0, length + 1);
+ memcpy(inbuffer, input, length);
+ inbuffer[length] = '\n';
+
+ b64 = BIO_new(BIO_f_base64());
+ bmem = BIO_new_mem_buf(inbuffer, length + 1);
+
+ if (b64 != NULL && bmem != NULL) {
+ bmem = BIO_push(b64, bmem);
+
+ n = BIO_read(bmem, buffer, length);
+
+ if (n != 0) {
+ buffer[n - 1] = '\0';
+ } else {
+ free(buffer);
+ buffer = NULL;
+ }
+ } else {
+ free(buffer);
+ buffer = NULL;
+ }
+
+ BIO_free_all(bmem);
+
+ return buffer;
+}
+
+static void reds_do_info_ticket(void)
+{
+ core->term_printf(core, "Ticket Information:");
+ if (ticketing_enabled) {
+ if (strlen(taTicket.password) == 0) {
+ core->term_printf(core, " blocked\n");
+ } else {
+ if (taTicket.expiration_time == INT_MAX) {
+ core->term_printf(core, " expiration NEVER\n");
+ } else {
+ time_t now;
+
+ time(&now);
+ int expired = taTicket.expiration_time < now;
+ if (expired) {
+ core->term_printf(core, " expiration EXPIRED\n");
+ } else {
+ core->term_printf(core, " expiration %s\n",
+ ctime((time_t *)&(taTicket.expiration_time)));
+ }
+ }
+ }
+ } else {
+ core->term_printf(core, " disabled\n");
+ }
+}
+
+static struct iovec *reds_iovec_skip(struct iovec vec[], int skip, int *vec_size)
+{
+ struct iovec *now = vec;
+
+ while (skip && skip >= now->iov_len) {
+ skip -= now->iov_len;
+ --*vec_size;
+ now++;
+ }
+ now->iov_base = (uint8_t *)now->iov_base + skip;
+ now->iov_len -= skip;
+ return now;
+}
+
+#ifdef RED_STATISTICS
+
+#define STAT_TAB_LEN 4
+#define STAT_VALUE_TABS 7
+
+static void print_stat_tree(uint32_t node_index, int depth)
+{
+ StatNode *node = &reds->stat->nodes[node_index];
+
+ if ((node->flags & STAT_NODE_MASK_SHOW) == STAT_NODE_MASK_SHOW) {
+ core->term_printf(core, "%*s%s", depth * STAT_TAB_LEN, "", node->name);
+ if (node->flags & STAT_NODE_FLAG_VALUE) {
+ core->term_printf(core, ":%*s%llu\n",
+ (STAT_VALUE_TABS - depth) * STAT_TAB_LEN - strlen(node->name) - 1, "",
+ node->value);
+ } else {
+ core->term_printf(core, "\n");
+ if (node->first_child_index != INVALID_STAT_REF) {
+ print_stat_tree(node->first_child_index, depth + 1);
+ }
+ }
+ }
+ if (node->next_sibling_index != INVALID_STAT_REF) {
+ print_stat_tree(node->next_sibling_index, depth);
+ }
+}
+
+static void do_info_statistics()
+{
+ core->term_printf(core, "Spice Statistics:\n");
+ print_stat_tree(reds->stat->root_index, 0);
+}
+
+static void do_reset_statistics()
+{
+ StatNode *node;
+ int i;
+
+ for (i = 0; i <= REDS_MAX_STAT_NODES; i++) {
+ node = &reds->stat->nodes[i];
+ if (node->flags & STAT_NODE_FLAG_VALUE) {
+ node->value = 0;
+ }
+ }
+}
+
+void insert_stat_node(StatNodeRef parent, StatNodeRef ref)
+{
+ StatNode *node = &reds->stat->nodes[ref];
+ uint32_t pos = INVALID_STAT_REF;
+ uint32_t node_index;
+ uint32_t *head;
+ StatNode *n;
+
+ node->first_child_index = INVALID_STAT_REF;
+ head = (parent == INVALID_STAT_REF ? &reds->stat->root_index :
+ &reds->stat->nodes[parent].first_child_index);
+ node_index = *head;
+ while (node_index != INVALID_STAT_REF && (n = &reds->stat->nodes[node_index]) &&
+ strcmp(node->name, n->name) > 0) {
+ pos = node_index;
+ node_index = n->next_sibling_index;
+ }
+ if (pos == INVALID_STAT_REF) {
+ node->next_sibling_index = *head;
+ *head = ref;
+ } else {
+ n = &reds->stat->nodes[pos];
+ node->next_sibling_index = n->next_sibling_index;
+ n->next_sibling_index = ref;
+ }
+}
+
+StatNodeRef stat_add_node(StatNodeRef parent, const char *name, int visible)
+{
+ StatNodeRef ref;
+ StatNode *node;
+
+ ASSERT(name && strlen(name) > 0);
+ if (strlen(name) >= sizeof(node->name)) {
+ return INVALID_STAT_REF;
+ }
+ pthread_mutex_lock(&reds->stat_lock);
+ ref = (parent == INVALID_STAT_REF ? reds->stat->root_index :
+ reds->stat->nodes[parent].first_child_index);
+ while (ref != INVALID_STAT_REF) {
+ node = &reds->stat->nodes[ref];
+ if (strcmp(name, node->name)) {
+ ref = node->next_sibling_index;
+ } else {
+ pthread_mutex_unlock(&reds->stat_lock);
+ return ref;
+ }
+ }
+ if (reds->stat->num_of_nodes >= REDS_MAX_STAT_NODES || reds->stat == NULL) {
+ pthread_mutex_unlock(&reds->stat_lock);
+ return INVALID_STAT_REF;
+ }
+ reds->stat->generation++;
+ reds->stat->num_of_nodes++;
+ for (ref = 0; ref <= REDS_MAX_STAT_NODES; ref++) {
+ node = &reds->stat->nodes[ref];
+ if (!(node->flags & STAT_NODE_FLAG_ENABLED)) {
+ break;
+ }
+ }
+ ASSERT(!(node->flags & STAT_NODE_FLAG_ENABLED));
+ node->value = 0;
+ node->flags = STAT_NODE_FLAG_ENABLED | (visible ? STAT_NODE_FLAG_VISIBLE : 0);
+ strncpy(node->name, name, sizeof(node->name));
+ insert_stat_node(parent, ref);
+ pthread_mutex_unlock(&reds->stat_lock);
+ return ref;
+}
+
+void stat_remove(StatNode *node)
+{
+ pthread_mutex_lock(&reds->stat_lock);
+ node->flags &= ~STAT_NODE_FLAG_ENABLED;
+ reds->stat->generation++;
+ reds->stat->num_of_nodes--;
+ pthread_mutex_unlock(&reds->stat_lock);
+}
+
+void stat_remove_node(StatNodeRef ref)
+{
+ stat_remove(&reds->stat->nodes[ref]);
+}
+
+uint64_t *stat_add_counter(StatNodeRef parent, const char *name, int visible)
+{
+ StatNodeRef ref = stat_add_node(parent, name, visible);
+ StatNode *node;
+
+ if (ref == INVALID_STAT_REF) {
+ return NULL;
+ }
+ node = &reds->stat->nodes[ref];
+ node->flags |= STAT_NODE_FLAG_VALUE;
+ return &node->value;
+}
+
+void stat_remove_counter(uint64_t *counter)
+{
+ stat_remove((StatNode *)(counter - offsetof(StatNode, value)));
+}
+
+static void reds_update_stat_value(RedsStatValue* stat_value, uint32_t value)
+{
+ stat_value->value = value;
+ stat_value->min = (stat_value->count ? MIN(stat_value->min, value) : value);
+ stat_value->max = MAX(stat_value->max, value);
+ stat_value->average = (stat_value->average * stat_value->count + value) /
+ (stat_value->count + 1);
+ stat_value->count++;
+}
+
+#endif
+
+void reds_register_channel(Channel *channel)
+{
+ ASSERT(reds);
+ channel->next = reds->channels;
+ reds->channels = channel;
+ reds->num_of_channels++;
+}
+
+void reds_unregister_channel(Channel *channel)
+{
+ Channel **now = &reds->channels;
+
+ while (*now) {
+ if (*now == channel) {
+ *now = channel->next;
+ reds->num_of_channels--;
+ return;
+ }
+ now = &(*now)->next;
+ }
+ red_printf("not found");
+}
+
+static Channel *reds_find_channel(uint32_t type, uint32_t id)
+{
+ Channel *channel = reds->channels;
+ while (channel && !(channel->type == type && channel->id == id)) {
+ channel = channel->next;
+ }
+ return channel;
+}
+
+static void reds_shatdown_channels()
+{
+ Channel *channel = reds->channels;
+ while (channel) {
+ channel->shutdown(channel);
+ channel = channel->next;
+ }
+}
+
+static void reds_mig_cleanup()
+{
+ if (reds->mig_inprogress) {
+ reds->mig_inprogress = FALSE;
+ reds->mig_wait_connect = FALSE;
+ reds->mig_wait_disconnect = FALSE;
+ core->disarm_timer(core, reds->mig_timer);
+ mig->notifier_done(mig, reds->mig_notifier);
+ }
+}
+
+static void reds_reset_vdp()
+{
+ VDIPortState *state = &reds->agent_state;
+
+ while (!ring_is_empty(&state->write_queue)) {
+ VDIPortBuf *buf;
+ RingItem *item;
+
+ item = ring_get_tail(&state->write_queue);
+ ring_remove(item);
+ buf = (VDIPortBuf *)item;
+ buf->free(buf);
+ }
+ state->read_state = VDI_PORT_READ_STATE_READ_HADER;
+ state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
+ state->recive_len = sizeof(state->vdi_chunk_header);
+ state->message_recive_len = 0;
+ if (state->current_read_buf) {
+ ring_add(&state->read_bufs, &state->current_read_buf->out_item.link);
+ state->current_read_buf = NULL;
+ }
+ state->client_agent_started = FALSE;
+ state->send_tokens = 0;
+}
+
+static void reds_reset_outgoing()
+{
+ RedsOutgoingData *outgoing = &reds->outgoing;
+ RingItem *ring_item;
+
+ if (outgoing->item) {
+ outgoing->item->release(outgoing->item);
+ outgoing->item = NULL;
+ }
+ while ((ring_item = ring_get_tail(&outgoing->pipe))) {
+ RedsOutItem *out_item = (RedsOutItem *)ring_item;
+ ring_remove(ring_item);
+ out_item->release(out_item);
+ }
+ outgoing->vec_size = 0;
+ outgoing->vec = outgoing->vec_buf;
+}
+
+static void reds_disconnect()
+{
+ if (!reds->peer || reds->disconnecting) {
+ return;
+ }
+
+ red_printf("");
+ LOG_MESSAGE(VD_LOG_INFO, "user disconnected");
+ reds->disconnecting = TRUE;
+ reds_reset_outgoing();
+
+ if (reds->agent_state.plug_ref != INVALID_VD_OBJECT_REF) {
+ ASSERT(vdagent);
+ vdagent->unplug(vdagent, reds->agent_state.plug_ref);
+ reds->agent_state.plug_ref = INVALID_VD_OBJECT_REF;
+ reds_reset_vdp();
+ }
+
+ reds_shatdown_channels();
+ core->set_file_handlers(core, reds->peer->socket, NULL, NULL, NULL);
+ reds->peer->cb_free(reds->peer);
+ reds->peer = NULL;
+ reds->in_handler.shut = TRUE;
+ reds->link_id = 0;
+ reds->serial = 0;
+ reds->ping_id = 0;
+ reds->net_test_id = 0;
+ reds->net_test_stage = NET_TEST_STAGE_INVALID;
+ reds->in_handler.end_pos = 0;
+
+ bitrate_per_sec = ~0;
+ letancy = 0;
+
+ reds_mig_cleanup();
+ reds->disconnecting = FALSE;
+}
+
+static void reds_mig_disconnect()
+{
+ if (reds->peer) {
+ reds_disconnect();
+ } else {
+ reds_mig_cleanup();
+ }
+}
+
+static int handle_incoming(RedsStreamContext *peer, IncomingHandler *handler)
+{
+ for (;;) {
+ uint8_t *buf = handler->buf;
+ uint32_t pos = handler->end_pos;
+ uint8_t *end = buf + pos;
+ RedDataHeader *header;
+ int n;
+ n = peer->cb_read(peer->ctx, buf + pos, RECIVE_BUF_SIZE - pos);
+ if (n <= 0) {
+ if (n == 0) {
+ return -1;
+ }
+ switch (errno) {
+ case EAGAIN:
+ return 0;
+ case EINTR:
+ break;
+ case EPIPE:
+ return -1;
+ default:
+ red_printf("%s", strerror(errno));
+ return -1;
+ }
+ } else {
+ pos += n;
+ end = buf + pos;
+ while (buf + sizeof(RedDataHeader) <= end &&
+ buf + sizeof(RedDataHeader) + (header = (RedDataHeader *)buf)->size <= end) {
+ buf += sizeof(RedDataHeader) + header->size;
+ handler->handle_message(handler->opaque, header);
+
+ if (handler->shut) {
+ return -1;
+ }
+ }
+ memmove(handler->buf, buf, (handler->end_pos = end - buf));
+ }
+ }
+}
+
+static int handle_outgoing(RedsStreamContext *peer, OutgoingHandler *handler)
+{
+ if (!handler->length) {
+ return 0;
+ }
+
+ while (handler->length) {
+ int n;
+
+ n = peer->cb_write(peer->ctx, handler->now, handler->length);
+ if (n <= 0) {
+ if (n == 0) {
+ return -1;
+ }
+ switch (errno) {
+ case EAGAIN:
+ return 0;
+ case EINTR:
+ break;
+ case EPIPE:
+ return -1;
+ default:
+ red_printf("%s", strerror(errno));
+ return -1;
+ }
+ } else {
+ handler->now += n;
+ handler->length -= n;
+ }
+ }
+ handler->select(handler->opaque, FALSE);
+ handler->may_write(handler->opaque);
+ return 0;
+}
+
+#define OUTGOING_OK 0
+#define OUTGOING_FAILED -1
+#define OUTGOING_BLOCKED 1
+
+static int outgoing_write(RedsStreamContext *peer, OutgoingHandler *handler, void *in_data,
+ int length)
+{
+ uint8_t *data = in_data;
+ ASSERT(length <= SEND_BUF_SIZE);
+ if (handler->length) {
+ return OUTGOING_BLOCKED;
+ }
+
+ while (length) {
+ int n = peer->cb_write(peer->ctx, data, length);
+ if (n < 0) {
+ switch (errno) {
+ case EAGAIN:
+ handler->length = length;
+ memcpy(handler->buf, data, length);
+ handler->select(handler->opaque, TRUE);
+ return OUTGOING_OK;
+ case EINTR:
+ break;
+ case EPIPE:
+ return OUTGOING_FAILED;
+ default:
+ red_printf("%s", strerror(errno));
+ return OUTGOING_FAILED;
+ }
+ } else {
+ data += n;
+ length -= n;
+ }
+ }
+ return OUTGOING_OK;
+}
+
+typedef struct SimpleOutItem {
+ RedsOutItem base;
+ RedDataHeader header;
+ uint8_t data[0];
+} SimpleOutItem;
+
+static void reds_prepare_basic_out_item(RedsOutItem *in_item, struct iovec* vec, int *len)
+{
+ SimpleOutItem *item = (SimpleOutItem *)in_item;
+
+ vec[0].iov_base = &item->header;
+ vec[0].iov_len = sizeof(item->header);
+ if (item->header.size) {
+ vec[1].iov_base = item->data;
+ vec[1].iov_len = item->header.size;
+ *len = 2;
+ } else {
+ *len = 1;
+ }
+}
+
+static void reds_free_basic_out_item(RedsOutItem *item)
+{
+ free(item);
+}
+
+static SimpleOutItem *new_simple_out_item(uint32_t type, int message_size)
+{
+ SimpleOutItem *item;
+
+ if (!(item = (SimpleOutItem *)malloc(sizeof(*item) + message_size))) {
+ return NULL;
+ }
+ ring_item_init(&item->base.link);
+ item->base.prepare = reds_prepare_basic_out_item;
+ item->base.release = reds_free_basic_out_item;
+
+ item->header.serial = ++reds->serial;
+ item->header.type = type;
+ item->header.size = message_size;
+ item->header.sub_list = 0;
+
+ return item;
+}
+
+static void reds_push_pipe_item(RedsOutItem *item)
+{
+ ring_add(&reds->outgoing.pipe, &item->link);
+ reds_push();
+}
+
+static void reds_send_channels()
+{
+ RedChannels* channels_info;
+ SimpleOutItem *item;
+ int message_size;
+ Channel *channel;
+ int i;
+
+ message_size = sizeof(RedChannels) + reds->num_of_channels * sizeof(RedChannelInit);
+ if (!(item = new_simple_out_item(RED_CHANNELS_LIST, message_size))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+ channels_info = (RedChannels *)item->data;
+ channels_info->num_of_channels = reds->num_of_channels;
+ channel = reds->channels;
+
+ for (i = 0; i < reds->num_of_channels; i++) {
+ ASSERT(channel);
+ channels_info->channels[i].type = channel->type;
+ channels_info->channels[i].id = channel->id;
+ channel = channel->next;
+ }
+ reds_push_pipe_item(&item->base);
+}
+
+static void reds_prepare_ping_item(RedsOutItem *in_item, struct iovec* vec, int *len)
+{
+ PingItem *item = (PingItem *)in_item;
+
+ vec[0].iov_base = &item->header;
+ vec[0].iov_len = sizeof(item->header);
+ vec[1].iov_base = &item->ping;
+ vec[1].iov_len = sizeof(item->ping);
+ int size = item->size;
+ int pos = 2;
+ while (size) {
+ ASSERT(pos < REDS_MAX_SEND_IOVEC);
+ int now = MIN(PAGE_SIZE, size);
+ size -= now;
+ vec[pos].iov_base = zero_page;
+ vec[pos].iov_len = now;
+ pos++;
+ }
+ *len = pos;
+}
+
+static void reds_free_ping_item(RedsOutItem *item)
+{
+ free(item);
+}
+
+static int send_ping(int size)
+{
+ struct timespec time_space;
+ PingItem *item;
+
+ if (!reds->peer || !(item = (PingItem *)malloc(sizeof(*item)))) {
+ return FALSE;
+ }
+ ring_item_init(&item->base.link);
+ item->base.prepare = reds_prepare_ping_item;
+ item->base.release = reds_free_ping_item;
+
+ item->header.serial = ++reds->serial;
+ item->header.type = RED_PING;
+ item->header.size = sizeof(item->ping) + size;
+ item->header.sub_list = 0;
+
+ item->ping.id = ++reds->ping_id;
+ clock_gettime(CLOCK_MONOTONIC, &time_space);
+ item->ping.timestamp = time_space.tv_sec * 1000000LL + time_space.tv_nsec / 1000LL;
+
+ item->size = size;
+ reds_push_pipe_item(&item->base);
+ return TRUE;
+}
+
+#ifdef RED_STATISTICS
+
+static void do_ping_client(const char *opt, int has_interval, int interval)
+{
+ if (!reds->peer) {
+ red_printf("not connected to peer");
+ return;
+ }
+
+ if (!opt) {
+ send_ping(0);
+ } else if (!strcmp(opt, "on")) {
+ if (has_interval && interval > 0) {
+ reds->ping_interval = interval * 1000;
+ }
+ core->arm_timer(core, reds->ping_timer, reds->ping_interval);
+ core->term_printf(core, "ping on, interval %u s\n", reds->ping_interval / 1000);
+ } else if (!strcmp(opt, "off")) {
+ core->disarm_timer(core, reds->ping_timer);
+ core->term_printf(core, "ping off\n");
+ } else {
+ core->term_printf(core, "ping invalid option: %s\n", opt);
+ return;
+ }
+}
+
+static void ping_timer_cb()
+{
+ if (!reds->peer) {
+ red_printf("not connected to peer, ping off");
+ core->disarm_timer(core, reds->ping_timer);
+ return;
+ }
+ do_ping_client(NULL, 0, 0);
+ core->arm_timer(core, reds->ping_timer, reds->ping_interval);
+}
+
+static void do_info_rtt_client()
+{
+ core->term_printf(core, "rtt=%uus, min/max/avg=%u/%u/%uus\n", reds->roundtrip_stat.value,
+ reds->roundtrip_stat.min, reds->roundtrip_stat.max,
+ reds->roundtrip_stat.average);
+}
+
+#endif
+
+static void reds_send_mouse_mode()
+{
+ RedMouseMode *mouse_mode;
+ SimpleOutItem *item;
+
+ if (!reds->peer) {
+ return;
+ }
+
+ if (!(item = new_simple_out_item(RED_MOUSE_MODE, sizeof(RedMouseMode)))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+ mouse_mode = (RedMouseMode *)item->data;
+ mouse_mode->supported_modes = RED_MOUSE_MODE_SERVER;
+ if (reds->is_client_mouse_allowed) {
+ mouse_mode->supported_modes |= RED_MOUSE_MODE_CLIENT;
+ }
+ mouse_mode->current_mode = reds->mouse_mode;
+ reds_push_pipe_item(&item->base);
+}
+
+static void reds_set_mouse_mode(uint32_t mode)
+{
+ if (reds->mouse_mode == mode) {
+ return;
+ }
+ reds->mouse_mode = mode;
+ red_dispatcher_set_mouse_mode(reds->mouse_mode);
+ reds_send_mouse_mode();
+}
+
+static void reds_update_mouse_mode()
+{
+ int allowed = 0;
+ int qxl_count = red_dispatcher_qxl_count();
+
+ if ((agent_mouse && vdagent) || (tablet && qxl_count == 1)) {
+ allowed = reds->dispatcher_allows_client_mouse;
+ }
+ if (allowed == reds->is_client_mouse_allowed) {
+ return;
+ }
+ reds->is_client_mouse_allowed = allowed;
+ if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT && !allowed) {
+ reds_set_mouse_mode(RED_MOUSE_MODE_SERVER);
+ return;
+ }
+ reds_send_mouse_mode();
+}
+
+static void reds_send_agent_connected()
+{
+ SimpleOutItem *item;
+ if (!(item = new_simple_out_item(RED_AGENT_CONNECTED, 0))) {
+ PANIC("alloc item failed");
+ }
+ reds_push_pipe_item(&item->base);
+}
+
+static void reds_send_agent_disconnected()
+{
+ RedAgentDisconnect *disconnect;
+ SimpleOutItem *item;
+
+ if (!(item = new_simple_out_item(RED_AGENT_DISCONNECTED, sizeof(RedAgentDisconnect)))) {
+ PANIC("alloc item failed");
+ }
+ disconnect = (RedAgentDisconnect *)item->data;
+ disconnect->error_code = RED_ERR_OK;
+ reds_push_pipe_item(&item->base);
+}
+
+static void reds_agent_remove()
+{
+ VDIPortInterface *interface = vdagent;
+
+ vdagent = NULL;
+ reds_update_mouse_mode();
+
+ if (!reds->peer || !interface) {
+ return;
+ }
+
+ ASSERT(reds->agent_state.plug_ref != INVALID_VD_OBJECT_REF);
+ interface->unplug(interface, reds->agent_state.plug_ref);
+ reds->agent_state.plug_ref = INVALID_VD_OBJECT_REF;
+
+ if (reds->mig_target) {
+ return;
+ }
+
+ reds_reset_vdp();
+ reds_send_agent_disconnected();
+}
+
+static void reds_send_tokens()
+{
+ RedAgentTokens *tokens;
+ SimpleOutItem *item;
+
+ if (!reds->peer) {
+ return;
+ }
+
+ if (!(item = new_simple_out_item(RED_AGENT_TOKEN, sizeof(RedAgentTokens)))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+ tokens = (RedAgentTokens *)item->data;
+ tokens->num_tokens = reds->agent_state.num_tokens;
+ reds->agent_state.num_client_tokens += tokens->num_tokens;
+ ASSERT(reds->agent_state.num_client_tokens <= REDS_AGENT_WINDOW_SIZE);
+ reds->agent_state.num_tokens = 0;
+ reds_push_pipe_item(&item->base);
+}
+
+static int write_to_vdi_port()
+{
+ VDIPortState *state = &reds->agent_state;
+ RingItem *ring_item;
+ VDIPortBuf *buf;
+ int total = 0;
+ int n;
+
+ if (reds->agent_state.plug_ref == INVALID_VD_OBJECT_REF || reds->mig_target) {
+ return 0;
+ }
+
+ for (;;) {
+ if (!(ring_item = ring_get_tail(&state->write_queue))) {
+ break;
+ }
+ buf = (VDIPortBuf *)ring_item;
+ n = vdagent->write(vdagent, state->plug_ref, buf->now, buf->write_len);
+ if (n == 0) {
+ break;
+ }
+ total += n;
+ buf->write_len -= n;
+ if (!buf->write_len) {
+ ring_remove(ring_item);
+ buf->free(buf);
+ continue;
+ }
+ buf->now += n;
+ }
+ return total;
+}
+
+static void dispatch_vdi_port_data(int port, VDIReadBuf *buf)
+{
+ VDIPortState *state = &reds->agent_state;
+ switch (port) {
+ case VDP_CLIENT_PORT: {
+ buf->header.serial = ++reds->serial;
+ buf->header.size = buf->len;
+ reds_push_pipe_item(&buf->out_item);
+ break;
+ }
+ case VDP_SERVER_PORT:
+ ring_add(&state->read_bufs, &buf->out_item.link);
+ break;
+ default:
+ ring_add(&state->read_bufs, &buf->out_item.link);
+ red_printf("invalid port");
+ reds_agent_remove();
+ }
+}
+
+static int read_from_vdi_port()
+{
+ VDIPortState *state = &reds->agent_state;
+ VDIReadBuf *dispatch_buf;
+ int total = 0;
+ int n;
+
+ if (reds->mig_target) {
+ return 0;
+ }
+
+ while (reds->agent_state.plug_ref != INVALID_VD_OBJECT_REF) {
+ switch (state->read_state) {
+ case VDI_PORT_READ_STATE_READ_HADER:
+ n = vdagent->read(vdagent, state->plug_ref, state->recive_pos, state->recive_len);
+ if (!n) {
+ return total;
+ }
+ total += n;
+ if ((state->recive_len -= n)) {
+ state->recive_pos += n;
+ break;
+ }
+ state->message_recive_len = state->vdi_chunk_header.size;
+ state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
+ case VDI_PORT_READ_STATE_GET_BUFF: {
+ RingItem *item;
+
+ if (!(item = ring_get_head(&state->read_bufs))) {
+ return total;
+ }
+
+ if (state->vdi_chunk_header.port == VDP_CLIENT_PORT) {
+ if (!state->send_tokens) {
+ return total;
+ }
+ --state->send_tokens;
+ }
+ ring_remove(item);
+ state->current_read_buf = (VDIReadBuf *)item;
+ state->recive_pos = state->current_read_buf->data;
+ state->recive_len = MIN(state->message_recive_len,
+ sizeof(state->current_read_buf->data));
+ state->current_read_buf->len = state->recive_len;
+ state->message_recive_len -= state->recive_len;
+ state->read_state = VDI_PORT_READ_STATE_READ_DATA;
+ }
+ case VDI_PORT_READ_STATE_READ_DATA:
+ n = vdagent->read(vdagent, state->plug_ref, state->recive_pos, state->recive_len);
+ if (!n) {
+ return total;
+ }
+ total += n;
+ if ((state->recive_len -= n)) {
+ state->recive_pos += n;
+ break;
+ }
+ dispatch_buf = state->current_read_buf;
+ state->current_read_buf = NULL;
+ state->recive_pos = NULL;
+ if (state->message_recive_len == 0) {
+ state->read_state = VDI_PORT_READ_STATE_READ_HADER;
+ state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
+ state->recive_len = sizeof(state->vdi_chunk_header);
+ } else {
+ state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
+ }
+ dispatch_vdi_port_data(state->vdi_chunk_header.port, dispatch_buf);
+ }
+ }
+ return total;
+}
+
+static void reds_agent_wakeup(VDIPortPlug *plug)
+{
+ while (write_to_vdi_port() || read_from_vdi_port());
+}
+
+static void reds_handle_agent_mouse_event()
+{
+ RingItem *ring_item;
+ VDInternalBuf *buf;
+
+ if (!reds->inputs_state) {
+ return;
+ }
+ if (reds->mig_target || !(ring_item = ring_get_head(&reds->agent_state.internal_bufs))) {
+ reds->inputs_state->pending_mouse_event = TRUE;
+ return;
+ }
+ reds->inputs_state->pending_mouse_event = FALSE;
+ ring_remove(ring_item);
+ buf = (VDInternalBuf *)ring_item;
+ buf->base.now = (uint8_t *)&buf->base.chunk_header;
+ buf->base.write_len = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) +
+ sizeof(VDAgentMouseState);
+ buf->u.mouse_state = reds->inputs_state->mouse_state;
+ ring_add(&reds->agent_state.write_queue, &buf->base.link);
+ write_to_vdi_port();
+}
+
+static void add_token()
+{
+ VDIPortState *state = &reds->agent_state;
+
+ if (++state->num_tokens == REDS_TOKENS_TO_SEND) {
+ reds_send_tokens();
+ }
+}
+
+typedef struct MainMigrateData {
+ uint32_t version;
+ uint32_t serial;
+ uint32_t ping_id;
+
+ uint32_t agent_connected;
+ uint32_t client_agent_started;
+ uint32_t num_client_tokens;
+ uint32_t send_tokens;
+
+ uint32_t read_state;
+ VDIChunkHeader vdi_chunk_header;
+ uint32_t recive_len;
+ uint32_t message_recive_len;
+ uint32_t read_buf_len;
+
+ uint32_t write_queue_size;
+} MainMigrateData;
+
+#define MAIN_CHANNEL_MIG_DATA_VERSION 1
+
+typedef struct WriteQueueInfo {
+ uint32_t port;
+ uint32_t len;
+} WriteQueueInfo;
+
+typedef struct SendMainMigrateItem {
+ RedsOutItem base;
+ RedDataHeader header;
+ MainMigrateData data;
+ WriteQueueInfo queue_info[REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES];
+} SendMainMigrateItem;
+
+static void main_channel_send_migrate_data_item(RedsOutItem *in_item, struct iovec* vec_start,
+ int *len)
+{
+ SendMainMigrateItem *item = (SendMainMigrateItem *)in_item;
+ VDIPortState *state = &reds->agent_state;
+ struct iovec* vec;
+ int buf_index;
+ RingItem *now;
+
+ vec = vec_start;
+
+ item->header.serial = ++reds->serial;
+ item->header.type = RED_MIGRATE_DATA;
+ item->header.size = sizeof(item->data);
+ item->header.sub_list = 0;
+
+ vec[0].iov_base = &item->header;
+ vec[0].iov_len = sizeof(item->header);
+ vec[1].iov_base = &item->data;
+ vec[1].iov_len = sizeof(item->data);
+
+ vec += 2;
+ *len = 2;
+
+ item->data.version = MAIN_CHANNEL_MIG_DATA_VERSION;
+ item->data.serial = reds->serial;
+ item->data.ping_id = reds->ping_id;
+
+ item->data.agent_connected = !!state->plug_ref;
+ item->data.client_agent_started = state->client_agent_started;
+ item->data.num_client_tokens = state->num_client_tokens;
+ item->data.send_tokens = state->send_tokens;
+
+ item->data.read_state = state->read_state;
+ item->data.vdi_chunk_header = state->vdi_chunk_header;
+ item->data.recive_len = state->recive_len;
+ item->data.message_recive_len = state->message_recive_len;
+
+
+ if (state->current_read_buf) {
+ item->data.read_buf_len = state->current_read_buf->len;
+ if ((vec->iov_len = item->data.read_buf_len - item->data.recive_len)) {
+ vec->iov_base = state->current_read_buf->data;
+ item->header.size += vec->iov_len;
+ vec++;
+ (*len)++;
+ }
+ } else {
+ item->data.read_buf_len = 0;
+ }
+
+ now = &state->write_queue;
+ item->data.write_queue_size = 0;
+ while ((now = ring_prev(&state->write_queue, now))) {
+ item->data.write_queue_size++;
+ }
+ if (!item->data.write_queue_size) {
+ return;
+ }
+ ASSERT(item->data.write_queue_size <= sizeof(item->queue_info) / sizeof(item->queue_info[0]));
+ vec->iov_base = item->queue_info;
+ vec->iov_len = item->data.write_queue_size * sizeof(item->queue_info[0]);
+ item->header.size += vec->iov_len;
+ vec++;
+ (*len)++;
+
+ buf_index = 0;
+ now = &state->write_queue;
+ while ((now = ring_prev(&state->write_queue, now))) {
+ VDIPortBuf *buf = (VDIPortBuf *)now;
+ item->queue_info[buf_index].port = buf->chunk_header.port;
+ item->queue_info[buf_index++].len = buf->write_len;
+ ASSERT(vec - vec_start < REDS_MAX_SEND_IOVEC);
+ vec->iov_base = buf->now;
+ vec->iov_len = buf->write_len;
+ item->header.size += vec->iov_len;
+ vec++;
+ (*len)++;
+ }
+}
+
+static void main_channelrelease_migrate_data_item(RedsOutItem *in_item)
+{
+ SendMainMigrateItem *item = (SendMainMigrateItem *)in_item;
+ free(item);
+}
+
+static void main_channel_push_migrate_data_item()
+{
+ SendMainMigrateItem *item;
+
+ if (!(item = (SendMainMigrateItem *)malloc(sizeof(*item)))) {
+ PANIC("malloc failed");
+ }
+ memset(item, 0, sizeof(*item));
+ ring_item_init(&item->base.link);
+ item->base.prepare = main_channel_send_migrate_data_item;
+ item->base.release = main_channelrelease_migrate_data_item;
+
+ reds_push_pipe_item((RedsOutItem *)item);
+}
+
+static int main_channel_restore_vdi_read_state(MainMigrateData *data, uint8_t **in_pos,
+ uint8_t *end)
+{
+ VDIPortState *state = &reds->agent_state;
+ uint8_t *pos = *in_pos;
+ RingItem *ring_item;
+
+ state->read_state = data->read_state;
+ state->vdi_chunk_header = data->vdi_chunk_header;
+ state->recive_len = data->recive_len;
+ state->message_recive_len = data->message_recive_len;
+
+ switch (state->read_state) {
+ case VDI_PORT_READ_STATE_READ_HADER:
+ if (data->read_buf_len) {
+ red_printf("unexpected recive buf");
+ reds_disconnect();
+ return FALSE;
+ }
+ state->recive_pos = (uint8_t *)(&state->vdi_chunk_header + 1) - state->recive_len;
+ break;
+ case VDI_PORT_READ_STATE_GET_BUFF:
+ if (state->message_recive_len > state->vdi_chunk_header.size) {
+ red_printf("invalid message recive len");
+ reds_disconnect();
+ return FALSE;
+ }
+
+ if (data->read_buf_len) {
+ red_printf("unexpected recive buf");
+ reds_disconnect();
+ return FALSE;
+ }
+ break;
+ case VDI_PORT_READ_STATE_READ_DATA: {
+ VDIReadBuf *buff;
+ uint32_t n;
+
+ if (!data->read_buf_len) {
+ red_printf("read state and read_buf_len == 0");
+ reds_disconnect();
+ return FALSE;
+ }
+
+ if (state->message_recive_len > state->vdi_chunk_header.size) {
+ red_printf("invalid message recive len");
+ reds_disconnect();
+ return FALSE;
+ }
+
+
+ if (!(ring_item = ring_get_head(&state->read_bufs))) {
+ red_printf("get read buf failed");
+ reds_disconnect();
+ return FALSE;
+ }
+
+ ring_remove(ring_item);
+ buff = state->current_read_buf = (VDIReadBuf *)ring_item;
+ buff->len = data->read_buf_len;
+ n = buff->len - state->recive_len;
+ if (buff->len > RED_AGENT_MAX_DATA_SIZE || n > RED_AGENT_MAX_DATA_SIZE) {
+ red_printf("bad read position");
+ reds_disconnect();
+ return FALSE;
+ }
+ memcpy(buff->data, pos, n);
+ pos += n;
+ state->recive_pos = buff->data + n;
+ break;
+ }
+ default:
+ red_printf("invalid read state");
+ reds_disconnect();
+ return FALSE;
+ }
+ *in_pos = pos;
+ return TRUE;
+}
+
+static void free_tmp_internal_buf(VDIPortBuf *buf)
+{
+ free(buf);
+}
+
+static int main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *pos, uint8_t *end)
+{
+ VDIPortState *state = &reds->agent_state;
+ WriteQueueInfo *inf;
+ WriteQueueInfo *inf_end;
+ RingItem *ring_item;
+
+ if (!data->write_queue_size) {
+ return TRUE;
+ }
+
+ inf = (WriteQueueInfo *)pos;
+ inf_end = inf + data->write_queue_size;
+ pos = (uint8_t *)inf_end;
+ if (pos > end) {
+ red_printf("access violation");
+ reds_disconnect();
+ return FALSE;
+ }
+
+ for (; inf < inf_end; inf++) {
+ if (pos + inf->len > end) {
+ red_printf("access violation");
+ reds_disconnect();
+ return FALSE;
+ }
+ if (inf->port == VDP_SERVER_PORT) {
+ VDInternalBuf *buf;
+
+ if (inf->len > sizeof(*buf) - OFFSETOF(VDInternalBuf, header)) {
+ red_printf("bad buffer len");
+ reds_disconnect();
+ return FALSE;
+ }
+ if (!(buf = malloc(sizeof(VDInternalBuf)))) {
+ red_printf("no internal buff");
+ reds_disconnect();
+ return FALSE;
+ }
+ ring_item_init(&buf->base.link);
+ buf->base.free = free_tmp_internal_buf;
+ buf->base.now = (uint8_t *)&buf->base.chunk_header;
+ buf->base.write_len = inf->len;
+ memcpy(buf->base.now, pos, buf->base.write_len);
+ ring_add(&reds->agent_state.write_queue, &buf->base.link);
+ } else if (inf->port == VDP_CLIENT_PORT) {
+ VDAgentExtBuf *buf;
+
+ state->num_tokens--;
+ if (inf->len > sizeof(*buf) - OFFSETOF(VDAgentExtBuf, buf)) {
+ red_printf("bad buffer len");
+ reds_disconnect();
+ return FALSE;
+ }
+ if (!(ring_item = ring_get_head(&reds->agent_state.external_bufs))) {
+ red_printf("no external buff");
+ reds_disconnect();
+ return FALSE;
+ }
+ ring_remove(ring_item);
+ buf = (VDAgentExtBuf *)ring_item;
+ memcpy(&buf->buf, pos, inf->len);
+ buf->base.now = (uint8_t *)buf->buf;
+ buf->base.write_len = inf->len;
+ ring_add(&reds->agent_state.write_queue, &buf->base.link);
+ } else {
+ red_printf("invalid data");
+ reds_disconnect();
+ return FALSE;
+ }
+ pos += inf->len;
+ }
+ return TRUE;
+}
+
+static void main_channel_recive_migrate_data(MainMigrateData *data, uint8_t *end)
+{
+ VDIPortState *state = &reds->agent_state;
+ uint8_t *pos;
+
+ if (data->version != MAIN_CHANNEL_MIG_DATA_VERSION) {
+ red_printf("version mismatch");
+ reds_disconnect();
+ return;
+ }
+
+ reds->serial = data->serial;
+ reds->ping_id = data->ping_id;
+
+ state->num_client_tokens = data->num_client_tokens;
+ ASSERT(state->num_client_tokens + data->write_queue_size <= REDS_AGENT_WINDOW_SIZE +
+ REDS_NUM_INTERNAL_AGENT_MESSAGES);
+ state->num_tokens = REDS_AGENT_WINDOW_SIZE - state->num_client_tokens;
+ state->send_tokens = data->send_tokens;
+
+
+ if (!data->agent_connected) {
+ if (state->plug_ref) {
+ reds_send_agent_connected();
+ }
+ return;
+ }
+
+ if (state->plug_ref == INVALID_VD_OBJECT_REF) {
+ reds_send_agent_disconnected();
+ return;
+ }
+
+ if (state->plug_generation > 1) {
+ reds_send_agent_disconnected();
+ reds_send_agent_connected();
+ return;
+ }
+
+ state->client_agent_started = data->client_agent_started;
+
+ pos = (uint8_t *)(data + 1);
+
+ if (!main_channel_restore_vdi_read_state(data, &pos, end)) {
+ return;
+ }
+
+ main_channel_restore_vdi_wqueue(data, pos, end);
+ ASSERT(state->num_client_tokens + state->num_tokens == REDS_AGENT_WINDOW_SIZE);
+}
+
+static void reds_main_handle_message(void *opaque, RedDataHeader *message)
+{
+ switch (message->type) {
+ case REDC_AGENT_START: {
+ RedcAgentTokens *agent_start;
+
+ red_printf("agent start");
+ if (!reds->peer) {
+ return;
+ }
+ agent_start = (RedcAgentTokens *)(message + 1);
+ reds->agent_state.client_agent_started = TRUE;
+ reds->agent_state.send_tokens = agent_start->num_tokens;
+ read_from_vdi_port();
+ break;
+ }
+ case REDC_AGENT_DATA: {
+ RingItem *ring_item;
+ VDAgentExtBuf *buf;
+
+ if (!reds->agent_state.num_client_tokens) {
+ red_printf("token vailoation");
+ reds_disconnect();
+ break;
+ }
+ --reds->agent_state.num_client_tokens;
+
+ if (!vdagent) {
+ add_token();
+ break;
+ }
+
+ if (!reds->agent_state.client_agent_started) {
+ red_printf("REDC_AGENT_DATA race");
+ add_token();
+ break;
+ }
+
+ if (message->size > RED_AGENT_MAX_DATA_SIZE) {
+ red_printf("invalid agent message");
+ reds_disconnect();
+ break;
+ }
+
+ if (!(ring_item = ring_get_head(&reds->agent_state.external_bufs))) {
+ red_printf("no agent free bufs");
+ reds_disconnect();
+ break;
+ }
+ ring_remove(ring_item);
+ buf = (VDAgentExtBuf *)ring_item;
+ buf->base.now = (uint8_t *)&buf->base.chunk_header.port;
+ buf->base.write_len = message->size + sizeof(VDIChunkHeader);
+ buf->base.chunk_header.size = message->size;
+ memcpy(buf->buf, message + 1, message->size);
+ ring_add(&reds->agent_state.write_queue, ring_item);
+ write_to_vdi_port();
+ break;
+ }
+ case REDC_AGENT_TOKEN: {
+ RedcAgentTokens *token;
+
+ if (!reds->agent_state.client_agent_started) {
+ red_printf("REDC_AGENT_TOKEN race");
+ break;
+ }
+
+ token = (RedcAgentTokens *)(message + 1);
+ reds->agent_state.send_tokens += token->num_tokens;
+ read_from_vdi_port();
+ break;
+ }
+ case REDC_ATTACH_CHANNELS:
+ reds_send_channels();
+ break;
+ case REDC_MIGRATE_CONNECTED:
+ red_printf("connected");
+ if (reds->mig_wait_connect) {
+ reds_mig_cleanup();
+ }
+ break;
+ case REDC_MIGRATE_CONNECT_ERROR:
+ red_printf("mig connect error");
+ if (reds->mig_wait_connect) {
+ reds_mig_cleanup();
+ }
+ break;
+ case REDC_MOUSE_MODE_REQUEST: {
+ switch (((RedcMouseModeRequest *)(message + 1))->mode) {
+ case RED_MOUSE_MODE_CLIENT:
+ if (reds->is_client_mouse_allowed) {
+ reds_set_mouse_mode(RED_MOUSE_MODE_CLIENT);
+ } else {
+ red_printf("client mouse is disabled");
+ }
+ break;
+ case RED_MOUSE_MODE_SERVER:
+ reds_set_mouse_mode(RED_MOUSE_MODE_SERVER);
+ break;
+ default:
+ red_printf("unsupported mouse mode");
+ }
+ break;
+ }
+ case REDC_PONG: {
+ RedPing *ping = (RedPing *)(message + 1);
+ uint64_t roundtrip;
+ struct timespec ts;
+
+ clock_gettime(CLOCK_MONOTONIC, &ts);
+ roundtrip = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL - ping->timestamp;
+
+ if (ping->id == reds->net_test_id) {
+ switch (reds->net_test_stage) {
+ case NET_TEST_STAGE_WARMUP:
+ reds->net_test_id++;
+ reds->net_test_stage = NET_TEST_STAGE_LATENCY;
+ break;
+ case NET_TEST_STAGE_LATENCY:
+ reds->net_test_id++;
+ reds->net_test_stage = NET_TEST_STAGE_RATE;
+ letancy = roundtrip;
+ break;
+ case NET_TEST_STAGE_RATE:
+ reds->net_test_id = 0;
+ if (roundtrip <= letancy) {
+ // probably high load on client or server result with incorrect values
+ letancy = 0;
+ red_printf("net test: invalid values, letancy %lu roundtrip %lu. assuming high"
+ "bendwidth", letancy, roundtrip);
+ break;
+ }
+ bitrate_per_sec = (uint64_t)(NET_TEST_BYTES * 8) * 1000000 / (roundtrip - letancy);
+ red_printf("net test: letancy %f ms, bitrate %lu bps (%f Mbps)%s",
+ (double)letancy / 1000,
+ bitrate_per_sec,
+ (double)bitrate_per_sec / 1024 / 1024,
+ IS_LOW_BANDWIDTH() ? " LOW BANDWIDTH" : "");
+ reds->net_test_stage = NET_TEST_STAGE_INVALID;
+ break;
+ default:
+ red_printf("invalid net test stage, ping id %d test id %d stage %d",
+ ping->id,
+ reds->net_test_id,
+ reds->net_test_stage);
+ }
+ break;
+ }
+#ifdef RED_STATISTICS
+ reds_update_stat_value(&reds->roundtrip_stat, roundtrip);
+ do_info_rtt_client();
+#endif
+ break;
+ }
+ case REDC_MIGRATE_FLUSH_MARK:
+ main_channel_push_migrate_data_item();
+ break;
+ case REDC_MIGRATE_DATA:
+ main_channel_recive_migrate_data((MainMigrateData *)(message + 1),
+ (uint8_t *)(message + 1) + message->size);
+ reds->mig_target = FALSE;
+ while (write_to_vdi_port() || read_from_vdi_port());
+ break;
+ case REDC_DISCONNECTING:
+ break;
+ default:
+ red_printf("unexpected type %d", message->type);
+ }
+}
+
+static void reds_main_read(void *data)
+{
+ if (handle_incoming(reds->peer, &reds->in_handler)) {
+ reds_disconnect();
+ }
+}
+
+static int reds_send_data()
+{
+ RedsOutgoingData *outgoing = &reds->outgoing;
+ int n;
+
+ if (!outgoing->item) {
+ return TRUE;
+ }
+
+ ASSERT(outgoing->vec_size);
+ for (;;) {
+ if ((n = reds->peer->cb_writev(reds->peer->ctx, outgoing->vec, outgoing->vec_size)) == -1) {
+ switch (errno) {
+ case EAGAIN:
+ core->set_file_handlers(core, reds->peer->socket, reds_main_read, reds_main_write,
+ NULL);
+ return FALSE;
+ case EINTR:
+ break;
+ case EPIPE:
+ reds_disconnect();
+ return FALSE;
+ default:
+ red_printf("%s", strerror(errno));
+ reds_disconnect();
+ return FALSE;
+ }
+ } else {
+ outgoing->vec = reds_iovec_skip(outgoing->vec, n, &outgoing->vec_size);
+ if (!outgoing->vec_size) {
+ outgoing->item->release(outgoing->item);
+ outgoing->item = NULL;
+ outgoing->vec = outgoing->vec_buf;
+ return TRUE;
+ }
+ }
+ }
+}
+
+static void reds_push()
+{
+ RedsOutgoingData *outgoing = &reds->outgoing;
+ RingItem *item;
+
+ for (;;) {
+ if (!reds->peer || outgoing->item || !(item = ring_get_tail(&outgoing->pipe))) {
+ return;
+ }
+ ring_remove(item);
+ outgoing->item = (RedsOutItem *)item;
+ outgoing->item->prepare(outgoing->item, outgoing->vec_buf, &outgoing->vec_size);
+ reds_send_data();
+ }
+}
+
+static void reds_main_write(void *data)
+{
+ RedsOutgoingData *outgoing = &reds->outgoing;
+
+ if (reds_send_data()) {
+ reds_push();
+ if (!outgoing->item) {
+ core->set_file_handlers(core, reds->peer->socket, reds_main_read, NULL, NULL);
+ }
+ }
+}
+
+static int sync_write(RedsStreamContext *peer, void *in_buf, size_t n)
+{
+ uint8_t *buf = (uint8_t *)in_buf;
+ while (n) {
+ int now = peer->cb_write(peer->ctx, buf, n);
+ if (now <= 0) {
+ if (now == -1 && (errno == EINTR || errno == EAGAIN)) {
+ continue;
+ }
+ return FALSE;
+ }
+ n -= now;
+ buf += now;
+ }
+ return TRUE;
+}
+
+static int reds_send_link_ack(RedLinkInfo *link)
+{
+ RedLinkHeader header;
+ RedLinkReply ack;
+ Channel *channel;
+ BUF_MEM *bmBuf;
+ BIO *bio;
+ int ret;
+
+ header.magic = RED_MAGIC;
+ header.size = sizeof(ack);
+ header.major_version = RED_VERSION_MAJOR;
+ header.minor_version = RED_VERSION_MINOR;
+
+ ack.error = RED_ERR_OK;
+
+ if ((channel = reds_find_channel(link->link_mess->channel_type, 0))) {
+ ack.num_common_caps = channel->num_common_caps;
+ ack.num_channel_caps = channel->num_caps;
+ header.size += (ack.num_common_caps + ack.num_channel_caps) * sizeof(uint32_t);
+ } else {
+ ack.num_common_caps = 0;
+ ack.num_channel_caps = 0;
+ }
+ ack.caps_offset = sizeof(RedLinkReply);
+
+ if (!(link->tiTicketing.rsa = RSA_new())) {
+ red_printf("RSA nes failed");
+ return FALSE;
+ }
+
+ if (!(bio = BIO_new(BIO_s_mem()))) {
+ red_printf("BIO new failed");
+ return FALSE;
+ }
+
+ RSA_generate_key_ex(link->tiTicketing.rsa, RED_TICKET_KEY_PAIR_LENGTH, link->tiTicketing.bn,
+ NULL);
+ link->tiTicketing.rsa_size = RSA_size(link->tiTicketing.rsa);
+
+ i2d_RSA_PUBKEY_bio(bio, link->tiTicketing.rsa);
+ BIO_get_mem_ptr(bio, &bmBuf);
+ memcpy(ack.pub_key, bmBuf->data, sizeof(ack.pub_key));
+
+ ret = sync_write(link->peer, &header, sizeof(header)) && sync_write(link->peer, &ack,
+ sizeof(ack));
+ if (channel) {
+ ret = ret && sync_write(link->peer, channel->common_caps,
+ channel->num_common_caps * sizeof(uint32_t)) &&
+ sync_write(link->peer, channel->caps, channel->num_caps * sizeof(uint32_t));
+ }
+ BIO_free(bio);
+ return ret;
+}
+
+static int reds_send_link_error(RedLinkInfo *link, uint32_t error)
+{
+ RedLinkHeader header;
+ RedLinkReply reply;
+
+ header.magic = RED_MAGIC;
+ header.size = sizeof(reply);
+ header.major_version = RED_VERSION_MAJOR;
+ header.minor_version = RED_VERSION_MINOR;
+ memset(&reply, 0, sizeof(reply));
+ reply.error = error;
+ return sync_write(link->peer, &header, sizeof(header)) && sync_write(link->peer, &reply,
+ sizeof(reply));
+}
+
+static void reds_show_new_channel(RedLinkInfo *link)
+{
+ red_printf("channel %d:%d, connected sucessfully, over %s link",
+ link->link_mess->channel_type,
+ link->link_mess->channel_id,
+ link->peer->ssl == NULL ? "Non Secure" : "Secure");
+}
+
+static void reds_send_link_result(RedLinkInfo *link, uint32_t error)
+{
+ sync_write(link->peer, &error, sizeof(error));
+}
+
+static void reds_start_net_test()
+{
+ if (!reds->peer || reds->net_test_id) {
+ return;
+ }
+
+ if (send_ping(NET_TEST_WARMUP_BYTES) && send_ping(0) && send_ping(NET_TEST_BYTES)) {
+ reds->net_test_id = reds->ping_id - 2;
+ reds->net_test_stage = NET_TEST_STAGE_WARMUP;
+ }
+}
+
+static void reds_handle_main_link(RedLinkInfo *link)
+{
+ uint32_t connection_id;
+
+ red_printf("");
+
+ reds_disconnect();
+
+ if (!link->link_mess->connection_id) {
+ reds_send_link_result(link, RED_ERR_OK);
+ while((connection_id = rand()) == 0);
+ reds->agent_state.num_tokens = 0;
+ reds->agent_state.send_tokens = 0;
+ memcpy(&(reds->taTicket), &taTicket, sizeof(reds->taTicket));
+ reds->mig_target = FALSE;
+ } else {
+ if (link->link_mess->connection_id != reds->link_id) {
+ reds_send_link_result(link, RED_ERR_BAD_CONNECTION_ID);
+ reds_release_link(link);
+ return;
+ }
+ reds_send_link_result(link, RED_ERR_OK);
+ connection_id = link->link_mess->connection_id;
+ reds->mig_target = TRUE;
+ }
+
+ reds->link_id = connection_id;
+ reds->mig_inprogress = FALSE;
+ reds->mig_wait_connect = FALSE;
+ reds->mig_wait_disconnect = FALSE;
+ reds->peer = link->peer;
+ reds->in_handler.shut = FALSE;
+ if (reds->mig_target) {
+ LOG_MESSAGE(VD_LOG_INFO, "migrate connection");
+ } else {
+ LOG_MESSAGE(VD_LOG_INFO, "new user connection");
+ }
+
+ reds_show_new_channel(link);
+ __reds_release_link(link);
+ if (vdagent) {
+ reds->agent_state.plug_ref = vdagent->plug(vdagent, &reds->agent_state.plug);
+ if (reds->agent_state.plug_ref == INVALID_VD_OBJECT_REF) {
+ PANIC("vdagent plug failed");
+ }
+ reds->agent_state.plug_generation++;
+ }
+ core->set_file_handlers(core, reds->peer->socket, reds_main_read, NULL, NULL);
+
+ if (!reds->mig_target) {
+ SimpleOutItem *item;
+ RedInit *init;
+
+ if (!(item = new_simple_out_item(RED_INIT, sizeof(RedInit)))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+ init = (RedInit *)item->data;
+ init->session_id = connection_id;
+ init->display_channels_hint = red_dispatcher_count();
+ init->current_mouse_mode = reds->mouse_mode;
+ init->supported_mouse_modes = RED_MOUSE_MODE_SERVER;
+ if (reds->is_client_mouse_allowed) {
+ init->supported_mouse_modes |= RED_MOUSE_MODE_CLIENT;
+ }
+ init->agent_connected = !!vdagent;
+ init->agent_tokens = REDS_AGENT_WINDOW_SIZE;
+ reds->agent_state.num_client_tokens = REDS_AGENT_WINDOW_SIZE;
+ init->multi_media_time = reds_get_mm_time() - MM_TIME_DELTA;
+ init->ram_hint = red_dispatcher_qxl_ram_size();
+ reds_push_pipe_item(&item->base);
+ reds_start_net_test();
+ }
+}
+
+#define RED_MOUSE_STATE_TO_LOCAL(state) \
+ ((state & REDC_LBUTTON_MASK) | \
+ ((state & REDC_MBUTTON_MASK) << 1) | \
+ ((state & REDC_RBUTTON_MASK) >> 1))
+
+#define RED_MOUSE_BUTTON_STATE_TO_AGENT(state) \
+ (((state & REDC_LBUTTON_MASK) ? VD_AGENT_LBUTTON_MASK : 0) | \
+ ((state & REDC_MBUTTON_MASK) ? VD_AGENT_MBUTTON_MASK : 0) | \
+ ((state & REDC_RBUTTON_MASK) ? VD_AGENT_RBUTTON_MASK : 0))
+
+static void activate_modifiers_watch()
+{
+ core->arm_timer(core, reds->key_modifiers_timer, KEY_MODIFIERS_TTL);
+}
+
+static void push_key_scan(uint8_t scan)
+{
+ if (!keyboard) {
+ return;
+ }
+ keyboard->push_scan_freg(keyboard, scan);
+}
+
+static void inputs_handle_input(void *opaque, RedDataHeader *header)
+{
+ InputsState *state = (InputsState *)opaque;
+ uint8_t *buf = (uint8_t *)(header + 1);
+
+ switch (header->type) {
+ case REDC_INPUTS_KEY_DOWN: {
+ RedcKeyDown *key_up = (RedcKeyDown *)buf;
+ if (key_up->code == CAPS_LOCK_SCAN_CODE || key_up->code == NUM_LOCK_SCAN_CODE ||
+ key_up->code == SCROLL_LOCK_SCAN_CODE) {
+ activate_modifiers_watch();
+ }
+ }
+ case REDC_INPUTS_KEY_UP: {
+ RedcKeyDown *key_down = (RedcKeyDown *)buf;
+ uint8_t *now = (uint8_t *)&key_down->code;
+ uint8_t *end = now + sizeof(key_down->code);
+ for (; now < end && *now; now++) {
+ push_key_scan(*now);
+ }
+ break;
+ }
+ case REDC_INPUTS_MOUSE_MOTION: {
+ RedcMouseMotion *mouse_motion = (RedcMouseMotion *)buf;
+
+ if (++state->motion_count % RED_MOTION_ACK_BUNCH == 0) {
+ RedDataHeader header;
+
+ header.serial = ++state->serial;
+ header.type = RED_INPUTS_MOUSE_MOTION_ACK;
+ header.size = 0;
+ header.sub_list = 0;
+ if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+ != OUTGOING_OK) {
+ red_printf("motion ack failed");
+ reds_disconnect();
+ }
+ }
+ if (mouse && reds->mouse_mode == RED_MOUSE_MODE_SERVER) {
+ mouse->moution(mouse, mouse_motion->dx, mouse_motion->dy, 0,
+ RED_MOUSE_STATE_TO_LOCAL(mouse_motion->buttons_state));
+ }
+ break;
+ }
+ case REDC_INPUTS_MOUSE_POSITION: {
+ RedcMousePosition *pos = (RedcMousePosition *)buf;
+
+ if (++state->motion_count % RED_MOTION_ACK_BUNCH == 0) {
+ RedDataHeader header;
+
+ header.serial = ++state->serial;
+ header.type = RED_INPUTS_MOUSE_MOTION_ACK;
+ header.size = 0;
+ header.sub_list = 0;
+ if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+ != OUTGOING_OK) {
+ red_printf("position ack failed");
+ reds_disconnect();
+ }
+ }
+ if (reds->mouse_mode != RED_MOUSE_MODE_CLIENT) {
+ break;
+ }
+ ASSERT((agent_mouse && vdagent) || tablet);
+ if (!agent_mouse || !vdagent) {
+ tablet->position(tablet, pos->x, pos->y, RED_MOUSE_STATE_TO_LOCAL(pos->buttons_state));
+ break;
+ }
+ VDAgentMouseState *mouse_state = &state->mouse_state;
+ mouse_state->x = pos->x;
+ mouse_state->y = pos->y;
+ mouse_state->buttons = RED_MOUSE_BUTTON_STATE_TO_AGENT(pos->buttons_state);
+ mouse_state->display_id = pos->display_id;
+ reds_handle_agent_mouse_event();
+ break;
+ }
+ case REDC_INPUTS_MOUSE_PRESS: {
+ RedcMousePress *mouse_press = (RedcMousePress *)buf;
+ int dz = 0;
+ if (mouse_press->button == REDC_MOUSE_UBUTTON) {
+ dz = -1;
+ } else if (mouse_press->button == REDC_MOUSE_DBUTTON) {
+ dz = 1;
+ }
+ if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT) {
+ if (agent_mouse && vdagent) {
+ reds->inputs_state->mouse_state.buttons =
+ RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_press->buttons_state) |
+ (dz == -1 ? VD_AGENT_UBUTTON_MASK : 0) |
+ (dz == 1 ? VD_AGENT_DBUTTON_MASK : 0);
+ reds_handle_agent_mouse_event();
+ } else if (tablet) {
+ tablet->wheel(tablet, dz, RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
+ }
+ } else if (mouse) {
+ mouse->moution(mouse, 0, 0, dz, RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
+ }
+ break;
+ }
+ case REDC_INPUTS_MOUSE_RELEASE: {
+ RedcMouseRelease *mouse_release = (RedcMouseRelease *)buf;
+ if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT) {
+ if (agent_mouse && vdagent) {
+ reds->inputs_state->mouse_state.buttons =
+ RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_release->buttons_state);
+ reds_handle_agent_mouse_event();
+ } else if (tablet) {
+ tablet->buttons(tablet, RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
+ }
+ } else if (mouse) {
+ mouse->buttons(mouse, RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
+ }
+ break;
+ }
+ case REDC_INPUTS_KEY_MODIFAIERS: {
+ RedcKeyModifiers *modifiers = (RedcKeyModifiers *)buf;
+ if (!keyboard) {
+ break;
+ }
+ uint8_t leds = keyboard->get_leds(keyboard);
+ if ((modifiers->modifiers & RED_SCROLL_LOCK_MODIFIER) !=
+ (leds & RED_SCROLL_LOCK_MODIFIER)) {
+ push_key_scan(SCROLL_LOCK_SCAN_CODE);
+ push_key_scan(SCROLL_LOCK_SCAN_CODE | 0x80);
+ }
+ if ((modifiers->modifiers & RED_NUM_LOCK_MODIFIER) != (leds & RED_NUM_LOCK_MODIFIER)) {
+ push_key_scan(NUM_LOCK_SCAN_CODE);
+ push_key_scan(NUM_LOCK_SCAN_CODE | 0x80);
+ }
+ if ((modifiers->modifiers & RED_CAPS_LOCK_MODIFIER) != (leds & RED_CAPS_LOCK_MODIFIER)) {
+ push_key_scan(CAPS_LOCK_SCAN_CODE);
+ push_key_scan(CAPS_LOCK_SCAN_CODE | 0x80);
+ }
+ activate_modifiers_watch();
+ break;
+ }
+ case REDC_DISCONNECTING:
+ break;
+ default:
+ red_printf("unexpected type %d", header->type);
+ }
+}
+
+void reds_set_client_mouse_allowed(int is_client_mouse_allowed, int x_res, int y_res)
+{
+ reds->monitor_mode.x_res = x_res;
+ reds->monitor_mode.y_res = y_res;
+ reds->dispatcher_allows_client_mouse = is_client_mouse_allowed;
+ reds_update_mouse_mode();
+ if (reds->is_client_mouse_allowed && tablet) {
+ tablet->set_logical_size(tablet, reds->monitor_mode.x_res, reds->monitor_mode.y_res);
+ }
+}
+
+static void inputs_relase_keys(void)
+{
+ push_key_scan(0x2a | 0x80); //LSHIFT
+ push_key_scan(0x36 | 0x80); //RSHIFT
+ push_key_scan(0xe0); push_key_scan(0x1d | 0x80); //RCTRL
+ push_key_scan(0x1d | 0x80); //LCTRL
+ push_key_scan(0xe0); push_key_scan(0x38 | 0x80); //RALT
+ push_key_scan(0x38 | 0x80); //LALT
+}
+
+static void inputs_read(void *data)
+{
+ InputsState *inputs_state = (InputsState *)data;
+ if (handle_incoming(inputs_state->peer, &inputs_state->in_handler)) {
+ inputs_relase_keys();
+ core->set_file_handlers(core, inputs_state->peer->socket, NULL, NULL, NULL);
+ if (inputs_state->channel) {
+ inputs_state->channel->data = NULL;
+ reds->inputs_state = NULL;
+ }
+ inputs_state->peer->cb_free(inputs_state->peer);
+ free(inputs_state);
+ }
+}
+
+static void inputs_write(void *data)
+{
+ InputsState *inputs_state = (InputsState *)data;
+
+ red_printf("");
+ if (handle_outgoing(inputs_state->peer, &inputs_state->out_handler)) {
+ reds_disconnect();
+ }
+}
+
+static void inputs_shutdown(Channel *channel)
+{
+ InputsState *state = (InputsState *)channel->data;
+ if (state) {
+ state->in_handler.shut = TRUE;
+ shutdown(state->peer->socket, SHUT_RDWR);
+ channel->data = NULL;
+ state->channel = NULL;
+ reds->inputs_state = NULL;
+ }
+}
+
+static void inputs_migrate(Channel *channel)
+{
+ InputsState *state = (InputsState *)channel->data;
+ RedDataHeader header;
+ RedMigrate migrate;
+
+ red_printf("");
+ header.serial = ++state->serial;
+ header.type = RED_MIGRATE;
+ header.size = sizeof(migrate);
+ header.sub_list = 0;
+ migrate.flags = 0;
+ if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(header))
+ != OUTGOING_OK ||
+ outgoing_write(state->peer, &state->out_handler, &migrate, sizeof(migrate))
+ != OUTGOING_OK) {
+ red_printf("write failed");
+ }
+}
+
+static void inputs_select(void *opaque, int select)
+{
+ InputsState *inputs_state;
+ red_printf("");
+
+ inputs_state = (InputsState *)opaque;
+ if (select) {
+ core->set_file_handlers(core, inputs_state->peer->socket, inputs_read, inputs_write,
+ inputs_state);
+ } else {
+ core->set_file_handlers(core, inputs_state->peer->socket, inputs_read, NULL, inputs_state);
+ }
+}
+
+static void inputs_may_write(void *opaque)
+{
+ red_printf("");
+}
+
+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;
+ int delay_val;
+ int flags;
+
+ red_printf("");
+ ASSERT(channel->data == NULL);
+
+ if (!(inputs_state = malloc(sizeof(InputsState)))) {
+ red_printf("alloc input state failed");
+ close(peer->socket);
+ return;
+ }
+
+ delay_val = 1;
+ if (setsockopt(peer->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
+ red_printf("setsockopt failed, %s", strerror(errno));
+ }
+
+ if ((flags = fcntl(peer->socket, F_GETFL)) == -1 ||
+ fcntl(peer->socket, F_SETFL, flags | O_ASYNC) == -1) {
+ red_printf("fcntl failed, %s", strerror(errno));
+ }
+
+ memset(inputs_state, 0, sizeof(*inputs_state));
+ inputs_state->peer = peer;
+ inputs_state->end_pos = 0;
+ inputs_state->channel = channel;
+ inputs_state->in_handler.opaque = inputs_state;
+ inputs_state->in_handler.handle_message = inputs_handle_input;
+ inputs_state->out_handler.length = 0;
+ inputs_state->out_handler.opaque = inputs_state;
+ inputs_state->out_handler.select = inputs_select;
+ inputs_state->out_handler.may_write = inputs_may_write;
+ inputs_state->pending_mouse_event = FALSE;
+ channel->data = inputs_state;
+ reds->inputs_state = inputs_state;
+ core->set_file_handlers(core, peer->socket, inputs_read, NULL, inputs_state);
+
+ RedDataHeader header;
+ RedInputsInit inputs_init;
+ header.serial = ++inputs_state->serial;
+ header.type = RED_INPUTS_INIT;
+ header.size = sizeof(RedInputsInit);
+ header.sub_list = 0;
+ inputs_init.keyboard_modifiers = keyboard ? keyboard->get_leds(keyboard) : 0;
+ if (outgoing_write(inputs_state->peer, &inputs_state->out_handler, &header,
+ sizeof(RedDataHeader)) != OUTGOING_OK ||
+ outgoing_write(inputs_state->peer, &inputs_state->out_handler, &inputs_init,
+ sizeof(RedInputsInit)) != OUTGOING_OK) {
+ red_printf("failed to send modifiers state");
+ reds_disconnect();
+ }
+}
+
+static void reds_send_keyborad_modifiers(uint8_t modifiers)
+{
+ Channel *channel = reds_find_channel(RED_CHANNEL_INPUTS, 0);
+ InputsState *state;
+
+ if (!channel || !(state = (InputsState *)channel->data)) {
+ return;
+ }
+ ASSERT(state->peer);
+ RedDataHeader header;
+ RedKeyModifiers key_modifiers;
+ header.serial = ++state->serial;
+ header.type = RED_INPUTS_KEY_MODIFAIERS;
+ header.size = sizeof(RedKeyModifiers);
+ header.sub_list = 0;
+ key_modifiers.modifiers = modifiers;
+
+ if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+ != OUTGOING_OK ||
+ outgoing_write(state->peer, &state->out_handler, &key_modifiers, sizeof(RedKeyModifiers))
+ != OUTGOING_OK) {
+ red_printf("failed to send modifiers state");
+ reds_disconnect();
+ }
+}
+
+static void reds_on_keyborad_leads_change(void *opaque, uint8_t leds)
+{
+ reds_send_keyborad_modifiers(leds);
+}
+
+static void openssl_init(RedLinkInfo *link)
+{
+ unsigned long f4 = RSA_F4;
+ link->tiTicketing.bn = BN_new();
+
+ if (!link->tiTicketing.bn) {
+ red_error("OpenSSL BIGNUMS alloc failed");
+ }
+
+ BN_set_word(link->tiTicketing.bn, f4);
+}
+
+static void inputs_init()
+{
+ Channel *channel;
+ if (!(channel = malloc(sizeof(Channel)))) {
+ red_error("alloc inputs chanel failed");
+ }
+ memset(channel, 0, sizeof(Channel));
+ channel->type = RED_CHANNEL_INPUTS;
+ channel->link = inputs_link;
+ channel->shutdown = inputs_shutdown;
+ channel->migrate = inputs_migrate;
+ reds_register_channel(channel);
+}
+
+static void reds_handle_other_links(RedLinkInfo *link)
+{
+ Channel *channel;
+ RedsStreamContext *peer;
+ RedLinkMess *link_mess;
+ uint32_t *caps;
+
+ link_mess = link->link_mess;
+
+ if (!reds->link_id || reds->link_id != link_mess->connection_id) {
+ reds_send_link_result(link, RED_ERR_BAD_CONNECTION_ID);
+ reds_release_link(link);
+ return;
+ }
+
+ if (!(channel = reds_find_channel(link_mess->channel_type,
+ link_mess->channel_id))) {
+ reds_send_link_result(link, RED_ERR_CHANNEL_NOT_AVAILABLE);
+ reds_release_link(link);
+ return;
+ }
+
+ reds_send_link_result(link, RED_ERR_OK);
+ reds_show_new_channel(link);
+ if (link_mess->channel_type == RED_CHANNEL_INPUTS && !link->peer->ssl) {
+ SimpleOutItem *item;
+ RedNotify *notify;
+ char *mess = "keybord channel is unsecure";
+ const int mess_len = strlen(mess);
+
+ LOG_MESSAGE(VD_LOG_WARN, "%s", mess);
+
+ if (!(item = new_simple_out_item(RED_NOTIFY, sizeof(RedNotify) + mess_len + 1))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+
+ notify = (RedNotify *)item->data;
+ notify->time_stamp = get_time_stamp();
+ notify->severty = RED_NOTIFY_SEVERITY_WARN;
+ notify->visibilty = RED_NOTIFY_VISIBILITY_HIGH;
+ notify->what = RED_WARN_GENERAL;
+ notify->message_len = mess_len;
+ memcpy(notify->message, mess, mess_len + 1);
+ reds_push_pipe_item(&item->base);
+ }
+ peer = link->peer;
+ link->link_mess = NULL;
+ __reds_release_link(link);
+ caps = (uint32_t *)((uint8_t *)link_mess + link_mess->caps_offset);
+ channel->link(channel, peer, reds->mig_target, link_mess->num_common_caps,
+ link_mess->num_common_caps ? caps : NULL, link_mess->num_channel_caps,
+ link_mess->num_channel_caps ? caps + link_mess->num_common_caps : NULL);
+ free(link_mess);
+}
+
+static void reds_handle_ticket(void *opaque)
+{
+ RedLinkInfo *link = (RedLinkInfo *)opaque;
+ char password[RED_MAX_PASSWORD_LENGTH];
+ time_t ltime;
+
+ //todo: use monotonic time
+ time(&ltime);
+ RSA_private_decrypt(link->tiTicketing.rsa_size,
+ link->tiTicketing.encrypted_ticket.encrypted_data,
+ (unsigned char *)password, link->tiTicketing.rsa, RSA_PKCS1_OAEP_PADDING);
+
+ if (ticketing_enabled) {
+ int expired = !link->link_mess->connection_id && taTicket.expiration_time < ltime;
+ char *actual_sever_pass = link->link_mess->connection_id ? reds->taTicket.password :
+ taTicket.password;
+ if (strlen(actual_sever_pass) == 0) {
+ reds_send_link_result(link, RED_ERR_PERMISSION_DENIED);
+ red_printf("Ticketing is enabled, but no password is set. "
+ "please set a ticket first");
+ reds_release_link(link);
+ return;
+ }
+
+ if (expired || strncmp(password, actual_sever_pass, RED_MAX_PASSWORD_LENGTH) != 0) {
+ reds_send_link_result(link, RED_ERR_PERMISSION_DENIED);
+ LOG_MESSAGE(VD_LOG_WARN, "bad connection password or time expired");
+ reds_release_link(link);
+ return;
+ }
+ }
+ if (link->link_mess->channel_type == RED_CHANNEL_MAIN) {
+ reds_handle_main_link(link);
+ } else {
+ reds_handle_other_links(link);
+ }
+}
+
+static inline void async_read_clear_handlers(AsyncRead *obj)
+{
+ if (!obj->active_file_handlers) {
+ return;
+ }
+ obj->active_file_handlers = FALSE;
+ core->set_file_handlers(core, obj->peer->socket, NULL, NULL, NULL);
+}
+
+static void async_read_handler(void *data)
+{
+ AsyncRead *obj = (AsyncRead *)data;
+
+ for (;;) {
+ int n = obj->end - obj->now;
+
+ ASSERT(n > 0);
+ if ((n = obj->peer->cb_read(obj->peer->ctx, obj->now, n)) <= 0) {
+ if (n < 0) {
+ switch (errno) {
+ case EAGAIN:
+ if (!obj->active_file_handlers) {
+ obj->active_file_handlers = TRUE;
+ core->set_file_handlers(core, obj->peer->socket, async_read_handler, NULL,
+ obj);
+ }
+ return;
+ case EINTR:
+ break;
+ default:
+ async_read_clear_handlers(obj);
+ obj->error(obj->opaque, errno);
+ return;
+ }
+ } else {
+ async_read_clear_handlers(obj);
+ obj->error(obj->opaque, 0);
+ return;
+ }
+ } else {
+ obj->now += n;
+ if (obj->now == obj->end) {
+ async_read_clear_handlers(obj);
+ obj->done(obj->opaque);
+ return;
+ }
+ }
+ }
+}
+
+static int reds_security_check(RedLinkInfo *link)
+{
+ ChannelSecurityOptions *security_option = find_channel_security(link->link_mess->channel_type);
+ uint32_t security = security_option ? security_option->options : default_channel_security;
+ return (link->peer->ssl && (security & CHANNEL_SECURITY_SSL)) || (!link->peer->ssl &&
+ (security & CHANNEL_SECURITY_NON));
+}
+
+static void reds_handle_read_link_done(void *opaque)
+{
+ RedLinkInfo *link = (RedLinkInfo *)opaque;
+ RedLinkMess *link_mess = link->link_mess;
+ AsyncRead *obj = &link->asyc_read;
+ uint32_t num_caps = link_mess->num_common_caps + link_mess->num_channel_caps;
+
+ if (num_caps && (num_caps * sizeof(uint32_t) + link_mess->caps_offset >
+ link->link_header.size ||
+ link_mess->caps_offset < sizeof(*link_mess))) {
+ reds_send_link_error(link, RED_ERR_INVALID_DATA);
+ reds_release_link(link);
+ return;
+ }
+
+ if (!reds_security_check(link)) {
+ if (link->peer->ssl) {
+ LOG_MESSAGE(VD_LOG_INFO, "channels of type %d should connect only over "
+ "a non secure link", link_mess->channel_type);
+ red_printf("spice channels %d should not be encrypted", link_mess->channel_type);
+ reds_send_link_error(link, RED_ERR_NEED_UNSECURED);
+ } else {
+ LOG_MESSAGE(VD_LOG_INFO, "channels of type %d should connect only over "
+ "a secure link", link_mess->channel_type);
+ red_printf("spice channels %d should be encrypted", link_mess->channel_type);
+ reds_send_link_error(link, RED_ERR_NEED_SECURED);
+ }
+ reds_release_link(link);
+ return;
+ }
+
+ if (!reds_send_link_ack(link)) {
+ reds_release_link(link);
+ return;
+ }
+
+ obj->now = (uint8_t *)&link->tiTicketing.encrypted_ticket.encrypted_data;
+ obj->end = obj->now + link->tiTicketing.rsa_size;
+ obj->done = reds_handle_ticket;
+ async_read_handler(&link->asyc_read);
+}
+
+static void reds_handle_link_error(void *opaque, int err)
+{
+ RedLinkInfo *link = (RedLinkInfo *)opaque;
+ switch (err) {
+ case 0:
+ case EPIPE:
+ break;
+ default:
+ red_printf("%s", strerror(errno));
+ break;
+ }
+ reds_release_link(link);
+}
+
+static void reds_handle_read_header_done(void *opaque)
+{
+ RedLinkInfo *link = (RedLinkInfo *)opaque;
+ RedLinkHeader *header = &link->link_header;
+ AsyncRead *obj = &link->asyc_read;
+
+ if (header->magic != RED_MAGIC) {
+ reds_send_link_error(link, RED_ERR_INVALID_MAGIC);
+ LOG_MESSAGE(VD_LOG_ERROR, "bad magic %u", header->magic);
+ reds_release_link(link);
+ return;
+ }
+
+ if (header->major_version != RED_VERSION_MAJOR) {
+ if (header->major_version > 0) {
+ reds_send_link_error(link, RED_ERR_VERSION_MISMATCH);
+ }
+ LOG_MESSAGE(VD_LOG_INFO, "version mismatch client %u.%u server %u.%u",
+ header->major_version,
+ header->minor_version,
+ RED_VERSION_MAJOR,
+ RED_VERSION_MINOR);
+
+ red_printf("version mismatch");
+ reds_release_link(link);
+ return;
+ }
+
+ if (header->size < sizeof(RedLinkMess)) {
+ reds_send_link_error(link, RED_ERR_INVALID_DATA);
+ red_printf("bad size %u", header->size);
+ reds_release_link(link);
+ return;
+ }
+
+ if (!(link->link_mess = malloc(header->size))) {
+ red_printf("malloc failed %u", header->size);
+ reds_release_link(link);
+ return;
+ }
+
+ obj->now = (uint8_t *)link->link_mess;
+ obj->end = obj->now + header->size;
+ obj->done = reds_handle_read_link_done;
+ async_read_handler(&link->asyc_read);
+}
+
+static void reds_handle_new_link(RedLinkInfo *link)
+{
+ AsyncRead *obj = &link->asyc_read;
+ obj->opaque = link;
+ obj->peer = link->peer;
+ obj->now = (uint8_t *)&link->link_header;
+ obj->end = (uint8_t *)((RedLinkHeader *)&link->link_header + 1);
+ obj->active_file_handlers = FALSE;
+ obj->done = reds_handle_read_header_done;
+ obj->error = reds_handle_link_error;
+ async_read_handler(&link->asyc_read);
+}
+
+static void reds_handle_ssl_accept(void *data)
+{
+ RedLinkInfo *link = (RedLinkInfo *)data;
+ int return_code;
+
+ if ((return_code = SSL_accept(link->peer->ssl)) != 1) {
+ int ssl_error = SSL_get_error(link->peer->ssl, return_code);
+
+ if (ssl_error != SSL_ERROR_WANT_READ && ssl_error != SSL_ERROR_WANT_WRITE) {
+ red_printf("SSL_accept failed, error=%d", ssl_error);
+ reds_release_link(link);
+ }
+ return;
+ }
+ reds_handle_new_link(link);
+}
+
+static RedLinkInfo *__reds_accept_connection(int listen_socket)
+{
+ RedLinkInfo *link;
+ RedsStreamContext *peer;
+ int delay_val = 1;
+ int flags;
+ int socket;
+
+ if ((socket = accept(listen_socket, NULL, 0)) == -1) {
+ red_printf("accept failed, %s", strerror(errno));
+ return NULL;
+ }
+
+ if ((flags = fcntl(socket, F_GETFL)) == -1) {
+ red_printf("accept failed, %s", strerror(errno));
+ goto error1;
+ }
+
+ if (fcntl(socket, F_SETFL, flags | O_NONBLOCK) == -1) {
+ red_printf("accept failed, %s", strerror(errno));
+ goto error1;
+ }
+
+ if (setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
+ red_printf("setsockopt failed, %s", strerror(errno));
+ }
+
+ if (!(link = malloc(sizeof(RedLinkInfo)))) {
+ red_printf("malloc failed");
+ goto error1;
+ }
+
+ if (!(peer = malloc(sizeof(RedsStreamContext)))) {
+ red_printf("malloc failed");
+ goto error2;
+ }
+
+ memset(link, 0, sizeof(RedLinkInfo));
+ memset(peer, 0, sizeof(RedsStreamContext));
+ link->peer = peer;
+ peer->socket = socket;
+ openssl_init(link);
+
+ return link;
+
+error2:
+ free(link);
+
+error1:
+ close(socket);
+
+ return NULL;
+}
+
+static RedLinkInfo *reds_accept_connection(int listen_socket)
+{
+ RedLinkInfo *link;
+ RedsStreamContext *peer;
+
+ if (!(link = __reds_accept_connection(listen_socket))) {
+ return NULL;
+ }
+ peer = link->peer;
+ peer->ctx = (void *)((unsigned long)link->peer->socket);
+ peer->cb_read = (int (*)(void *, void *, int))reds_read;
+ peer->cb_write = (int (*)(void *, void *, int))reds_write;
+ peer->cb_readv = (int (*)(void *, const struct iovec *vector, int count))readv;
+ peer->cb_writev = (int (*)(void *, const struct iovec *vector, int count))writev;
+ peer->cb_free = (int (*)(RedsStreamContext *))reds_free;
+
+ return link;
+}
+
+static void reds_accept_ssl_connection(void *data)
+{
+ RedLinkInfo *link;
+ int return_code;
+ int ssl_error;
+ BIO *sbio;
+
+ link = __reds_accept_connection(reds->secure_listen_socket);
+ if (link == NULL) {
+ return;
+ }
+
+ // Handle SSL handshaking
+ if (!(sbio = BIO_new_socket(link->peer->socket, BIO_NOCLOSE))) {
+ red_printf("could not allocate ssl bio socket");
+ goto error;
+ }
+
+ link->peer->ssl = SSL_new(reds->ctx);
+ if (!link->peer->ssl) {
+ red_printf("could not allocate ssl context");
+ BIO_free(sbio);
+ goto error;
+ }
+
+ SSL_set_bio(link->peer->ssl, sbio, sbio);
+
+ link->peer->ctx = (void *)(link->peer->ssl);
+ link->peer->cb_write = (int (*)(void *, void *, int))reds_ssl_write;
+ link->peer->cb_read = (int (*)(void *, void *, int))reds_ssl_read;
+ link->peer->cb_readv = NULL;
+ link->peer->cb_writev = reds_ssl_writev;
+ link->peer->cb_free = (int (*)(RedsStreamContext *))reds_ssl_free;
+
+ return_code = SSL_accept(link->peer->ssl);
+ if (return_code == 1) {
+ reds_handle_new_link(link);
+ return;
+ }
+
+ ssl_error = SSL_get_error(link->peer->ssl, return_code);
+ if (return_code == -1 && (ssl_error == SSL_ERROR_WANT_READ ||
+ ssl_error == SSL_ERROR_WANT_WRITE)) {
+ core->set_file_handlers(core, link->peer->socket, reds_handle_ssl_accept,
+ reds_handle_ssl_accept, link);
+ return;
+ }
+
+ ERR_print_errors_fp(stderr);
+ red_printf("SSL_accept failed, error=%d", ssl_error);
+ SSL_free(link->peer->ssl);
+
+error:
+ close(link->peer->socket);
+ free(link->peer);
+ BN_free(link->tiTicketing.bn);
+ free(link);
+}
+
+static void reds_accept(void *data)
+{
+ RedLinkInfo *link;
+
+ link = reds_accept_connection(reds->listen_socket);
+ if (link == NULL) {
+ red_printf("accept failed");
+ return;
+ }
+ reds_handle_new_link(link);
+}
+
+static int reds_init_socket(uint16_t port)
+{
+ struct sockaddr_in addr;
+ int sock;
+ int flags;
+
+ if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
+ red_error("socket failed, %s", strerror(errno));
+ }
+
+ flags = 1;
+ if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags)) < 0) {
+ red_error("socket set sockopt failed, %s", strerror(errno));
+ }
+
+ addr.sin_family = AF_INET;
+ addr.sin_port = htons(port);
+ addr.sin_addr.s_addr = spice_addr.s_addr;
+ if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+ red_error("bind failed, %s", strerror(errno));
+ }
+
+ if ((flags = fcntl(sock, F_GETFL)) == -1) {
+ red_error("fcntl get failed, %s", strerror(errno));
+ }
+
+ if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
+ red_error("fcntl set failed, %s", strerror(errno));
+ }
+
+ if (listen(sock, 2) == -1) {
+ red_error("listen failed, %s", strerror(errno));
+ }
+
+ return sock;
+}
+
+static void reds_init_net()
+{
+ if (spice_port != -1) {
+ reds->listen_socket = reds_init_socket(spice_port);
+ if (core->set_file_handlers(core, reds->listen_socket, reds_accept, NULL, NULL)) {
+ red_error("set fd handle failed");
+ }
+ }
+
+ if (spice_secure_port != -1) {
+ reds->secure_listen_socket = reds_init_socket(spice_secure_port);
+ if (core->set_file_handlers(core, reds->secure_listen_socket,
+ reds_accept_ssl_connection, NULL, NULL)) {
+ red_error("set fd handle failed");
+ }
+ }
+}
+
+static void load_dh_params(SSL_CTX *ctx, char *file)
+{
+ DH *ret = 0;
+ BIO *bio;
+
+ if ((bio = BIO_new_file(file, "r")) == NULL) {
+ red_error("Could not open DH file");
+ }
+
+ ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
+ if (ret == 0) {
+ red_error("Could not read DH params");
+ }
+
+ BIO_free(bio);
+
+ if (SSL_CTX_set_tmp_dh(ctx, ret) < 0) {
+ red_error("Could not set DH params");
+ }
+}
+
+/*The password code is not thread safe*/
+static int ssl_password_cb(char *buf, int size, int flags, void *userdata)
+{
+ char *pass = ssl_parameters.keyfile_password;
+ if (size < strlen(pass) + 1) {
+ return (0);
+ }
+
+ strcpy(buf, pass);
+ return (strlen(pass));
+}
+
+static unsigned long pthreads_thread_id(void)
+{
+ unsigned long ret;
+
+ ret = (unsigned long)pthread_self();
+ return (ret);
+}
+
+static void pthreads_locking_callback(int mode, int type, char *file, int line)
+{
+ if (mode & CRYPTO_LOCK) {
+ pthread_mutex_lock(&(lock_cs[type]));
+ lock_count[type]++;
+ } else {
+ pthread_mutex_unlock(&(lock_cs[type]));
+ }
+}
+
+static void openssl_thread_setup()
+{
+ int i;
+
+ lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
+ lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
+
+ for (i = 0; i < CRYPTO_num_locks(); i++) {
+ lock_count[i] = 0;
+ pthread_mutex_init(&(lock_cs[i]), NULL);
+ }
+
+ CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
+ CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
+}
+
+static void reds_init_ssl()
+{
+ SSL_METHOD *ssl_method;
+ int return_code;
+ long ssl_options = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;
+
+ /* Global system initialization*/
+ SSL_library_init();
+ SSL_load_error_strings();
+
+ /* Create our context*/
+ ssl_method = TLSv1_method();
+ reds->ctx = SSL_CTX_new(ssl_method);
+ if (!reds->ctx) {
+ red_error("Could not allocate new SSL context");
+ }
+
+ /* Limit connection to TLSv1 only */
+#ifdef SSL_OP_NO_COMPRESSION
+ ssl_options |= SSL_OP_NO_COMPRESSION;
+#endif
+ SSL_CTX_set_options(reds->ctx, ssl_options);
+
+ /* Load our keys and certificates*/
+ return_code = SSL_CTX_use_certificate_chain_file(reds->ctx, ssl_parameters.certs_file);
+ if (return_code != 1) {
+ red_error("Could not load certificates from %s", ssl_parameters.certs_file);
+ }
+
+ SSL_CTX_set_default_passwd_cb(reds->ctx, ssl_password_cb);
+
+ return_code = SSL_CTX_use_PrivateKey_file(reds->ctx, ssl_parameters.private_key_file,
+ SSL_FILETYPE_PEM);
+ if (return_code != 1) {
+ red_error("Could not user private key file");
+ }
+
+ /* Load the CAs we trust*/
+ return_code = SSL_CTX_load_verify_locations(reds->ctx, ssl_parameters.ca_certificate_file, 0);
+ if (return_code != 1) {
+ red_error("Could not use ca file");
+ }
+
+#if (OPENSSL_VERSION_NUMBER < 0x00905100L)
+ SSL_CTX_set_verify_depth(reds->ctx, 1);
+#endif
+
+ load_dh_params(reds->ctx, ssl_parameters.dh_key_file);
+
+ SSL_CTX_set_session_id_context(reds->ctx, (const unsigned char *)"SPICE", 5);
+ SSL_CTX_set_cipher_list(reds->ctx, ssl_parameters.ciphersuite);
+
+ openssl_thread_setup();
+
+#ifndef SSL_OP_NO_COMPRESSION
+ STACK *cmp_stack = SSL_COMP_get_compression_methods();
+ sk_zero(cmp_stack);
+#endif
+}
+
+static void reds_exit()
+{
+ if (reds->peer) {
+ close(reds->peer->socket);
+ }
+#ifdef RED_STATISTICS
+ shm_unlink(reds->stat_shm_name);
+ free(reds->stat_shm_name);
+#endif
+ unsetenv("QEMU_AUDIO_DRV");
+}
+
+enum {
+ SPICE_OPTION_INVALID,
+ SPICE_OPTION_PORT,
+ SPICE_OPTION_SPORT,
+ SPICE_OPTION_HOST,
+ SPICE_OPTION_IMAGE_COMPRESSION,
+ SPICE_OPTION_PASSWORD,
+ SPICE_OPTION_DISABLE_TICKET,
+ SPICE_OPTION_RENDERER,
+ SPICE_OPTION_SSLKEY,
+ SPICE_OPTION_SSLCERTS,
+ SPICE_OPTION_SSLCAFILE,
+ SPICE_OPTION_SSLDHFILE,
+ SPICE_OPTION_SSLPASSWORD,
+ SPICE_OPTION_SSLCIPHERSUITE,
+ SPICE_SECURED_CHANNELS,
+ SPICE_UNSECURED_CHANNELS,
+ SPICE_OPTION_STREAMING_VIDEO,
+ SPICE_OPTION_AGENT_MOUSE,
+ SPICE_OPTION_PLAYBACK_COMPRESSION,
+};
+
+typedef struct OptionsMap {
+ const char *name;
+ int val;
+} OptionsMap;
+
+static int find_option(const char *str, OptionsMap *options_map)
+{
+ int i = 0;
+
+ for (i = 0; options_map[i].name != NULL; i++) {
+ if (strcmp(str, options_map[i].name) == 0) {
+ return options_map[i].val;
+ }
+ }
+ return SPICE_OPTION_INVALID;
+}
+
+static void clear_blanks(char **ptr)
+{
+ char *str = *ptr;
+ while (isspace(*str)) {
+ str++;
+ }
+ while (isspace(str[strlen(str) - 1])) {
+ str[strlen(str) - 1] = 0;
+ }
+ *ptr = str;
+}
+
+static int get_option(char **args, char **out_val, OptionsMap *map, char seperator)
+{
+ char *p;
+ char *next;
+ char *val;
+
+ ASSERT(args && out_val);
+
+ p = *args;
+ if ((next = strchr(p, seperator))) {
+ *next = 0;
+ *args = next + 1;
+ } else {
+ *args = NULL;
+ }
+
+ if ((val = strchr(p, '='))) {
+ *(val++) = 0;
+ clear_blanks(&val);
+ *out_val = (strlen(val) == 0) ? NULL : val;
+ } else {
+ *out_val = NULL;
+ }
+
+ clear_blanks(&p);
+ return find_option(p, map);
+}
+
+enum {
+ SPICE_TICKET_OPTION_INVALID,
+ SPICE_TICKET_OPTION_EXPIRATION,
+ SPICE_TICKET_OPTION_CONNECTED,
+};
+
+static OptionsMap _spice_ticket_options[] = {
+ {"expiration", SPICE_TICKET_OPTION_EXPIRATION},
+ {"connected", SPICE_TICKET_OPTION_CONNECTED},
+ {NULL, 0},
+};
+
+static inline void on_activating_ticketing()
+{
+ if (!ticketing_enabled && reds->peer) {
+ red_printf("disconnecting");
+ reds_disconnect();
+ }
+}
+
+static void reds_reset_ticketing()
+{
+ on_activating_ticketing();
+ ticketing_enabled = 1;
+ taTicket.expiration_time = 0;
+ memset(taTicket.password, 0, sizeof(taTicket.password));
+}
+
+static void reds_set_ticketing(const char *pass, long expiration)
+{
+ ASSERT(expiration >= 0);
+ on_activating_ticketing();
+ ticketing_enabled = 1;
+ if (expiration == 0) {
+ taTicket.expiration_time = INT_MAX;
+ } else {
+ time_t ltime;
+
+ time(&ltime);
+ taTicket.expiration_time = ltime + expiration;
+ }
+ strncpy(taTicket.password, pass, sizeof(taTicket.password));
+}
+
+static void reds_do_set_ticket(const char *password, const char *args)
+{
+ long expiration = 0;
+ char *local_args = NULL;
+ const char *term_str = "invalid args";
+ int disconnect = FALSE;
+ int fail = FALSE;
+
+ if (!password) {
+ term_str = "unexpected NULL password";
+ goto error;
+ }
+
+ if (args) {
+ char *in_args;
+ int option;
+ char *val;
+
+ in_args = local_args = malloc(strlen(args) + 1);
+ strcpy(local_args, args);
+ do {
+ switch (option = get_option(&in_args, &val, _spice_ticket_options, ',')) {
+ case SPICE_TICKET_OPTION_EXPIRATION: {
+ char *endptr;
+
+ if (!val) {
+ goto error;
+ }
+ expiration = strtol(val, &endptr, 0);
+ if (endptr != val + strlen(val) || expiration < 0) {
+ term_str = "invalid expiration";
+ goto error;
+ }
+ break;
+ }
+ case SPICE_TICKET_OPTION_CONNECTED:
+ if (!val) {
+ goto error;
+ }
+
+ if (strcmp(val, "disconnect") == 0) {
+ disconnect = TRUE;
+ fail = FALSE;
+ } else if (strcmp(val, "fail") == 0) {
+ fail = TRUE;
+ disconnect = FALSE;
+ } else if (strcmp(val, "keep") == 0) {
+ fail = FALSE;
+ disconnect = FALSE;
+ } else {
+ goto error;
+ }
+ break;
+ default:
+ goto error;
+ }
+ } while (in_args);
+ }
+
+ if (fail && reds->peer) {
+ term_str = "Ticket set failed";
+ } else {
+ if (disconnect) {
+ reds_disconnect();
+ }
+ reds_set_ticketing(password, expiration);
+ term_str = "Ticket set successfully";
+ }
+ core->term_printf(core, "%s\n", term_str);
+ free(local_args);
+ return;
+
+error:
+ reds_reset_ticketing();
+ core->term_printf(core, "%s\n", term_str);
+ free(local_args);
+}
+
+static void reds_do_set_ticket64(const char *password64, const char *args)
+{
+ char *password;
+
+ if (!password64) {
+ reds_reset_ticketing();
+ core->term_printf(core, "unexpected NULL password\n");
+ return;
+ }
+
+ if (!(password = base64decode(password64, strlen(password64)))) {
+ reds_reset_ticketing();
+ core->term_printf(core, "set_ticket64 failed!\n");
+ return;
+ }
+ reds_do_set_ticket(password, args);
+ free(password);
+}
+
+static void reds_do_info_spice()
+{
+ core->term_printf(core, "spice info:");
+ if (reds->peer) {
+ char *ip = NULL;
+ struct sockaddr_in sock_addr;
+ socklen_t len = sizeof(sock_addr);
+ if (getpeername(reds->peer->socket, (struct sockaddr *)&sock_addr, &len) != -1) {
+ ip = inet_ntoa(sock_addr.sin_addr);
+ }
+ core->term_printf(core, " client=%s", ip);
+ } else {
+ core->term_printf(core, " disconnected");
+ }
+ core->term_printf(core, " ticketing=%s", ticketing_enabled ? "on" : "off");
+ switch (image_compression) {
+ case IMAGE_COMPRESS_AUTO_GLZ:
+ core->term_printf(core, " ic=auto_glz");
+ break;
+ case IMAGE_COMPRESS_AUTO_LZ:
+ core->term_printf(core, " ic=auto_lz");
+ break;
+ case IMAGE_COMPRESS_QUIC:
+ core->term_printf(core, " ic=quic");
+ break;
+ case IMAGE_COMPRESS_LZ:
+ core->term_printf(core, " ic=lz");
+ break;
+ case IMAGE_COMPRESS_GLZ:
+ core->term_printf(core, " ic=glz");
+ break;
+ case IMAGE_COMPRESS_OFF:
+ core->term_printf(core, " ic=off");
+ break;
+ case IMAGE_COMPRESS_INVALID:
+ default:
+ core->term_printf(core, " ic=invalid");
+ }
+
+ core->term_printf(core, " sv=%s", streaming_video ? "on" : "off");
+ core->term_printf(core, " playback-compression=%s\n",
+ snd_get_playback_compression() ? "on" : "off");
+}
+
+static void set_image_compression(image_compression_t val)
+{
+ if (val == image_compression) {
+ return;
+ }
+ image_compression = val;
+ red_dispatcher_on_ic_change();
+}
+
+static image_compression_t reds_get_image_compression(const char *val)
+{
+ if ((strcmp(val, "on") == 0) || (strcmp(val, "auto_glz") == 0)) {
+ return IMAGE_COMPRESS_AUTO_GLZ;
+ } else if (strcmp(val, "auto_lz") == 0) {
+ return IMAGE_COMPRESS_AUTO_LZ;
+ } else if (strcmp(val, "quic") == 0) {
+ return IMAGE_COMPRESS_QUIC;
+ } else if (strcmp(val, "glz") == 0) {
+ return IMAGE_COMPRESS_GLZ;
+ } else if (strcmp(val, "lz") == 0) {
+ return IMAGE_COMPRESS_LZ;
+ } else if (strcmp(val, "off") == 0) {
+ return IMAGE_COMPRESS_OFF;
+ }
+ return IMAGE_COMPRESS_INVALID;
+}
+
+static void reds_do_set_image_compression(const char *val)
+{
+ image_compression_t real_val = reds_get_image_compression(val);
+ if (real_val == IMAGE_COMPRESS_INVALID) {
+ core->term_printf(core, "bad image compression arg\n");
+ return;
+ }
+ set_image_compression(real_val);
+}
+
+static void reds_do_set_streaming_video(const char *val)
+{
+ uint32_t new_val;
+ if (strcmp(val, "on") == 0) {
+ new_val = TRUE;
+ } else if (strcmp(val, "off") == 0) {
+ new_val = FALSE;
+ } else {
+ core->term_printf(core, "bad streaming video arg\n");
+ return;
+ }
+ if (new_val == streaming_video) {
+ return;
+ }
+ streaming_video = new_val;
+ red_dispatcher_on_sv_change();
+}
+
+static void reds_do_set_agent_mouse(const char *val)
+{
+ int new_val;
+ if (strcmp(val, "on") == 0) {
+ new_val = TRUE;
+ } else if (strcmp(val, "off") == 0) {
+ new_val = FALSE;
+ } else {
+ core->term_printf(core, "bad agent mouse arg\n");
+ return;
+ }
+ if (new_val == agent_mouse) {
+ return;
+ }
+ agent_mouse = new_val;
+ reds_update_mouse_mode();
+}
+
+static void reds_do_set_playback_compression(const char *val)
+{
+ int on;
+ if (strcmp(val, "on") == 0) {
+ on = TRUE;
+ } else if (strcmp(val, "off") == 0) {
+ on = FALSE;
+ } else {
+ core->term_printf(core, "bad playback compression arg\n");
+ return;
+ }
+ snd_set_playback_compression(on);
+}
+
+static OptionsMap _spice_options[] = {
+ {"port", SPICE_OPTION_PORT},
+ {"sport", SPICE_OPTION_SPORT},
+ {"host", SPICE_OPTION_HOST},
+ {"ic", SPICE_OPTION_IMAGE_COMPRESSION},
+ {"password", SPICE_OPTION_PASSWORD},
+ {"disable-ticketing", SPICE_OPTION_DISABLE_TICKET},
+ {"renderer", SPICE_OPTION_RENDERER},
+ {"sslkey", SPICE_OPTION_SSLKEY},
+ {"sslcert", SPICE_OPTION_SSLCERTS},
+ {"sslcafile", SPICE_OPTION_SSLCAFILE},
+ {"ssldhfile", SPICE_OPTION_SSLDHFILE},
+ {"sslpassword", SPICE_OPTION_SSLPASSWORD},
+ {"sslciphersuite", SPICE_OPTION_SSLCIPHERSUITE},
+ {"secure-channels", SPICE_SECURED_CHANNELS},
+ {"unsecure-channels", SPICE_UNSECURED_CHANNELS},
+ {"sv", SPICE_OPTION_STREAMING_VIDEO},
+ {"agent-mouse", SPICE_OPTION_AGENT_MOUSE},
+ {"playback-compression", SPICE_OPTION_PLAYBACK_COMPRESSION},
+ {NULL, 0},
+};
+
+enum {
+ CHANNEL_NAME_INVALID,
+ CHANNEL_NAME_ALL,
+ CHANNEL_NAME_MAIN,
+ CHANNEL_NAME_DISPLAY,
+ CHANNEL_NAME_INPUTS,
+ CHANNEL_NAME_CURSOR,
+ CHANNEL_NAME_PLAYBACK,
+ CHANNEL_NAME_RECORD,
+};
+
+static OptionsMap _channel_map[] = {
+ {"all", CHANNEL_NAME_ALL},
+ {"main", CHANNEL_NAME_MAIN},
+ {"display", CHANNEL_NAME_DISPLAY},
+ {"inputs", CHANNEL_NAME_INPUTS},
+ {"cursor", CHANNEL_NAME_CURSOR},
+ {"playback", CHANNEL_NAME_PLAYBACK},
+ {"record", CHANNEL_NAME_RECORD},
+ {NULL, 0},
+};
+
+static void set_all_channels_security(uint32_t security)
+{
+ while (channels_security) {
+ ChannelSecurityOptions *temp = channels_security;
+ channels_security = channels_security->next;
+ free(temp);
+ }
+ default_channel_security = security;
+}
+
+static void set_one_channel_security(int id, uint32_t security)
+{
+ ChannelSecurityOptions *security_options;
+
+ if ((security_options = find_channel_security(id))) {
+ security_options->options = security;
+ return;
+ }
+ security_options = (ChannelSecurityOptions *)malloc(sizeof(*security_options));
+ if (!security_options) {
+ red_error("malloc failed");
+ }
+ security_options->channel_id = id;
+ security_options->options = security;
+ security_options->next = channels_security;
+ channels_security = security_options;
+}
+
+static int set_channels_security(const char *channels, uint32_t security)
+{
+ char *local_str = malloc(strlen(channels) + 1);
+ int channel_name;
+ char *str;
+ char *val;
+ int all = 0;
+ int specific = 0;
+
+ if (!local_str) {
+ red_error("malloc failed");
+ }
+ strcpy(local_str, channels);
+ str = local_str;
+ do {
+ switch (channel_name = get_option(&str, &val, _channel_map, '+')) {
+ case CHANNEL_NAME_ALL:
+ all++;
+ break;
+ case CHANNEL_NAME_MAIN:
+ specific++;
+ set_one_channel_security(RED_CHANNEL_MAIN, security);
+ break;
+ case CHANNEL_NAME_DISPLAY:
+ specific++;
+ set_one_channel_security(RED_CHANNEL_DISPLAY, security);
+ break;
+ case CHANNEL_NAME_INPUTS:
+ specific++;
+ set_one_channel_security(RED_CHANNEL_INPUTS, security);
+ break;
+ case CHANNEL_NAME_CURSOR:
+ specific++;
+ set_one_channel_security(RED_CHANNEL_CURSOR, security);
+ break;
+ case CHANNEL_NAME_PLAYBACK:
+ specific++;
+ set_one_channel_security(RED_CHANNEL_PLAYBACK, security);
+ break;
+ case CHANNEL_NAME_RECORD:
+ specific++;
+ set_one_channel_security(RED_CHANNEL_RECORD, security);
+ break;
+ default:
+ goto error;
+ }
+ if (val) {
+ goto error;
+ }
+ } while (str);
+
+ if (all) {
+ if (specific || all > 1) {
+ goto error;
+ }
+ set_all_channels_security(security);
+ return TRUE;
+ }
+ return TRUE;
+
+error:
+ free(local_str);
+ return FALSE;
+}
+
+int __attribute__ ((visibility ("default"))) spice_parse_args(const char *in_args)
+{
+ char *local_args;
+ char *args;
+ int option;
+ char *val;
+ int renderers_opt = FALSE;
+
+ int ssl_port = FALSE;
+ int ssl_key = FALSE;
+ int ssl_certs = FALSE;
+ int ssl_ciphersuite = FALSE;
+ int ssl_cafile = FALSE;
+ int ssl_dhfile = FALSE;
+
+ memset(&ssl_parameters, 0, sizeof(ssl_parameters));
+
+ local_args = malloc(strlen(in_args) + 1);
+ strcpy(local_args, in_args);
+
+ args = local_args;
+ do {
+ switch (option = get_option(&args, &val, _spice_options, ',')) {
+ case SPICE_OPTION_PORT: {
+ char *endptr;
+ long int port;
+
+ if (!val) {
+ goto error;
+ }
+ port = strtol(val, &endptr, 0);
+ if (endptr != val + strlen(val) || port < 0 || port > 0xffff) {
+ goto error;
+ }
+ spice_port = port;
+ break;
+ }
+ case SPICE_OPTION_SPORT: {
+ char *endptr;
+ long int port;
+
+ if (!val) {
+ goto error;
+ }
+ port = strtol(val, &endptr, 0);
+ if (endptr != val + strlen(val) || port < 0 || port > 0xffff) {
+ goto error;
+ }
+
+ ssl_port = TRUE;
+ spice_secure_port = port;
+ break;
+ }
+ case SPICE_OPTION_HOST: {
+ struct hostent* host_addr;
+ if (!val) {
+ goto error;
+ }
+ if ((host_addr = gethostbyname(val)) == NULL || host_addr->h_addrtype != AF_INET) {
+ goto error;
+ }
+ ASSERT(host_addr->h_length == sizeof(spice_addr));
+ memcpy(&spice_addr, host_addr->h_addr, sizeof(spice_addr));
+ break;
+ }
+ case SPICE_OPTION_IMAGE_COMPRESSION:
+ if (!val) {
+ goto error;
+ }
+ image_compression = reds_get_image_compression(val);
+ if (image_compression == IMAGE_COMPRESS_INVALID) {
+ goto error;
+ }
+ break;
+ case SPICE_OPTION_PASSWORD:
+ ticketing_enabled = 1;
+
+ if (val) {
+ strncpy(taTicket.password, val, sizeof taTicket.password);
+ //todo: add expiration option
+ taTicket.expiration_time = INT_MAX;
+ }
+
+ break;
+ case SPICE_OPTION_DISABLE_TICKET:
+ ticketing_enabled = 0;
+ break;
+ case SPICE_OPTION_RENDERER:
+ renderers_opt = TRUE;
+ if (!val) {
+ goto error;
+ }
+ while (val) {
+ char *now = val;
+ if ((val = strchr(now, '+'))) {
+ *val++ = 0;
+ }
+ if (!red_dispatcher_add_renderer(now)) {
+ goto error;
+ }
+ }
+
+ break;
+ case SPICE_OPTION_SSLCIPHERSUITE:
+ ssl_ciphersuite = TRUE;
+
+ if (val) {
+ strncpy(ssl_parameters.ciphersuite, val, sizeof(ssl_parameters.ciphersuite));
+ }
+
+ break;
+ case SPICE_OPTION_SSLPASSWORD:
+ if (val) {
+ strncpy(ssl_parameters.keyfile_password, val,
+ sizeof(ssl_parameters.keyfile_password));
+ }
+ break;
+ case SPICE_OPTION_SSLKEY:
+ ssl_key = TRUE;
+
+ if (val) {
+ strncpy(ssl_parameters.private_key_file, val,
+ sizeof(ssl_parameters.private_key_file));
+ }
+ break;
+ case SPICE_OPTION_SSLCERTS:
+ ssl_certs = TRUE;
+
+ if (val) {
+ strncpy(ssl_parameters.certs_file, val, sizeof(ssl_parameters.certs_file));
+ }
+ break;
+ case SPICE_OPTION_SSLCAFILE:
+ ssl_cafile = TRUE;
+
+ if (val) {
+ strncpy(ssl_parameters.ca_certificate_file, val,
+ sizeof(ssl_parameters.ca_certificate_file));
+ }
+ break;
+ case SPICE_OPTION_SSLDHFILE:
+ ssl_dhfile = TRUE;
+
+ if (val) {
+ strncpy(ssl_parameters.dh_key_file, val, sizeof(ssl_parameters.dh_key_file));
+ }
+ break;
+ case SPICE_SECURED_CHANNELS:
+ if (!val || !set_channels_security(val, CHANNEL_SECURITY_SSL)) {
+ goto error;
+ }
+ break;
+ case SPICE_UNSECURED_CHANNELS:
+ if (!val || !set_channels_security(val, CHANNEL_SECURITY_NON)) {
+ goto error;
+ }
+ break;
+ case SPICE_OPTION_STREAMING_VIDEO:
+ if (!val) {
+ goto error;
+ }
+ if (strcmp(val, "off") == 0) {
+ streaming_video = FALSE;
+ } else if (strcmp(val, "on") != 0) {
+ goto error;
+ }
+ break;
+ case SPICE_OPTION_PLAYBACK_COMPRESSION:
+ if (!val) {
+ goto error;
+ }
+ if (strcmp(val, "on") == 0) {
+ snd_set_playback_compression(TRUE);
+ } else if (strcmp(val, "off") == 0) {
+ snd_set_playback_compression(FALSE);
+ } else {
+ goto error;
+ }
+ break;
+ case SPICE_OPTION_AGENT_MOUSE:
+ if (!val) {
+ goto error;
+ }
+ if (strcmp(val, "on") == 0) {
+ agent_mouse = TRUE;
+ } else if (strcmp(val, "off") == 0) {
+ agent_mouse = FALSE;
+ } else {
+ goto error;
+ }
+ break;
+ default:
+ goto error;
+ }
+ } while (args);
+
+ if (!renderers_opt && !red_dispatcher_add_renderer("cairo")) {
+ goto error;
+ }
+
+ // All SSL parameters should be either on or off.
+ if (ssl_port != ssl_key || ssl_key != ssl_certs || ssl_certs != ssl_cafile ||
+ ssl_cafile != ssl_dhfile || ssl_dhfile != ssl_ciphersuite) {
+
+ goto error;
+ }
+ free(local_args);
+ return TRUE;
+
+error:
+ free(local_args);
+ return FALSE;
+}
+
+const char *spice_usage_str[] __attribute__ ((visibility ("default"))) = {
+ "[port=<port>][,sport=<port>][,host=<host>]",
+ "[,ic=on|auto_glz|auto_lz|quic|glz|lz|off]",
+ "[,playback-compression=on|off]",
+ "[,password=password][,disable-ticketing]",
+ "[,renderer=oglpbuf+oglpixmap+cairo]",
+ "[,sslkeys=key directory,sslcerts=certs directory,sslpassword=pem password,",
+ " sslciphersuite=cipher suite]",
+ "[,secure-channels=all|channel+channel+...]",
+ "[,unsecure-channels=all|channel+channel+...]",
+ "[,vs=on|off] [,ac=on|off]",
+ " listen on interface address <host> port <port> and/or sport <port>",
+ " setting ticket password using \"ticket\" option",
+ " setting image compression using \"ic\" option [default=auto_local]",
+ " setting playback compression using \"playback-compression\" option [default=on]",
+ " select renderers using \"renderer\" option",
+ " sslkeys - set directory where ssl key file resides.",
+ " sslcerts - set directory where ssl cert file resides.",
+ " sslpassword - set the password to open the private key file.",
+ " sslciphersuite - set the cipher suite to use.",
+ " setting streaming video using \"sv\" option [default=on]",
+ " setting audio compression codec using \"ac\" option [default=off]",
+ " secure-channels - force secure connection on all/specific chnnels.",
+ " channels names: main, inputs, display, cursor,",
+ " playback and record.",
+ " unsecure-channels - force unsecure connection on all/specific chnnels.",
+ " channels names as in secure-channels.",
+ NULL,
+};
+
+#define REDS_SAVE_VERSION 1
+
+static OptionsMap spice_mig_options[] = {
+ {"spicesport", SPICE_OPTION_SPORT},
+ {"spiceport", SPICE_OPTION_PORT},
+ {"spicehost", SPICE_OPTION_HOST},
+ {NULL, 0},
+};
+
+struct RedsMigSpice;
+
+typedef struct RedsMigRead {
+ uint8_t buf[RECIVE_BUF_SIZE];
+ uint32_t end_pos;
+ uint32_t size;
+
+ void (*handle_data)(struct RedsMigSpice *message);
+} RedsMigRead;
+
+typedef struct RedsMigWrite {
+ uint8_t buf[SEND_BUF_SIZE];
+ uint8_t *now;
+ uint32_t length;
+
+ void (*handle_done)(struct RedsMigSpice *s);
+} RedsMigWrite;
+
+typedef struct RedsMigSpice {
+ int fd;
+ RedsMigWrite write;
+ RedsMigRead read;
+
+ char pub_key[RED_TICKET_PUBKEY_BYTES];
+ uint32_t mig_key;
+
+ char *local_args;
+ char *host;
+ int port;
+ int sport;
+} RedsMigSpice;
+
+typedef struct RedsMigSpiceMessage {
+ uint32_t link_id;
+} RedsMigSpiceMessage;
+
+static int reds_mig_actual_read(RedsMigSpice *s)
+{
+ for (;;) {
+ uint8_t *buf = s->read.buf;
+ uint32_t pos = s->read.end_pos;
+ int n;
+ n = read(s->fd, buf + pos, s->read.size - pos);
+ if (n <= 0) {
+ if (n == 0) {
+ return -1;
+ }
+ switch (errno) {
+ case EAGAIN:
+ return 0;
+ case EINTR:
+ break;
+ case EPIPE:
+ return -1;
+ default:
+ red_printf("%s", strerror(errno));
+ return -1;
+ }
+ } else {
+ s->read.end_pos += n;
+ if (s->read.end_pos == s->read.size) {
+ s->read.handle_data(s);
+ return 0;
+ }
+ }
+ }
+}
+
+static int reds_mig_actual_write(RedsMigSpice *s)
+{
+ if (!s->write.length) {
+ return 0;
+ }
+
+ while (s->write.length) {
+ int n;
+
+ n = write(s->fd, s->write.now, s->write.length);
+ if (n <= 0) {
+ if (n == 0) {
+ return -1;
+ }
+ switch (errno) {
+ case EAGAIN:
+ return 0;
+ case EINTR:
+ break;
+ case EPIPE:
+ return -1;
+ default:
+ red_printf("%s", strerror(errno));
+ return -1;
+ }
+ } else {
+ s->write.now += n;
+ s->write.length -= n;
+ }
+ }
+
+ s->write.handle_done(s);
+ return 0;
+}
+
+static void reds_mig_failed(RedsMigSpice *s)
+{
+ red_printf("");
+ core->set_file_handlers(core, s->fd, NULL, NULL, NULL);
+ if (s->local_args) {
+ free(s->local_args);
+ }
+ free(s);
+
+ reds_mig_disconnect();
+}
+
+static void reds_mig_write(void *data)
+{
+ RedsMigSpice *s = data;
+
+ if (reds_mig_actual_write((RedsMigSpice *)data)) {
+ red_printf("write error cannot continue spice migration");
+ reds_mig_failed(s);
+ }
+}
+
+static void reds_mig_read(void *data)
+{
+ RedsMigSpice *s = data;
+
+ if (reds_mig_actual_read((RedsMigSpice *)data)) {
+ red_printf("read error cannot continue spice migration");
+ reds_mig_failed(s);
+ }
+}
+
+static void reds_mig_continue(RedsMigSpice *s)
+{
+ RedMigrationBegin *migrate;
+ SimpleOutItem *item;
+ int host_len;
+
+ red_printf("");
+ core->set_file_handlers(core, s->fd, NULL, NULL, NULL);
+ host_len = strlen(s->host) + 1;
+ if (!(item = new_simple_out_item(RED_MIGRATE_BEGIN, sizeof(RedMigrationBegin) + host_len))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+ migrate = (RedMigrationBegin *)item->data;
+ migrate->port = s->port;
+ migrate->sport = s->sport;
+ memcpy(migrate->host, s->host, host_len);
+ reds_push_pipe_item(&item->base);
+
+ free(s->local_args);
+ free(s);
+ reds->mig_wait_connect = TRUE;
+ core->arm_timer(core, reds->mig_timer, MIGRATE_TIMEOUT);
+}
+
+static void reds_mig_receive_ack(RedsMigSpice *s)
+{
+ s->read.size = sizeof(uint32_t);
+ s->read.end_pos = 0;
+ s->read.handle_data = reds_mig_continue;
+
+ core->set_file_handlers(core, s->fd, reds_mig_read, NULL, s);
+}
+
+static void reds_mig_send_link_id(RedsMigSpice *s)
+{
+ RedsMigSpiceMessage *data = (RedsMigSpiceMessage *)s->write.buf;
+
+ memcpy(&data->link_id, &reds->link_id, sizeof(reds->link_id));
+
+ s->write.now = s->write.buf;
+ s->write.length = sizeof(RedsMigSpiceMessage);
+ s->write.handle_done = reds_mig_receive_ack;
+
+ core->set_file_handlers(core, s->fd, reds_mig_write, reds_mig_write, s);
+}
+
+static void reds_mig_send_ticket(RedsMigSpice *s)
+{
+ EVP_PKEY *pubkey = NULL;
+ BIO *bio_key;
+ RSA *rsa;
+ int rsa_size = 0;
+
+ red_printf("");
+
+ bio_key = BIO_new(BIO_s_mem());
+ if (bio_key != NULL) {
+ BIO_write(bio_key, s->read.buf, RED_TICKET_PUBKEY_BYTES);
+ pubkey = d2i_PUBKEY_bio(bio_key, NULL);
+ rsa = pubkey->pkey.rsa;
+ rsa_size = RSA_size(rsa);
+ if (RSA_public_encrypt(strlen(reds->taTicket.password) + 1,
+ (unsigned char *)reds->taTicket.password,
+ (uint8_t *)(s->write.buf),
+ rsa, RSA_PKCS1_OAEP_PADDING) > 0) {
+ s->write.length = RSA_size(rsa);
+ s->write.now = s->write.buf;
+ s->write.handle_done = reds_mig_send_link_id;
+ core->set_file_handlers(core, s->fd, reds_mig_write, reds_mig_write, s);
+ } else {
+ reds_mig_failed(s);
+ }
+ } else {
+ reds_mig_failed(s);
+ }
+
+ EVP_PKEY_free(pubkey);
+ BIO_free(bio_key);
+}
+
+static void reds_mig_control(RedsMigSpice *spice_migration)
+{
+ uint32_t *control;
+
+ core->set_file_handlers(core, spice_migration->fd, NULL, NULL, NULL);
+ control = (uint32_t *)spice_migration->read.buf;
+
+ switch (*control) {
+ case REDS_MIG_CONTINUE:
+ spice_migration->read.size = RED_TICKET_PUBKEY_BYTES;
+ spice_migration->read.end_pos = 0;
+ spice_migration->read.handle_data = reds_mig_send_ticket;
+
+ core->set_file_handlers(core, spice_migration->fd, reds_mig_read,
+ NULL, spice_migration);
+ break;
+ case REDS_MIG_ABORT:
+ red_printf("abort");
+ reds_mig_failed(spice_migration);
+ break;
+ default:
+ red_printf("invalid control");
+ reds_mig_failed(spice_migration);
+ }
+}
+
+static void reds_mig_receive_control(RedsMigSpice *spice_migration)
+{
+ spice_migration->read.size = sizeof(uint32_t);
+ spice_migration->read.end_pos = 0;
+ spice_migration->read.handle_data = reds_mig_control;
+
+ core->set_file_handlers(core, spice_migration->fd, reds_mig_read, NULL, spice_migration);
+}
+
+static void reds_mig_started(void *opaque, const char *in_args)
+{
+ RedsMigSpice *spice_migration = NULL;
+ uint32_t *version;
+ char *val;
+ char *args;
+ int option;
+
+ ASSERT(in_args);
+ red_printf("");
+
+ reds->mig_inprogress = TRUE;
+
+ if (reds->listen_socket != -1) {
+ core->set_file_handlers(core, reds->listen_socket, NULL, NULL, NULL);
+ }
+
+ if (reds->secure_listen_socket != -1) {
+ core->set_file_handlers(core, reds->secure_listen_socket, NULL, NULL, NULL);
+ }
+
+ if (reds->peer == NULL) {
+ red_printf("not connected to peer");
+ goto error;
+ }
+
+ spice_migration = (RedsMigSpice *)malloc(sizeof(RedsMigSpice));
+ if (!spice_migration) {
+ red_printf("Could not allocate memory for spice migration structure");
+ goto error;
+ }
+ memset(spice_migration, 0, sizeof(RedsMigSpice));
+ spice_migration->port = -1;
+ spice_migration->sport = -1;
+
+ if (!(spice_migration->local_args = malloc(strlen(in_args) + 1))) {
+ red_printf("str malloc failed");
+ goto error;
+ }
+
+ strcpy(spice_migration->local_args, in_args);
+ args = spice_migration->local_args;
+ do {
+ switch (option = get_option(&args, &val, spice_mig_options, ',')) {
+ case SPICE_OPTION_SPORT: {
+ char *endptr;
+
+ if (!val) {
+ goto error;
+ }
+ spice_migration->sport = strtol(val, &endptr, 0);
+ if (endptr != val + strlen(val) || spice_migration->sport < 0 ||
+ spice_migration->sport > 0xffff) {
+ goto error;
+ }
+ break;
+ }
+ case SPICE_OPTION_PORT: {
+ char *endptr;
+
+ if (!val) {
+ goto error;
+ }
+ spice_migration->port = strtol(val, &endptr, 0);
+ if (
+ endptr != val + strlen(val) ||
+ spice_migration->port < 0 ||
+ spice_migration->port > 0xffff
+ ) {
+ goto error;
+ }
+ break;
+ }
+ case SPICE_OPTION_HOST:
+ if (!val) {
+ goto error;
+ }
+ spice_migration->host = val;
+ break;
+ }
+ } while (args);
+
+ if ((spice_migration->sport == -1 && spice_migration->port == -1) || !spice_migration->host) {
+ red_printf("invalid args port %d sport %d host %s",
+ spice_migration->port,
+ spice_migration->sport,
+ (spice_migration->host) ? spice_migration->host : "NULL");
+ goto error;
+ }
+
+ spice_migration->fd = mig->begin_hook(mig, reds->mig_notifier);
+
+ if (spice_migration->fd == -1) {
+ goto error;
+ }
+
+ spice_migration->write.now = spice_migration->write.buf;
+ spice_migration->write.length = sizeof(uint32_t);
+ version = (uint32_t *)spice_migration->write.buf;
+ *version = REDS_MIG_VERSION;
+ spice_migration->write.handle_done = reds_mig_receive_control;
+ core->set_file_handlers(core, spice_migration->fd, reds_mig_write,
+ reds_mig_write, spice_migration);
+ return;
+
+error:
+ if (spice_migration) {
+ if (spice_migration->local_args) {
+ free(spice_migration->local_args);
+ }
+ free(spice_migration);
+ }
+
+ reds_mig_disconnect();
+}
+
+static void reds_mig_finished(void *opaque, int completed)
+{
+ SimpleOutItem *item;
+
+ red_printf("");
+ if (reds->listen_socket != -1) {
+ core->set_file_handlers(core, reds->listen_socket, reds_accept, NULL, NULL);
+ }
+
+ if (reds->secure_listen_socket != -1) {
+ core->set_file_handlers(core, reds->secure_listen_socket, reds_accept_ssl_connection,
+ NULL, NULL);
+ }
+
+ if (reds->peer == NULL) {
+ red_printf("no peer connected");
+ mig->notifier_done(mig, reds->mig_notifier);
+ return;
+ }
+ reds->mig_inprogress = TRUE;
+
+ if (completed) {
+ Channel *channel;
+ RedMigrate *migrate;
+
+ reds->mig_wait_disconnect = TRUE;
+ core->arm_timer(core, reds->mig_timer, MIGRATE_TIMEOUT);
+
+ if (!(item = new_simple_out_item(RED_MIGRATE, sizeof(RedMigrate)))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+ migrate = (RedMigrate *)item->data;
+ migrate->flags = RED_MIGRATE_NEED_FLUSH | RED_MIGRATE_NEED_DATA_TRANSFER;
+ reds_push_pipe_item(&item->base);
+ channel = reds->channels;
+ while (channel) {
+ channel->migrate(channel);
+ channel = channel->next;
+ }
+ } else {
+ if (!(item = new_simple_out_item(RED_MIGRATE_CANCEL, 0))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+ reds_push_pipe_item(&item->base);
+ reds_mig_cleanup();
+ }
+}
+
+static int write_all(int fd, const void *in_buf, int len1)
+{
+ int ret, len;
+ uint8_t *buf = (uint8_t *)in_buf;
+
+ len = len1;
+ while (len > 0) {
+ ret = write(fd, buf, len);
+ if (ret < 0) {
+ if (errno != EINTR && errno != EAGAIN) {
+ return -1;
+ }
+ } else if (ret == 0) {
+ break;
+ } else {
+ buf += ret;
+ len -= ret;
+ }
+ }
+ return len1 - len;
+}
+
+static int read_all(int fd, void *in_nuf, int lenl)
+{
+ int ret, len;
+ uint8_t *buf = in_nuf;
+
+ len = lenl;
+ while (len > 0) {
+ ret = read(fd, buf, len);
+ if (ret < 0) {
+ if (errno != EINTR && errno != EAGAIN) {
+ return -1;
+ }
+ } else if (ret == 0) {
+ break;
+ } else {
+ buf += ret;
+ len -= ret;
+ }
+ }
+ return lenl - len;
+}
+
+static void reds_mig_read_all(int fd, void *buf, int len, const char *name)
+{
+ int n = read_all(fd, buf, len);
+ if (n != len) {
+ red_error("read %s failed, n=%d (%s)", name, n, strerror(errno));
+ }
+}
+
+static void reds_mig_write_all(int fd, void *buf, int len, const char *name)
+{
+ int n = write_all(fd, buf, len);
+ if (n != len) {
+ red_error("write %s faile, n=%d (%s)", name, n, strerror(errno));
+ }
+}
+
+static void reds_mig_recv(void *opaque, int fd)
+{
+ uint32_t ack_message = *(uint32_t *)"ack_";
+ char password[RED_MAX_PASSWORD_LENGTH];
+ RedsMigSpiceMessage mig_message;
+ unsigned long f4 = RSA_F4;
+ TicketInfo ticketing_info;
+ uint32_t version;
+ uint32_t resault;
+ BIO *bio;
+
+ BUF_MEM *buff;
+
+ reds_mig_read_all(fd, &version, sizeof(version), "version");
+
+ if (version != REDS_MIG_VERSION) {
+ resault = REDS_MIG_ABORT;
+ reds_mig_write_all(fd, &resault, sizeof(resault), "resault");
+ mig->notifier_done(mig, reds->mig_notifier);
+ return;
+ }
+
+ resault = REDS_MIG_CONTINUE;
+ reds_mig_write_all(fd, &resault, sizeof(resault), "resault");
+
+ ticketing_info.bn = BN_new();
+ if (!ticketing_info.bn) {
+ red_error("OpenSSL BIGNUMS alloc failed");
+ }
+
+ BN_set_word(ticketing_info.bn, f4);
+ if (!(ticketing_info.rsa = RSA_new())) {
+ red_error("OpenSSL RSA alloc failed");
+ }
+
+ RSA_generate_key_ex(ticketing_info.rsa, RED_TICKET_KEY_PAIR_LENGTH, ticketing_info.bn, NULL);
+ ticketing_info.rsa_size = RSA_size(ticketing_info.rsa);
+
+ if (!(bio = BIO_new(BIO_s_mem()))) {
+ red_error("OpenSSL BIO alloc failed");
+ }
+
+ i2d_RSA_PUBKEY_bio(bio, ticketing_info.rsa);
+ BIO_get_mem_ptr(bio, &buff);
+
+ reds_mig_write_all(fd, buff->data, RED_TICKET_PUBKEY_BYTES, "publick key");
+ reds_mig_read_all(fd, ticketing_info.encrypted_ticket.encrypted_data, ticketing_info.rsa_size,
+ "ticket");
+
+ RSA_private_decrypt(ticketing_info.rsa_size, ticketing_info.encrypted_ticket.encrypted_data,
+ (unsigned char *)password, ticketing_info.rsa, RSA_PKCS1_OAEP_PADDING);
+
+ BN_free(ticketing_info.bn);
+ BIO_free(bio);
+ RSA_free(ticketing_info.rsa);
+
+ memcpy(reds->taTicket.password, password, sizeof(reds->taTicket.password));
+ reds_mig_read_all(fd, &mig_message, sizeof(mig_message), "mig data");
+ reds->link_id = mig_message.link_id;
+ reds_mig_write_all(fd, &ack_message, sizeof(uint32_t), "ack");
+ mig->notifier_done(mig, reds->mig_notifier);
+}
+
+static void migrate_timout(void *opaque)
+{
+ red_printf("");
+ ASSERT(reds->mig_wait_connect || reds->mig_wait_disconnect);
+ reds_mig_disconnect();
+}
+
+static void key_modifiers_sender(void *opaque)
+{
+ reds_send_keyborad_modifiers(keyboard ? keyboard->get_leds(keyboard) : 0);
+}
+
+uint32_t reds_get_mm_time()
+{
+ struct timespec time_space;
+ clock_gettime(CLOCK_MONOTONIC, &time_space);
+ return time_space.tv_sec * 1000 + time_space.tv_nsec / 1000 / 1000;
+}
+
+void reds_update_mm_timer(uint32_t mm_time)
+{
+ red_dispatcher_set_mm_time(mm_time);
+}
+
+void reds_enable_mm_timer()
+{
+ RedMultiMediaTime *time_mes;
+ SimpleOutItem *item;
+
+ core->arm_timer(core, reds->mm_timer, MM_TIMER_GRANULARITY_MS);
+ if (!reds->peer) {
+ return;
+ }
+
+ if (!(item = new_simple_out_item(RED_MULTI_MEDIA_TIME, sizeof(RedMultiMediaTime)))) {
+ red_printf("alloc item failed");
+ reds_disconnect();
+ return;
+ }
+ time_mes = (RedMultiMediaTime *)item->data;
+ time_mes->time = reds_get_mm_time() - MM_TIME_DELTA;
+ reds_push_pipe_item(&item->base);
+}
+
+void reds_desable_mm_timer()
+{
+ core->disarm_timer(core, reds->mm_timer);
+}
+
+static void mm_timer_proc(void *opaque)
+{
+ red_dispatcher_set_mm_time(reds_get_mm_time());
+ core->arm_timer(core, reds->mm_timer, MM_TIMER_GRANULARITY_MS);
+}
+
+static void add_monitor_action_commands(QTermInterface *mon)
+{
+ mon->add_action_command_handler(mon, "spice", "set_image_compression", "s",
+ reds_do_set_image_compression,
+ "",
+ "<[on|auto_glz|auto_lz|quic|glz|lz|off]>");
+ mon->add_action_command_handler(mon, "spice", "set_streaming_video", "s",
+ reds_do_set_streaming_video,
+ "",
+ "<on|off>");
+ mon->add_action_command_handler(mon, "spice", "set_playback_compression", "s",
+ reds_do_set_playback_compression,
+ "",
+ "<on|off>");
+ mon->add_action_command_handler(mon, "spice", "set_ticket", "ss?",
+ reds_do_set_ticket,
+ "<password> [expiration=<seconds>]"
+ "[,connected=keep|disconnect|fail]",
+ "set the spice connection ticket");
+ mon->add_action_command_handler(mon, "spice", "set_ticket64", "ss?",
+ reds_do_set_ticket64,
+ "<password> [expiration=<seconds>]"
+ " [,connected=keep|disconnect|fail]",
+ "set the spice connection ticket");
+ mon->add_action_command_handler(mon, "spice", "disable_ticketing", "",
+ reds_do_disable_ticketing,
+ "",
+ "entirely disables OTP");
+ mon->add_action_command_handler(mon, "spice", "set_agent_mouse", "s",
+ reds_do_set_agent_mouse,
+ "",
+ "<on|off>");
+#ifdef RED_STATISTICS
+ mon->add_action_command_handler(mon, "spice", "reset_stat", "",
+ do_reset_statistics,
+ "",
+ "reset spice statistics");
+ mon->add_action_command_handler(mon, "spice", "ping_client", "s?i?",
+ do_ping_client,
+ "[on [interval]|off]",
+ "ping spice client to measure roundtrip");
+#endif
+}
+
+static void add_monitor_info_commands(QTermInterface *mon)
+{
+ mon->add_info_command_handler(mon, "spice", "state",
+ reds_do_info_spice,
+ "show spice state");
+ mon->add_info_command_handler(mon, "spice", "ticket",
+ reds_do_info_ticket,
+ "show ticket");
+#ifdef RED_STATISTICS
+ mon->add_info_command_handler(mon, "spice", "stat",
+ do_info_statistics,
+ "show spice statistics");
+ mon->add_info_command_handler(mon, "spice", "rtt_client",
+ do_info_rtt_client,
+ "show rtt to spice client");
+#endif
+}
+
+static void attach_to_red_agent(VDIPortInterface *interface)
+{
+ VDIPortState *state = &reds->agent_state;
+
+ vdagent = interface;
+ reds_update_mouse_mode();
+ if (!reds->peer) {
+ return;
+ }
+ state->plug_ref = vdagent->plug(vdagent, &state->plug);
+ reds->agent_state.plug_generation++;
+
+ if (reds->mig_target) {
+ return;
+ }
+
+ reds_send_agent_connected();
+}
+
+static void interface_change_notifier(void *opaque, VDInterface *interface,
+ VDInterfaceChangeType change)
+{
+ if (interface->base_version != VM_INTERFACE_VERSION) {
+ red_printf("unsuported base interface version");
+ return;
+ }
+ switch (change) {
+ case VD_INTERFACE_ADDING:
+ if (strcmp(interface->type, VD_INTERFACE_KEYBOARD) == 0) {
+ red_printf("VD_INTERFACE_KEYBOARD");
+ if (keyboard) {
+ red_printf("already have keyboard");
+ return;
+ }
+ if (interface->major_version != VD_INTERFACE_KEYBOARD_MAJOR ||
+ interface->minor_version < VD_INTERFACE_KEYBOARD_MINOR) {
+ red_printf("unsuported keyboard interface");
+ return;
+ }
+ keyboard = (KeyboardInterface *)interface;
+ if (!keyboard->register_leds_notifier(keyboard, reds_on_keyborad_leads_change, NULL)) {
+ red_error("register leds notifier failed");
+ }
+ } else if (strcmp(interface->type, VD_INTERFACE_MOUSE) == 0) {
+ red_printf("VD_INTERFACE_MOUSE");
+ if (mouse) {
+ red_printf("already have mouse");
+ return;
+ }
+ if (interface->major_version != VD_INTERFACE_MOUSE_MAJOR ||
+ interface->minor_version < VD_INTERFACE_MOUSE_MINOR) {
+ red_printf("unsuported mouse interface");
+ return;
+ }
+ mouse = (MouseInterface *)interface;
+ } else if (strcmp(interface->type, VD_INTERFACE_MIGRATION) == 0) {
+ red_printf("VD_INTERFACE_MIGRATION");
+ if (mig) {
+ red_printf("already have migration");
+ return;
+ }
+ if (interface->major_version != VD_INTERFACE_MIGRATION_MAJOR ||
+ interface->minor_version < VD_INTERFACE_MIGRATION_MINOR) {
+ red_printf("unsuported migration interface");
+ return;
+ }
+ mig = (MigrationInterface *)interface;
+ reds->mig_notifier = mig->register_notifiers(mig, MIGRATION_NOTIFY_SPICE_KEY,
+ reds_mig_started, reds_mig_finished,
+ reds_mig_recv, NULL);
+ if (reds->mig_notifier == INVALID_VD_OBJECT_REF) {
+ red_error("migration register failed");
+ }
+ } else if (strcmp(interface->type, VD_INTERFACE_QXL) == 0) {
+ QXLInterface *qxl_interface;
+
+ red_printf("VD_INTERFACE_QXL");
+ if (interface->major_version != VD_INTERFACE_QXL_MAJOR ||
+ interface->minor_version < VD_INTERFACE_QXL_MINOR) {
+ red_printf("unsuported qxl interface");
+ return;
+ }
+ qxl_interface = (QXLInterface *)interface;
+ red_dispatcher_init(qxl_interface);
+ } else if (strcmp(interface->type, VD_INTERFACE_QTERM) == 0) {
+ static int was_here = FALSE;
+ red_printf("VD_INTERFACE_QTERM");
+ if (was_here) {
+ return;
+ }
+ was_here = TRUE;
+ if (interface->major_version != VD_INTERFACE_QTERM_MAJOR ||
+ interface->minor_version < VD_INTERFACE_QTERM_MINOR) {
+ red_printf("unsuported qterm interface");
+ return;
+ }
+ add_monitor_action_commands((QTermInterface *)interface);
+ add_monitor_info_commands((QTermInterface *)interface);
+ } else if (strcmp(interface->type, VD_INTERFACE_TABLET) == 0) {
+ red_printf("VD_INTERFACE_TABLET");
+ if (tablet) {
+ red_printf("already have tablet");
+ return;
+ }
+ if (interface->major_version != VD_INTERFACE_TABLET_MAJOR ||
+ interface->minor_version < VD_INTERFACE_TABLET_MINOR) {
+ red_printf("unsuported tablet interface");
+ return;
+ }
+ tablet = (TabletInterface *)interface;
+ reds_update_mouse_mode();
+ if (reds->is_client_mouse_allowed) {
+ tablet->set_logical_size(tablet, reds->monitor_mode.x_res,
+ reds->monitor_mode.y_res);
+ }
+ } else if (strcmp(interface->type, VD_INTERFACE_PLAYBACK) == 0) {
+ red_printf("VD_INTERFACE_PLAYBACK");
+ if (interface->major_version != VD_INTERFACE_PLAYBACK_MAJOR ||
+ interface->minor_version < VD_INTERFACE_PLAYBACK_MINOR) {
+ red_printf("unsuported playback interface");
+ return;
+ }
+ snd_attach_playback((PlaybackInterface *)interface);
+ } else if (strcmp(interface->type, VD_INTERFACE_RECORD) == 0) {
+ red_printf("VD_INTERFACE_RECORD");
+ if (interface->major_version != VD_INTERFACE_RECORD_MAJOR ||
+ interface->minor_version < VD_INTERFACE_RECORD_MINOR) {
+ red_printf("unsuported record interface");
+ return;
+ }
+ snd_attach_record((RecordInterface *)interface);
+ } else if (strcmp(interface->type, VD_INTERFACE_VDI_PORT) == 0) {
+ red_printf("VD_INTERFACE_VDI_PORT");
+ if (vdagent) {
+ red_printf("vdi port already attached");
+ return;
+ }
+ if (interface->major_version != VD_INTERFACE_VDI_PORT_MAJOR ||
+ interface->minor_version < VD_INTERFACE_VDI_PORT_MINOR) {
+ red_printf("unsuported vdi port interface");
+ return;
+ }
+ attach_to_red_agent((VDIPortInterface *)interface);
+ }
+ break;
+ case VD_INTERFACE_REMOVING:
+ if (strcmp(interface->type, VD_INTERFACE_TABLET) == 0) {
+ red_printf("remove VD_INTERFACE_TABLET");
+ if (interface == (VDInterface *)tablet) {
+ tablet = NULL;
+ reds_update_mouse_mode();
+ }
+ break;
+ } else if (strcmp(interface->type, VD_INTERFACE_PLAYBACK) == 0) {
+ red_printf("remove VD_INTERFACE_PLAYBACK");
+ snd_detach_playback((PlaybackInterface *)interface);
+ break;
+ } else if (strcmp(interface->type, VD_INTERFACE_RECORD) == 0) {
+ red_printf("remove VD_INTERFACE_RECORD");
+ snd_detach_record((RecordInterface *)interface);
+ break;
+ } else if (strcmp(interface->type, VD_INTERFACE_VDI_PORT) == 0) {
+ red_printf("remove VD_INTERFACE_VDI_PORT");
+ if (interface == (VDInterface *)vdagent) {
+ reds_agent_remove();
+ }
+ break;
+ }
+ red_error("VD_INTERFACE_REMOVING unsupported");
+ break;
+ }
+}
+
+static void free_external_agent_buff(VDIPortBuf *in_buf)
+{
+ VDIPortState *state = &reds->agent_state;
+
+ ring_add(&state->external_bufs, &in_buf->link);
+ add_token();
+}
+
+static void free_internal_agent_buff(VDIPortBuf *in_buf)
+{
+ VDIPortState *state = &reds->agent_state;
+
+ ring_add(&state->internal_bufs, &in_buf->link);
+ if (reds->inputs_state && reds->inputs_state->pending_mouse_event) {
+ reds_handle_agent_mouse_event();
+ }
+}
+
+void reds_prepare_read_buf(RedsOutItem *in_nuf, struct iovec* vec, int *len)
+{
+ VDIReadBuf *buf = (VDIReadBuf *)in_nuf;
+
+ vec[0].iov_base = &buf->header;
+ vec[0].iov_len = sizeof(buf->header);
+ vec[1].iov_base = buf->data;
+ vec[1].iov_len = buf->len;
+ *len = 2;
+}
+
+void reds_release_read_buf(RedsOutItem *in_nuf)
+{
+ VDIReadBuf *buf = (VDIReadBuf *)in_nuf;
+
+ ring_add(&reds->agent_state.read_bufs, &buf->out_item.link);
+ read_from_vdi_port();
+}
+
+static void init_vd_agent_resources()
+{
+ VDIPortState *state = &reds->agent_state;
+ int i;
+
+ ring_init(&state->external_bufs);
+ ring_init(&state->internal_bufs);
+ ring_init(&state->write_queue);
+ ring_init(&state->read_bufs);
+
+ state->read_state = VDI_PORT_READ_STATE_READ_HADER;
+ state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
+ state->recive_len = sizeof(state->vdi_chunk_header);
+
+ for (i = 0; i < REDS_AGENT_WINDOW_SIZE; i++) {
+ VDAgentExtBuf *buf = (VDAgentExtBuf *)malloc(sizeof(VDAgentExtBuf));
+ if (!buf) {
+ PANIC("alloc failed");
+ }
+ memset(buf, 0, sizeof(*buf));
+ ring_item_init(&buf->base.link);
+ buf->base.chunk_header.port = VDP_CLIENT_PORT;
+ buf->base.free = free_external_agent_buff;
+ ring_add(&reds->agent_state.external_bufs, &buf->base.link);
+ }
+
+ for (i = 0; i < REDS_NUM_INTERNAL_AGENT_MESSAGES; i++) {
+ VDInternalBuf *buf = (VDInternalBuf *)malloc(sizeof(VDInternalBuf));
+ if (!buf) {
+ PANIC("alloc failed");
+ }
+ memset(buf, 0, sizeof(*buf));
+ ring_item_init(&buf->base.link);
+ buf->base.free = free_internal_agent_buff;
+ buf->base.chunk_header.port = VDP_SERVER_PORT;
+ buf->base.chunk_header.size = sizeof(VDAgentMessage) + sizeof(VDAgentMouseState);
+ buf->header.protocol = VD_AGENT_PROTOCOL;
+ buf->header.type = VD_AGENT_MOUSE_STATE;
+ buf->header.opaque = 0;
+ buf->header.size = sizeof(VDAgentMouseState);
+ ring_add(&reds->agent_state.internal_bufs, &buf->base.link);
+ }
+
+ for (i = 0; i < REDS_VDI_PORT_NUM_RECIVE_BUFFS; i++) {
+ VDIReadBuf *buf = (VDIReadBuf *)malloc(sizeof(VDIReadBuf));
+ if (!buf) {
+ PANIC("alloc failed");
+ }
+ memset(buf, 0, sizeof(*buf));
+ buf->out_item.prepare = reds_prepare_read_buf;
+ buf->out_item.release = reds_release_read_buf;
+ buf->header.type = RED_AGENT_DATA;
+ buf->header.sub_list = 0;
+ ring_item_init(&buf->out_item.link);
+ ring_add(&reds->agent_state.read_bufs, &buf->out_item.link);
+ }
+
+ state->plug.major_version = VD_INTERFACE_VDI_PORT_MAJOR;
+ state->plug.minor_version = VD_INTERFACE_VDI_PORT_MINOR;
+ state->plug.wakeup = reds_agent_wakeup;
+}
+
+const char *version_string = VERSION;
+
+void __attribute__ ((visibility ("default"))) spice_init(CoreInterface *core_interface)
+{
+ VDInterface *interface = NULL;
+
+ red_printf("starting %s", version_string);
+
+ if (core_interface->base.base_version != VM_INTERFACE_VERSION) {
+ red_error("bad base interface version");
+ }
+
+ if (core_interface->base.major_version != VD_INTERFACE_CORE_MAJOR) {
+ red_error("bad core interface version");
+ }
+ core = core_interface;
+ if (core_interface->base.minor_version > 1) {
+ log_proc = core->log;
+ }
+ if (!(reds = malloc(sizeof(RedsState)))) {
+ red_error("reds alloc failed");
+ }
+ memset(reds, 0, sizeof(RedsState));
+ reds->listen_socket = -1;
+ reds->secure_listen_socket = -1;
+ reds->peer = NULL;
+ reds->in_handler.handle_message = reds_main_handle_message;
+ ring_init(&reds->outgoing.pipe);
+ reds->outgoing.vec = reds->outgoing.vec_buf;
+
+ init_vd_agent_resources();
+
+ if (!(reds->mig_timer = core->create_timer(core, migrate_timout, NULL))) {
+ red_error("migration timer create failed");
+ }
+ if (!(reds->key_modifiers_timer = core->create_timer(core, key_modifiers_sender, NULL))) {
+ red_error("key modifiers timer create failed");
+ }
+
+ while ((interface = core->next(core, interface))) {
+ interface_change_notifier(&reds, interface, VD_INTERFACE_ADDING);
+ }
+ core->register_change_notifiers(core, &reds, interface_change_notifier);
+
+#ifdef RED_STATISTICS
+ int shm_name_len = strlen(REDS_STAT_SHM_NAME) + 20;
+ int fd;
+
+ if (!(reds->stat_shm_name = (char *)malloc(shm_name_len))) {
+ red_error("stat_shm_name alloc failed");
+ }
+ snprintf(reds->stat_shm_name, shm_name_len, REDS_STAT_SHM_NAME, getpid());
+ if ((fd = shm_open(reds->stat_shm_name, O_CREAT | O_RDWR, 0444)) == -1) {
+ red_error("statistics shm_open failed, %s", strerror(errno));
+ }
+ if (ftruncate(fd, REDS_STAT_SHM_SIZE) == -1) {
+ red_error("statistics ftruncate failed, %s", strerror(errno));
+ }
+ reds->stat = mmap(NULL, REDS_STAT_SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ if (reds->stat == (RedsStat *)MAP_FAILED) {
+ red_error("statistics mmap failed, %s", strerror(errno));
+ }
+ memset(reds->stat, 0, REDS_STAT_SHM_SIZE);
+ reds->stat->magic = REDS_STAT_MAGIC;
+ reds->stat->version = REDS_STAT_VERSION;
+ reds->stat->root_index = INVALID_STAT_REF;
+ if (pthread_mutex_init(&reds->stat_lock, NULL)) {
+ red_error("mutex init failed");
+ }
+ if (!(reds->ping_timer = core->create_timer(core, ping_timer_cb, NULL))) {
+ red_error("ping timer create failed");
+ }
+ reds->ping_interval = PING_INTERVAL;
+#endif
+
+ if (!(reds->mm_timer = core->create_timer(core, mm_timer_proc, NULL))) {
+ red_error("mm timer create failed");
+ }
+ core->arm_timer(core, reds->mm_timer, MM_TIMER_GRANULARITY_MS);
+
+ reds_init_net();
+ if (reds->secure_listen_socket != -1) {
+ reds_init_ssl();
+ }
+ inputs_init();
+
+ reds->mouse_mode = RED_MOUSE_MODE_SERVER;
+ atexit(reds_exit);
+}
+