guacamole-spice-protocol/libguac/src/client.c

391 lines
11 KiB
C
Raw Normal View History

2010-12-08 21:14:04 +00:00
2011-02-16 02:04:36 +00:00
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
2010-12-08 21:14:04 +00:00
*
2011-02-16 02:04:36 +00:00
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
2010-12-08 21:14:04 +00:00
*
2011-02-16 02:04:36 +00:00
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
2010-12-08 21:14:04 +00:00
*
2011-02-16 02:04:36 +00:00
* The Original Code is libguac.
*
* The Initial Developer of the Original Code is
* Michael Jumper.
* Portions created by the Initial Developer are Copyright (C) 2010
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
2010-12-08 21:14:04 +00:00
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include "socket.h"
2010-12-08 21:14:04 +00:00
#include "protocol.h"
#include "client.h"
#include "client-handlers.h"
2010-12-08 21:14:04 +00:00
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
guac_layer __GUAC_DEFAULT_LAYER = {
.index = 0,
.__next = NULL,
.__next_available = NULL
};
const guac_layer* GUAC_DEFAULT_LAYER = &__GUAC_DEFAULT_LAYER;
guac_client* __guac_alloc_client(guac_socket* io) {
2010-12-08 21:14:04 +00:00
/* Allocate new client (not handoff) */
guac_client* client = malloc(sizeof(guac_client));
memset(client, 0, sizeof(guac_client));
/* Init new client */
client->io = io;
client->last_received_timestamp = client->last_sent_timestamp = guac_protocol_get_timestamp();
client->state = RUNNING;
2010-12-08 21:14:04 +00:00
client->__all_layers = NULL;
client->__available_buffers = NULL;
client->__next_buffer_index = -1;
2010-12-08 21:14:04 +00:00
return client;
}
guac_layer* guac_client_alloc_layer(guac_client* client, int index) {
guac_layer* allocd_layer;
/* Init new layer */
allocd_layer = malloc(sizeof(guac_layer));
/* Add to __all_layers list */
allocd_layer->__next = client->__all_layers;
client->__all_layers = allocd_layer;
allocd_layer->index = index;
return allocd_layer;
}
guac_layer* guac_client_alloc_buffer(guac_client* client) {
guac_layer* allocd_layer;
/* If available layers, pop off first available buffer */
if (client->__available_buffers != NULL) {
allocd_layer = client->__available_buffers;
client->__available_buffers = client->__available_buffers->__next_available;
allocd_layer->__next_available = NULL;
}
/* If no available buffer, allocate new buffer, add to __all_layers list */
else {
/* Init new layer */
allocd_layer = malloc(sizeof(guac_layer));
allocd_layer->index = client->__next_buffer_index--;
/* Add to __all_layers list */
allocd_layer->__next = client->__all_layers;
client->__all_layers = allocd_layer;
}
return allocd_layer;
}
void guac_client_free_buffer(guac_client* client, guac_layer* layer) {
/* Add layer to pool of available buffers */
layer->__next_available = client->__available_buffers;
client->__available_buffers = layer;
}
2010-12-08 21:14:04 +00:00
guac_client* guac_get_client(int client_fd, int usec_timeout) {
2010-12-08 21:14:04 +00:00
guac_client* client;
guac_socket* io = guac_socket_open(client_fd);
2010-12-08 21:14:04 +00:00
/* Pluggable client */
char protocol_lib[256] = "libguac-client-";
2010-12-08 21:14:04 +00:00
union {
guac_client_init_handler* client_init;
void* obj;
} alias;
char* error;
/* Client args description */
const char** client_args;
2010-12-08 21:14:04 +00:00
/* Client arguments */
int argc;
char** argv;
/* Instruction */
guac_instruction* instruction;
2010-12-08 21:14:04 +00:00
/* Wait for select instruction */
2010-12-08 21:14:04 +00:00
for (;;) {
2011-03-16 06:02:47 +00:00
int result;
/* Wait for data until timeout */
result = guac_protocol_instructions_waiting(io, usec_timeout);
if (result == 0) {
guac_protocol_send_error(io, "Select timeout.");
guac_socket_close(io);
2011-03-16 06:02:47 +00:00
return NULL;
}
/* If error occurs while waiting, exit with failure */
if (result < 0) {
guac_socket_close(io);
2011-03-16 06:02:47 +00:00
return NULL;
}
instruction = guac_protocol_read_instruction(io, usec_timeout);
if (instruction == NULL) {
guac_socket_close(io);
return NULL;
}
2010-12-08 21:14:04 +00:00
/* Select instruction read */
else {
2010-12-08 21:14:04 +00:00
if (strcmp(instruction->opcode, "select") == 0) {
2010-12-08 21:14:04 +00:00
/* Get protocol from message */
char* protocol = instruction->argv[0];
2010-12-08 21:14:04 +00:00
strcat(protocol_lib, protocol);
strcat(protocol_lib, ".so");
/* Create new client */
client = __guac_alloc_client(io);
/* Load client plugin */
client->__client_plugin_handle = dlopen(protocol_lib, RTLD_LAZY);
if (!(client->__client_plugin_handle)) {
guac_client_log_error(client, "Could not open client plugin for protocol \"%s\": %s\n", protocol, dlerror());
guac_protocol_send_error(io, "Could not load server-side client plugin.");
guac_socket_flush(io);
guac_socket_close(io);
guac_instruction_free(instruction);
2010-12-08 21:14:04 +00:00
return NULL;
}
dlerror(); /* Clear errors */
/* Get init function */
alias.obj = dlsym(client->__client_plugin_handle, "guac_client_init");
2010-12-08 21:14:04 +00:00
if ((error = dlerror()) != NULL) {
guac_client_log_error(client, "Could not get guac_client_init in plugin: %s\n", error);
guac_protocol_send_error(io, "Invalid server-side client plugin.");
guac_socket_flush(io);
guac_socket_close(io);
guac_instruction_free(instruction);
2010-12-08 21:14:04 +00:00
return NULL;
}
/* Get usage strig */
client_args = (const char**) dlsym(client->__client_plugin_handle, "GUAC_CLIENT_ARGS");
if ((error = dlerror()) != NULL) {
guac_client_log_error(client, "Could not get GUAC_CLIENT_ARGS in plugin: %s\n", error);
guac_protocol_send_error(io, "Invalid server-side client plugin.");
guac_socket_flush(io);
guac_socket_close(io);
guac_instruction_free(instruction);
return NULL;
}
2011-03-19 23:39:18 +00:00
if ( /* Send args */
guac_protocol_send_args(io, client_args)
|| guac_socket_flush(io)
2011-03-19 23:39:18 +00:00
) {
guac_socket_close(io);
guac_instruction_free(instruction);
2011-03-19 23:39:18 +00:00
return NULL;
}
guac_instruction_free(instruction);
break;
} /* end if select */
guac_instruction_free(instruction);
}
}
/* Wait for connect instruction */
for (;;) {
2011-03-16 06:02:47 +00:00
int result;
/* Wait for data until timeout */
result = guac_protocol_instructions_waiting(io, usec_timeout);
2011-03-16 06:02:47 +00:00
if (result == 0) {
guac_protocol_send_error(io, "Connect timeout.");
guac_socket_close(io);
2011-03-16 06:02:47 +00:00
return NULL;
}
/* If error occurs while waiting, exit with failure */
if (result < 0) {
guac_socket_close(io);
2011-03-16 06:02:47 +00:00
return NULL;
}
instruction = guac_protocol_read_instruction(io, usec_timeout);
if (instruction == NULL) {
guac_client_log_error(client, "Error reading instruction while waiting for connect");
guac_socket_close(io);
return NULL;
}
/* Connect instruction read */
else {
if (strcmp(instruction->opcode, "connect") == 0) {
2010-12-08 21:14:04 +00:00
/* Initialize client arguments */
argc = instruction->argc;
argv = instruction->argv;
2010-12-08 21:14:04 +00:00
if (alias.client_init(client, argc, argv) != 0) {
/* NOTE: On error, proxy client will send appropriate error message */
guac_instruction_free(instruction);
guac_socket_close(io);
2010-12-08 21:14:04 +00:00
return NULL;
}
guac_instruction_free(instruction);
2010-12-08 21:14:04 +00:00
return client;
} /* end if connect */
guac_instruction_free(instruction);
2010-12-08 21:14:04 +00:00
}
}
}
void guac_client_free(guac_client* client) {
2010-12-08 21:14:04 +00:00
if (client->free_handler) {
if (client->free_handler(client))
guac_client_log_error(client, "Error calling client free handler");
2010-12-08 21:14:04 +00:00
}
guac_socket_close(client->io);
2010-12-08 21:14:04 +00:00
/* Unload client plugin */
if (dlclose(client->__client_plugin_handle)) {
guac_client_log_error(client, "Could not close client plugin while unloading client: %s", dlerror());
2010-12-08 21:14:04 +00:00
}
/* Free all layers */
while (client->__all_layers != NULL) {
/* Get layer, update layer pool head */
guac_layer* layer = client->__all_layers;
client->__all_layers = layer->__next;
/* Free layer */
free(layer);
}
2010-12-08 21:14:04 +00:00
free(client);
}
int guac_client_handle_instruction(guac_client* client, guac_instruction* instruction) {
/* For each defined instruction */
__guac_instruction_handler_mapping* current = __guac_instruction_handler_map;
while (current->opcode != NULL) {
/* If recognized, call handler */
if (strcmp(instruction->opcode, current->opcode) == 0)
return current->handler(client, instruction);
current++;
}
/* If unrecognized, ignore */
return 0;
}
2011-11-25 20:22:12 +00:00
void vguac_client_log_info(guac_client* client, const char* format,
va_list ap) {
/* Call handler if defined */
if (client->log_info_handler != NULL)
client->log_info_handler(client, format, ap);
}
void vguac_client_log_error(guac_client* client, const char* format,
va_list ap) {
/* Call handler if defined */
if (client->log_error_handler != NULL)
client->log_error_handler(client, format, ap);
}
void guac_client_log_info(guac_client* client, const char* format, ...) {
va_list args;
va_start(args, format);
vguac_client_log_info(client, format, args);
va_end(args);
}
void guac_client_log_error(guac_client* client, const char* format, ...) {
va_list args;
va_start(args, format);
vguac_client_log_error(client, format, args);
va_end(args);
}