From 9e7663463f3739302ce71b1808f2539eb094fe01 Mon Sep 17 00:00:00 2001 From: Michael Jumper Date: Mon, 29 Feb 2016 21:40:39 -0800 Subject: [PATCH] GUAC-1389: Restore guacd within build. Migrate guacd to screen sharing changes. --- Makefile.am | 1 + src/guacd/Makefile.am | 28 +- src/guacd/client.c | 209 ----------- src/guacd/connection.c | 330 ++++++++++++++++++ src/guacd/connection.h | 99 ++++++ src/guacd/daemon.c | 425 ++--------------------- src/guacd/log.c | 17 + src/guacd/log.h | 6 + src/guacd/move-fd.c | 115 +++++++ src/guacd/move-fd.h | 43 +++ src/guacd/{client-map.c => proc-map.c} | 59 ++-- src/guacd/{client-map.h => proc-map.h} | 43 ++- src/guacd/proc.c | 458 +++++++++++++++++++++++++ src/guacd/proc.h | 80 +++++ src/guacd/socket-ssl.c | 3 + src/guacd/socket-ssl.h | 3 +- src/guacd/user.c | 112 ++++++ src/guacd/{client.h => user.h} | 63 ++-- 18 files changed, 1397 insertions(+), 697 deletions(-) delete mode 100644 src/guacd/client.c create mode 100644 src/guacd/connection.c create mode 100644 src/guacd/connection.h create mode 100644 src/guacd/move-fd.c create mode 100644 src/guacd/move-fd.h rename src/guacd/{client-map.c => proc-map.c} (67%) rename src/guacd/{client-map.h => proc-map.h} (55%) create mode 100644 src/guacd/proc.c create mode 100644 src/guacd/proc.h create mode 100644 src/guacd/user.c rename src/guacd/{client.h => user.h} (59%) diff --git a/Makefile.am b/Makefile.am index c2e303ce..c95a0dc0 100644 --- a/Makefile.am +++ b/Makefile.am @@ -38,6 +38,7 @@ DIST_SUBDIRS = \ SUBDIRS = \ src/libguac \ src/common \ + src/guacd \ tests if ENABLE_COMMON_SSH diff --git a/src/guacd/Makefile.am b/src/guacd/Makefile.am index db1e7a54..8743fefe 100644 --- a/src/guacd/Makefile.am +++ b/src/guacd/Makefile.am @@ -29,21 +29,27 @@ man_MANS = \ man/guacd.conf.5 noinst_HEADERS = \ - client.h \ - client-map.h \ conf-args.h \ conf-file.h \ conf-parse.h \ - log.h + connection.h \ + log.h \ + move-fd.h \ + proc.h \ + proc-map.h \ + user.h -guacd_SOURCES = \ - daemon.c \ - client.c \ - client-map.c \ - conf-args.c \ - conf-file.c \ - conf-parse.c \ - log.c +guacd_SOURCES = \ + conf-args.c \ + conf-file.c \ + conf-parse.c \ + connection.c \ + daemon.c \ + log.c \ + move-fd.c \ + proc.c \ + proc-map.c \ + user.c guacd_CFLAGS = \ -Werror -Wall -pedantic \ diff --git a/src/guacd/client.c b/src/guacd/client.c deleted file mode 100644 index 075887cc..00000000 --- a/src/guacd/client.c +++ /dev/null @@ -1,209 +0,0 @@ -/* - * Copyright (C) 2013 Glyptodon LLC - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - -#include "config.h" - -#include "client.h" -#include "log.h" - -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -/** - * Sleep for the given number of milliseconds. - * - * @param millis The number of milliseconds to sleep. - */ -void __guacdd_sleep(int millis) { - - struct timespec sleep_period; - - sleep_period.tv_sec = millis / 1000; - sleep_period.tv_nsec = (millis % 1000) * 1000000L; - - nanosleep(&sleep_period, NULL); - -} - -void* __guacd_client_output_thread(void* data) { - - guac_client* client = (guac_client*) data; - guac_socket* socket = client->socket; - - guac_client_log(client, GUAC_LOG_DEBUG, - "Starting output thread."); - - /* Guacamole client output loop */ - while (client->state == GUAC_CLIENT_RUNNING) { - - /* Handle server messages */ - if (client->handle_messages) { - - /* Only handle messages if synced within threshold */ - if (client->last_sent_timestamp - client->last_received_timestamp - < GUACD_SYNC_THRESHOLD) { - - int retval = client->handle_messages(client); - if (retval) { - guacd_client_log_guac_error(client, GUAC_LOG_DEBUG, - "Error handling server messages"); - guac_client_stop(client); - return NULL; - } - - /* Send sync instruction */ - client->last_sent_timestamp = guac_timestamp_current(); - if (guac_protocol_send_sync(socket, client->last_sent_timestamp)) { - guacd_client_log_guac_error(client, GUAC_LOG_DEBUG, - "Error sending \"sync\" instruction"); - guac_client_stop(client); - return NULL; - } - - /* Flush */ - if (guac_socket_flush(socket)) { - guacd_client_log_guac_error(client, GUAC_LOG_DEBUG, - "Error flushing output"); - guac_client_stop(client); - return NULL; - } - - } - - /* Do not spin while waiting for old sync */ - else - __guacdd_sleep(GUACD_MESSAGE_HANDLE_FREQUENCY); - - } - - /* If no message handler, just sleep until next sync ping */ - else - __guacdd_sleep(GUACD_SYNC_FREQUENCY); - - } /* End of output loop */ - - guac_client_log(client, GUAC_LOG_DEBUG, - "Output thread terminated."); - - guac_client_stop(client); - return NULL; - -} - -void* __guacd_client_input_thread(void* data) { - - guac_client* client = (guac_client*) data; - guac_socket* socket = client->socket; - - guac_client_log(client, GUAC_LOG_DEBUG, - "Starting input thread."); - - /* Guacamole client input loop */ - while (client->state == GUAC_CLIENT_RUNNING) { - - /* Read instruction */ - guac_instruction* instruction = - guac_instruction_read(socket, GUACD_USEC_TIMEOUT); - - /* Stop on error */ - if (instruction == NULL) { - - if (guac_error == GUAC_STATUS_TIMEOUT) - guac_client_abort(client, GUAC_PROTOCOL_STATUS_CLIENT_TIMEOUT, "Client is not responding."); - - else { - if (guac_error != GUAC_STATUS_CLOSED) - guacd_client_log_guac_error(client, GUAC_LOG_WARNING, - "Guacamole connection failure"); - guac_client_stop(client); - } - - return NULL; - } - - /* Reset guac_error and guac_error_message (client handlers are not - * guaranteed to set these) */ - guac_error = GUAC_STATUS_SUCCESS; - guac_error_message = NULL; - - /* Call handler, stop on error */ - if (guac_client_handle_instruction(client, instruction) < 0) { - - /* Log error */ - guacd_client_log_guac_error(client, GUAC_LOG_WARNING, - "Connection aborted"); - - /* Log handler details */ - guac_client_log(client, GUAC_LOG_DEBUG, - "Failing instruction handler in client was \"%s\"", - instruction->opcode); - - guac_instruction_free(instruction); - guac_client_stop(client); - return NULL; - } - - /* Free allocated instruction */ - guac_instruction_free(instruction); - - } - - guac_client_log(client, GUAC_LOG_DEBUG, - "Input thread terminated."); - - return NULL; - -} - -int guacd_client_start(guac_client* client) { - - pthread_t input_thread, output_thread; - - if (pthread_create(&output_thread, NULL, __guacd_client_output_thread, (void*) client)) { - guac_client_log(client, GUAC_LOG_ERROR, "Unable to start output thread"); - return -1; - } - - if (pthread_create(&input_thread, NULL, __guacd_client_input_thread, (void*) client)) { - guac_client_log(client, GUAC_LOG_ERROR, "Unable to start input thread"); - guac_client_stop(client); - pthread_join(output_thread, NULL); - return -1; - } - - /* Wait for I/O threads */ - pthread_join(input_thread, NULL); - pthread_join(output_thread, NULL); - - /* Done */ - return 0; - -} - diff --git a/src/guacd/connection.c b/src/guacd/connection.c new file mode 100644 index 00000000..c8cb1a17 --- /dev/null +++ b/src/guacd/connection.c @@ -0,0 +1,330 @@ +/* + * Copyright (C) 2014 Glyptodon LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "config.h" + +#include "connection.h" +#include "log.h" +#include "move-fd.h" +#include "proc.h" +#include "proc-map.h" +#include "user.h" + +#include +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_SSL +#include +#include "socket-ssl.h" +#endif + +#include +#include +#include +#include + +/** + * Behaves exactly as write(), but writes as much as possible, returning + * successfully only if the entire buffer was written. If the write fails for + * any reason, a negative value is returned. + */ +static int __write_all(int fd, char* buffer, int length) { + + /* Repeatedly write() until all data is written */ + while (length > 0) { + + int written = write(fd, buffer, length); + if (written < 0) + return -1; + + length -= written; + buffer += written; + + } + + return length; + +} + +/** + * Continuously reads from a guac_socket, writing all data read to a file + * descriptor. + */ +static void* guacd_connection_write_thread(void* data) { + + guacd_connection_io_thread_params* params = (guacd_connection_io_thread_params*) data; + char buffer[8192]; + + int length; + + while ((length = guac_parser_shift(params->parser, buffer, sizeof(buffer))) > 0) { + if (__write_all(params->fd, buffer, length) < 0) + break; + } + + /* Parser is no longer needed */ + guac_parser_free(params->parser); + + /* Transfer data from file descriptor to socket */ + while ((length = guac_socket_read(params->socket, buffer, sizeof(buffer))) > 0) { + if (__write_all(params->fd, buffer, length) < 0) + break; + } + + return NULL; + +} + +void* guacd_connection_io_thread(void* data) { + + guacd_connection_io_thread_params* params = (guacd_connection_io_thread_params*) data; + char buffer[8192]; + + int length; + + pthread_t write_thread; + pthread_create(&write_thread, NULL, guacd_connection_write_thread, params); + + /* Transfer data from file descriptor to socket */ + while ((length = read(params->fd, buffer, sizeof(buffer))) > 0) { + if (guac_socket_write(params->socket, buffer, length)) + break; + guac_socket_flush(params->socket); + } + + /* Wait for write thread to die */ + pthread_join(write_thread, NULL); + + /* Clean up */ + guac_socket_free(params->socket); + close(params->fd); + free(params); + + return NULL; + +} + +/** + * Adds the given socket as a new user to the given process, automatically + * reading/writing from the socket via read/write threads. The given socket and + * any associated resources will be freed unless the user is not added + * successfully. + * + * If adding the user fails for any reason, non-zero is returned. Zero is + * returned upon success. + */ +static int guacd_add_user(guacd_proc* proc, guac_parser* parser, guac_socket* socket) { + + int sockets[2]; + + /* Set up socket pair */ + if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) < 0) { + guacd_log(GUAC_LOG_ERROR, "Unable to allocate file descriptors for I/O transfer: %s", strerror(errno)); + return 1; + } + + int user_fd = sockets[0]; + int proc_fd = sockets[1]; + + /* Send user file descriptor to process */ + if (!guacd_send_fd(proc->fd_socket, proc_fd)) { + guacd_log(GUAC_LOG_ERROR, "Unable to add user."); + return 1; + } + + /* Close our end of the process file descriptor */ + close(proc_fd); + + guacd_connection_io_thread_params* params = malloc(sizeof(guacd_connection_io_thread_params)); + params->parser = parser; + params->socket = socket; + params->fd = user_fd; + + /* Start I/O thread */ + pthread_t io_thread; + pthread_create(&io_thread, NULL, guacd_connection_io_thread, params); + pthread_detach(io_thread); + + return 0; + +} + +/** + * Routes the connection on the given socket according to the Guacamole + * protocol on the given socket, adding new users and creating new client + * processes as needed. + * + * The socket provided will be automatically freed when the connection + * terminates unless routing fails, in which case non-zero is returned. + */ +static int guacd_route_connection(guacd_proc_map* map, guac_socket* socket) { + + guac_parser* parser = guac_parser_alloc(); + + /* Reset guac_error */ + guac_error = GUAC_STATUS_SUCCESS; + guac_error_message = NULL; + + /* Get protocol from select instruction */ + if (guac_parser_expect(parser, socket, GUACD_USEC_TIMEOUT, "select")) { + + /* Log error */ + guacd_log_handshake_failure(); + guacd_log_guac_error(GUAC_LOG_DEBUG, + "Error reading \"select\""); + + guac_parser_free(parser); + return 1; + } + + /* Validate args to select */ + if (parser->argc != 1) { + + /* Log error */ + guacd_log_handshake_failure(); + guacd_log(GUAC_LOG_ERROR, "Bad number of arguments to \"select\" (%i)", + parser->argc); + + guac_parser_free(parser); + return 1; + } + + guacd_proc* proc; + int new_process; + + const char* identifier = parser->argv[0]; + + /* If connection ID, retrieve existing process */ + if (identifier[0] == GUAC_CLIENT_ID_PREFIX) { + + proc = guacd_proc_map_retrieve(map, identifier); + if (proc == NULL) + guacd_log(GUAC_LOG_INFO, "Connection \"%s\" does not exist.", identifier); + else + guacd_log(GUAC_LOG_INFO, "Joining existing connection \"%s\"", identifier); + + new_process = 0; + + } + + /* Otherwise, create new client */ + else { + + guacd_log(GUAC_LOG_INFO, "Creating new client for protocol \"%s\"", identifier); + proc = guacd_create_proc(parser, identifier); + + new_process = 1; + + } + + if (proc == NULL) { + guacd_log_guac_error(GUAC_LOG_INFO, "Connection did not succeed"); + guac_parser_free(parser); + return 1; + } + + /* Add new user (in the case of a new process, this will be the owner */ + if (guacd_add_user(proc, parser, socket) == 0) { + + /* If new process was created, manage that process */ + if (new_process) { + + /* Log connection ID */ + guacd_log(GUAC_LOG_INFO, "Connection ID is \"%s\"", proc->client->connection_id); + + /* Store process, allowing other users to join */ + guacd_proc_map_add(map, proc); + + /* Wait for child to finish */ + waitpid(proc->pid, NULL, 0); + + /* Remove client */ + if (guacd_proc_map_remove(map, proc->client->connection_id) == NULL) + guacd_log(GUAC_LOG_ERROR, "Internal failure removing client \"%s\". Client record will never be freed.", + proc->client->connection_id); + else + guacd_log(GUAC_LOG_INFO, "Connection \"%s\" removed.", proc->client->connection_id); + + /* Free skeleton client */ + guac_client_free(proc->client); + + /* Clean up */ + close(proc->fd_socket); + free(proc); + + } + + return 0; + } + + /* Add of user failed */ + else { + guac_parser_free(parser); + return 1; + } + +} + +void* guacd_connection_thread(void* data) { + + guacd_connection_thread_params* params = (guacd_connection_thread_params*) data; + + guacd_proc_map* map = params->map; + int connected_socket_fd = params->connected_socket_fd; + + guac_socket* socket; + +#ifdef ENABLE_SSL + + SSL_CTX* ssl_context = params->ssl_context; + + /* If SSL chosen, use it */ + if (ssl_context != NULL) { + socket = guac_socket_open_secure(ssl_context, connected_socket_fd); + if (socket == NULL) { + guacd_log_guac_error(GUAC_LOG_ERROR, "Unable to set up SSL/TLS"); + free(params); + return NULL; + } + } + else + socket = guac_socket_open(connected_socket_fd); + +#else + /* Open guac_socket */ + socket = guac_socket_open(connected_socket_fd); +#endif + + /* Route connection according to Guacamole, creating a new process if needed */ + if (guacd_route_connection(map, socket)) + guac_socket_free(socket); + + free(params); + return NULL; + +} + diff --git a/src/guacd/connection.h b/src/guacd/connection.h new file mode 100644 index 00000000..1797d951 --- /dev/null +++ b/src/guacd/connection.h @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2014 Glyptodon LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef GUACD_CONNECTION_H +#define GUACD_CONNECTION_H + +#include "config.h" + +#include "proc-map.h" + +#ifdef ENABLE_SSL +#include +#endif + +/** + * Parameters required by each connection thread. + */ +typedef struct guacd_connection_thread_params { + + /** + * The shared map of all connected clients. + */ + guacd_proc_map* map; + +#ifdef ENABLE_SSL + /** + * SSL context for encrypted connections to guacd. If SSL is not active, + * this will be NULL. + */ + SSL_CTX* ssl_context; +#endif + + /** + * The file descriptor associated with the newly-accepted connection. + */ + int connected_socket_fd; + +} guacd_connection_thread_params; + +/** + * Handles an inbound connection to guacd, allowing guacd to continue listening + * for other connections. It is expected that this thread will operate + * detached. The creating process need not join on the resulting thread. + */ +void* guacd_connection_thread(void* data); + +/** + * Parameters required by the per-connection I/O transfer thread. + */ +typedef struct guacd_connection_io_thread_params { + + /** + * The guac_parser which may contain buffered, but unparsed, data from the + * original guac_socket which must be transferred to the + * connection-specific process. + */ + guac_parser* parser; + + /** + * The guac_socket which is directly handling I/O from a user's connection + * to guacd. + */ + guac_socket* socket; + + /** + * The file descriptor which is being handled by a guac_socket within the + * connection-specific process. + */ + int fd; + +} guacd_connection_io_thread_params; + +/** + * Transfers data back and forth between the guacd-side guac_socket and the + * file descriptor used by the process-side guac_socket. + */ +void* guacd_connection_io_thread(void* data); + +#endif + diff --git a/src/guacd/daemon.c b/src/guacd/daemon.c index e7327044..326bfacd 100644 --- a/src/guacd/daemon.c +++ b/src/guacd/daemon.c @@ -22,22 +22,15 @@ #include "config.h" -#include "client.h" -#include "client-map.h" +#include "connection.h" #include "conf-args.h" #include "conf-file.h" #include "log.h" - -#include -#include -#include -#include -#include -#include +#include "proc-map.h" +#include "user.h" #ifdef ENABLE_SSL #include -#include "socket-ssl.h" #endif #include @@ -59,347 +52,10 @@ #define GUACD_ROOT "/" /** - * Logs a reasonable explanatory message regarding handshake failure based on - * the current value of guac_error. + * Redirects the given file descriptor to /dev/null. The given flags must match + * the read/write flags of the file descriptor given. */ -static void guacd_log_handshake_failure() { - - if (guac_error == GUAC_STATUS_CLOSED) - guacd_log(GUAC_LOG_INFO, - "Guacamole connection closed during handshake"); - else if (guac_error == GUAC_STATUS_PROTOCOL_ERROR) - guacd_log(GUAC_LOG_ERROR, - "Guacamole protocol violation. Perhaps the version of " - "guacamole-client is incompatible with this version of " - "guacd?"); - else - guacd_log(GUAC_LOG_WARNING, - "Guacamole handshake failed: %s", - guac_status_string(guac_error)); - -} - -/** - * Copies the given array of mimetypes (strings) into a newly-allocated NULL- - * terminated array of strings. Both the array and the strings within the array - * are newly-allocated and must be later freed via guacd_free_mimetypes(). - * - * @param mimetypes - * The array of mimetypes to copy. - * - * @param count - * The number of mimetypes in the given array. - * - * @return - * A newly-allocated, NULL-terminated array containing newly-allocated - * copies of each of the mimetypes provided in the original mimetypes - * array. - */ -static char** guacd_copy_mimetypes(char** mimetypes, int count) { - - int i; - - /* Allocate sufficient space for NULL-terminated array of mimetypes */ - char** mimetypes_copy = malloc(sizeof(char*) * (count+1)); - - /* Copy each provided mimetype */ - for (i = 0; i < count; i++) - mimetypes_copy[i] = strdup(mimetypes[i]); - - /* Terminate with NULL */ - mimetypes_copy[count] = NULL; - - return mimetypes_copy; - -} - -/** - * Frees the given array of mimetypes, including the space allocated to each - * mimetype string within the array. The provided array of mimetypes MUST have - * been allocated with guacd_copy_mimetypes(). - * - * @param mimetypes - * The NULL-terminated array of mimetypes to free. This array MUST have - * been previously allocated with guacd_copy_mimetypes(). - */ -static void guacd_free_mimetypes(char** mimetypes) { - - char** current_mimetype = mimetypes; - - /* Free all strings within NULL-terminated mimetype array */ - while (*current_mimetype != NULL) { - free(*current_mimetype); - current_mimetype++; - } - - /* Free the array itself, now that its contents have been freed */ - free(mimetypes); - -} - -/** - * Creates a new guac_client for the connection on the given socket, adding - * it to the client map based on its ID. - */ -static void guacd_handle_connection(guacd_client_map* map, guac_socket* socket) { - - guac_client* client; - guac_client_plugin* plugin; - guac_instruction* select; - guac_instruction* size; - guac_instruction* audio; - guac_instruction* video; - guac_instruction* image; - guac_instruction* connect; - int init_result; - - /* Reset guac_error */ - guac_error = GUAC_STATUS_SUCCESS; - guac_error_message = NULL; - - /* Get protocol from select instruction */ - select = guac_instruction_expect(socket, GUACD_USEC_TIMEOUT, "select"); - if (select == NULL) { - - /* Log error */ - guacd_log_handshake_failure(); - guacd_log_guac_error(GUAC_LOG_DEBUG, - "Error reading \"select\""); - - /* Free resources */ - guac_socket_free(socket); - return; - - } - - /* Validate args to select */ - if (select->argc != 1) { - - /* Log error */ - guacd_log_handshake_failure(); - guacd_log(GUAC_LOG_ERROR, "Bad number of arguments to \"select\" (%i)", - select->argc); - - /* Free resources */ - guac_socket_free(socket); - return; - } - - guacd_log(GUAC_LOG_INFO, "Protocol \"%s\" selected", select->argv[0]); - - /* Get plugin from protocol in select */ - plugin = guac_client_plugin_open(select->argv[0]); - guac_instruction_free(select); - - if (plugin == NULL) { - - /* Log error */ - if (guac_error == GUAC_STATUS_NOT_FOUND) - guacd_log(GUAC_LOG_WARNING, - "Support for selected protocol is not installed"); - else - guacd_log_guac_error(GUAC_LOG_ERROR, - "Unable to load client plugin"); - - /* Free resources */ - guac_socket_free(socket); - return; - } - - /* Send args response */ - if (guac_protocol_send_args(socket, plugin->args) - || guac_socket_flush(socket)) { - - /* Log error */ - guacd_log_handshake_failure(); - guacd_log_guac_error(GUAC_LOG_DEBUG, "Error sending \"args\""); - - if (guac_client_plugin_close(plugin)) - guacd_log_guac_error(GUAC_LOG_WARNING, - "Unable to close client plugin"); - - guac_socket_free(socket); - return; - } - - /* Get client */ - client = guac_client_alloc(); - if (client == NULL) { - guacd_log_guac_error(GUAC_LOG_ERROR, "Unable to create client"); - guac_socket_free(socket); - return; - } - - /* Get optimal screen size */ - size = guac_instruction_expect( - socket, GUACD_USEC_TIMEOUT, "size"); - if (size == NULL) { - - /* Log error */ - guacd_log_handshake_failure(); - guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"size\""); - - /* Free resources */ - guac_client_free(client); - guac_socket_free(socket); - return; - } - - /* Parse optimal screen dimensions from size instruction */ - client->info.optimal_width = atoi(size->argv[0]); - client->info.optimal_height = atoi(size->argv[1]); - - /* If DPI given, set the client resolution */ - if (size->argc >= 3) - client->info.optimal_resolution = atoi(size->argv[2]); - - /* Otherwise, use a safe default for rough backwards compatibility */ - else - client->info.optimal_resolution = 96; - - guac_instruction_free(size); - - /* Get supported audio formats */ - audio = guac_instruction_expect( - socket, GUACD_USEC_TIMEOUT, "audio"); - if (audio == NULL) { - - /* Log error */ - guacd_log_handshake_failure(); - guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"audio\""); - - /* Free resources */ - guac_client_free(client); - guac_socket_free(socket); - return; - } - - /* Store audio mimetypes */ - client->info.audio_mimetypes = - guacd_copy_mimetypes(audio->argv, audio->argc); - - guac_instruction_free(audio); - - /* Get supported video formats */ - video = guac_instruction_expect( - socket, GUACD_USEC_TIMEOUT, "video"); - if (video == NULL) { - - /* Log error */ - guacd_log_handshake_failure(); - guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"video\""); - - /* Free resources */ - guac_client_free(client); - guac_socket_free(socket); - return; - } - - /* Store video mimetypes */ - client->info.video_mimetypes = - guacd_copy_mimetypes(video->argv, video->argc); - - guac_instruction_free(video); - - /* Get supported image formats */ - image = guac_instruction_expect( - socket, GUACD_USEC_TIMEOUT, "image"); - if (image == NULL) { - - /* Log error */ - guacd_log_handshake_failure(); - guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"image\""); - - /* Free resources */ - guac_client_free(client); - guac_socket_free(socket); - return; - } - - /* Store image mimetypes */ - client->info.image_mimetypes = - guacd_copy_mimetypes(image->argv, image->argc); - - guac_instruction_free(image); - - /* Get args from connect instruction */ - connect = guac_instruction_expect( - socket, GUACD_USEC_TIMEOUT, "connect"); - if (connect == NULL) { - - /* Log error */ - guacd_log_handshake_failure(); - guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"connect\""); - - if (guac_client_plugin_close(plugin)) - guacd_log_guac_error(GUAC_LOG_WARNING, - "Unable to close client plugin"); - - guac_client_free(client); - guac_socket_free(socket); - return; - } - - client->socket = socket; - client->log_handler = guacd_client_log; - - /* Store client */ - if (guacd_client_map_add(map, client)) - guacd_log(GUAC_LOG_ERROR, "Unable to add client. Internal client storage has failed"); - - /* Send connection ID */ - guacd_log(GUAC_LOG_INFO, "Connection ID is \"%s\"", client->connection_id); - guac_protocol_send_ready(socket, client->connection_id); - - /* Init client */ - init_result = guac_client_plugin_init_client(plugin, - client, connect->argc, connect->argv); - - guac_instruction_free(connect); - - /* If client could not be started, free everything and fail */ - if (init_result) { - - guac_client_free(client); - - guacd_log_guac_error(GUAC_LOG_INFO, "Connection did not succeed"); - - if (guac_client_plugin_close(plugin)) - guacd_log_guac_error(GUAC_LOG_WARNING, - "Unable to close client plugin"); - - guac_socket_free(socket); - return; - } - - /* Start client threads */ - guacd_log(GUAC_LOG_INFO, "Starting client"); - if (guacd_client_start(client)) - guacd_log(GUAC_LOG_WARNING, "Client finished abnormally"); - else - guacd_log(GUAC_LOG_INFO, "Client disconnected"); - - /* Remove client */ - if (guacd_client_map_remove(map, client->connection_id) == NULL) - guacd_log(GUAC_LOG_ERROR, "Unable to remove client. Internal client storage has failed"); - - /* Free mimetype lists */ - guacd_free_mimetypes(client->info.audio_mimetypes); - guacd_free_mimetypes(client->info.video_mimetypes); - guacd_free_mimetypes(client->info.image_mimetypes); - - /* Clean up */ - guac_client_free(client); - if (guac_client_plugin_close(plugin)) - guacd_log_guac_error(GUAC_LOG_WARNING, - "Unable to close client plugin"); - - /* Close socket */ - guac_socket_free(socket); - -} - -int redirect_fd(int fd, int flags) { +static int redirect_fd(int fd, int flags) { /* Attempt to open bit bucket */ int new_fd = open(GUACD_DEV_NULL, flags); @@ -416,7 +72,10 @@ int redirect_fd(int fd, int flags) { } -int daemonize() { +/** + * Turns the current process into a daemon through a series of fork() calls. + */ +static int daemonize() { pid_t pid; @@ -499,7 +158,7 @@ int main(int argc, char* argv[]) { SSL_CTX* ssl_context = NULL; #endif - guacd_client_map* map = guacd_client_map_alloc(); + guacd_proc_map* map = guacd_proc_map_alloc(); /* General */ int retval; @@ -675,7 +334,7 @@ int main(int argc, char* argv[]) { /* Daemon loop */ for (;;) { - pid_t child_pid; + pthread_t child_thread; /* Accept connection */ client_addr_len = sizeof(client_addr); @@ -683,59 +342,27 @@ int main(int argc, char* argv[]) { (struct sockaddr*) &client_addr, &client_addr_len); if (connected_socket_fd < 0) { - guacd_log(GUAC_LOG_ERROR, "Could not accept client connection: %s", - strerror(errno)); - return 3; + guacd_log(GUAC_LOG_ERROR, "Could not accept client connection: %s", strerror(errno)); + continue; } - /* - * Once connection is accepted, send child into background. - * - * Note that we prefer fork() over threads for connection-handling - * processes as they give each connection its own memory area, and - * isolate the main daemon and other connections from errors in any - * particular client plugin. - */ + /* Create parameters for connection thread */ + guacd_connection_thread_params* params = malloc(sizeof(guacd_connection_thread_params)); + if (params == NULL) { + guacd_log(GUAC_LOG_ERROR, "Could not create connection thread: %s", strerror(errno)); + continue; + } - child_pid = fork(); - - /* If error, log */ - if (child_pid == -1) - guacd_log(GUAC_LOG_ERROR, "Error forking child process: %s", strerror(errno)); - - /* If child, start client, and exit when finished */ - else if (child_pid == 0) { - - guac_socket* socket; + params->map = map; + params->connected_socket_fd = connected_socket_fd; #ifdef ENABLE_SSL - - /* If SSL chosen, use it */ - if (ssl_context != NULL) { - socket = guac_socket_open_secure(ssl_context, connected_socket_fd); - if (socket == NULL) { - guacd_log_guac_error(GUAC_LOG_ERROR, - "Unable to set up SSL/TLS"); - return 0; - } - } - else - socket = guac_socket_open(connected_socket_fd); -#else - /* Open guac_socket */ - socket = guac_socket_open(connected_socket_fd); + params->ssl_context = ssl_context; #endif - guacd_handle_connection(map, socket); - close(connected_socket_fd); - return 0; - } - - /* If parent, close reference to child's descriptor */ - else if (close(connected_socket_fd) < 0) { - guacd_log(GUAC_LOG_ERROR, "Error closing daemon reference to " - "child descriptor: %s", strerror(errno)); - } + /* Spawn thread to handle connection */ + pthread_create(&child_thread, NULL, guacd_connection_thread, params); + pthread_detach(child_thread); } diff --git a/src/guacd/log.c b/src/guacd/log.c index 375877c5..2f8f0354 100644 --- a/src/guacd/log.c +++ b/src/guacd/log.c @@ -152,3 +152,20 @@ void guacd_client_log_guac_error(guac_client* client, } +void guacd_log_handshake_failure() { + + if (guac_error == GUAC_STATUS_CLOSED) + guacd_log(GUAC_LOG_INFO, + "Guacamole connection closed during handshake"); + else if (guac_error == GUAC_STATUS_PROTOCOL_ERROR) + guacd_log(GUAC_LOG_ERROR, + "Guacamole protocol violation. Perhaps the version of " + "guacamole-client is incompatible with this version of " + "guacd?"); + else + guacd_log(GUAC_LOG_WARNING, + "Guacamole handshake failed: %s", + guac_status_string(guac_error)); + +} + diff --git a/src/guacd/log.h b/src/guacd/log.h index bdb84521..68f9f78a 100644 --- a/src/guacd/log.h +++ b/src/guacd/log.h @@ -73,5 +73,11 @@ void guacd_log_guac_error(guac_client_log_level level, const char* message); void guacd_client_log_guac_error(guac_client* client, guac_client_log_level level, const char* message); +/** + * Logs a reasonable explanatory message regarding handshake failure based on + * the current value of guac_error. + */ +void guacd_log_handshake_failure(); + #endif diff --git a/src/guacd/move-fd.c b/src/guacd/move-fd.c new file mode 100644 index 00000000..07957336 --- /dev/null +++ b/src/guacd/move-fd.c @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2014 Glyptodon LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "config.h" +#include "move-fd.h" + +/* Required for CMSG_* macros on BSD */ +#define __BSD_VISIBLE 1 + +#include +#include +#include +#include +#include +#include +#include + +int guacd_send_fd(int sock, int fd) { + + struct msghdr message = {0}; + char message_data[] = {'G'}; + + /* Assign data buffer */ + struct iovec io_vector[1]; + io_vector[0].iov_base = message_data; + io_vector[0].iov_len = sizeof(message_data); + message.msg_iov = io_vector; + message.msg_iovlen = 1; + + /* Assign ancillary data buffer */ + char buffer[CMSG_SPACE(sizeof(fd))]; + message.msg_control = buffer; + message.msg_controllen = sizeof(buffer); + + /* Set fields of control message header */ + struct cmsghdr* control = CMSG_FIRSTHDR(&message); + control->cmsg_level = SOL_SOCKET; + control->cmsg_type = SCM_RIGHTS; + control->cmsg_len = CMSG_LEN(sizeof(fd)); + + /* Add file descriptor to message data */ + memcpy(CMSG_DATA(control), &fd, sizeof(fd)); + + /* Send file descriptor */ + return (sendmsg(sock, &message, 0) == sizeof(message_data)); + +} + +int guacd_recv_fd(int sock) { + + int fd; + + struct msghdr message = {0}; + char message_data[1]; + + /* Assign data buffer */ + struct iovec io_vector[1]; + io_vector[0].iov_base = message_data; + io_vector[0].iov_len = sizeof(message_data); + message.msg_iov = io_vector; + message.msg_iovlen = 1; + + + /* Assign ancillary data buffer */ + char buffer[CMSG_SPACE(sizeof(fd))]; + message.msg_control = buffer; + message.msg_controllen = sizeof(buffer); + + /* Receive file descriptor */ + if (recvmsg(sock, &message, 0) == sizeof(message_data)) { + + /* Validate payload */ + if (message_data[0] != 'G') { + errno = EPROTO; + return -1; + } + + /* Iterate control headers, looking for the sent file descriptor */ + struct cmsghdr* control; + for (control = CMSG_FIRSTHDR(&message); control != NULL; control = CMSG_NXTHDR(&message, control)) { + + /* Pull file descriptor from data */ + if (control->cmsg_level == SOL_SOCKET && control->cmsg_type == SCM_RIGHTS) { + memcpy(&fd, CMSG_DATA(control), sizeof(fd)); + return fd; + } + + } + + } /* end if recvmsg() success */ + + /* Failed to receive file descriptor */ + return -1; + +} + diff --git a/src/guacd/move-fd.h b/src/guacd/move-fd.h new file mode 100644 index 00000000..aed40993 --- /dev/null +++ b/src/guacd/move-fd.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2014 Glyptodon LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef GUACD_MOVE_FD_H +#define GUACD_MOVE_FD_H + +#include "config.h" + +/** + * Sends the given file descriptor along the given socket. The file descriptor + * must have been sent via guacd_recv_fd. Returns non-zero on success, zero on + * error. If an error does occur, errno will be set appropriately. + */ +int guacd_send_fd(int sock, int fd); + +/** + * Waits for a file descriptor on the given socket, returning the received file + * descriptor. If an error occurs, -1 is returned, and errno will be set + * appropriately. + */ +int guacd_recv_fd(int sock); + +#endif + diff --git a/src/guacd/client-map.c b/src/guacd/proc-map.c similarity index 67% rename from src/guacd/client-map.c rename to src/guacd/proc-map.c index a13478a6..d63f50ba 100644 --- a/src/guacd/client-map.c +++ b/src/guacd/proc-map.c @@ -21,9 +21,10 @@ */ #include "config.h" -#include "client.h" -#include "client-map.h" #include "guac_list.h" +#include "proc.h" +#include "proc-map.h" +#include "user.h" #include @@ -50,18 +51,19 @@ static unsigned int __guacd_client_hash(const char* str) { * Locates the bucket corresponding to the hash code indicated by the give id. * Each bucket is an instance of guac_common_list. */ -static guac_common_list* __guacd_client_find_bucket(guacd_client_map* map, const char* id) { +static guac_common_list* __guacd_proc_find_bucket(guacd_proc_map* map, const char* id) { - const int index = __guacd_client_hash(id) % GUACD_CLIENT_MAP_BUCKETS; + const int index = __guacd_client_hash(id) % GUACD_PROC_MAP_BUCKETS; return map->__buckets[index]; } /** - * Given a list of guac_client instances, returns the guac_client having the - * given ID, or NULL if no such client is stored. + * Given a list of guacd_proc instances, returns the + * guacd_proc having the guac_client with the given ID, or NULL if no + * such client is stored. */ -static guac_common_list_element* __guacd_client_find(guac_common_list* bucket, const char* id) { +static guac_common_list_element* __guacd_proc_find(guac_common_list* bucket, const char* id) { guac_common_list_element* current = bucket->head; @@ -69,8 +71,8 @@ static guac_common_list_element* __guacd_client_find(guac_common_list* bucket, c while (current != NULL) { /* Check connection ID */ - guac_client* client = (guac_client*) current->data; - if (strcmp(client->connection_id, id) == 0) + guacd_proc* proc = (guacd_proc*) current->data; + if (strcmp(proc->client->connection_id, id) == 0) break; current = current->next; @@ -80,9 +82,9 @@ static guac_common_list_element* __guacd_client_find(guac_common_list* bucket, c } -guacd_client_map* guacd_client_map_alloc() { +guacd_proc_map* guacd_proc_map_alloc() { - guacd_client_map* map = malloc(sizeof(guacd_client_map)); + guacd_proc_map* map = malloc(sizeof(guacd_proc_map)); guac_common_list** current; int i; @@ -90,7 +92,7 @@ guacd_client_map* guacd_client_map_alloc() { /* Init all buckets */ current = map->__buckets; - for (i=0; iconnection_id); + const char* identifier = proc->client->connection_id; + guac_common_list* bucket = __guacd_proc_find_bucket(map, identifier); guac_common_list_element* found; /* Retrieve corresponding element, if any */ guac_common_list_lock(bucket); - found = __guacd_client_find(bucket, client->connection_id); + found = __guacd_proc_find(bucket, identifier); /* If no such element, we can add the new client successfully */ if (found == NULL) { - guac_common_list_add(bucket, client); + guac_common_list_add(bucket, proc); guac_common_list_unlock(bucket); return 0; } @@ -121,16 +124,16 @@ int guacd_client_map_add(guacd_client_map* map, guac_client* client) { } -guac_client* guacd_client_map_retrieve(guacd_client_map* map, const char* id) { +guacd_proc* guacd_proc_map_retrieve(guacd_proc_map* map, const char* id) { - guac_client* client; + guacd_proc* proc; - guac_common_list* bucket = __guacd_client_find_bucket(map, id); + guac_common_list* bucket = __guacd_proc_find_bucket(map, id); guac_common_list_element* found; /* Retrieve corresponding element, if any */ guac_common_list_lock(bucket); - found = __guacd_client_find(bucket, id); + found = __guacd_proc_find(bucket, id); /* If no such element, fail */ if (found == NULL) { @@ -138,23 +141,23 @@ guac_client* guacd_client_map_retrieve(guacd_client_map* map, const char* id) { return NULL; } - client = (guac_client*) found->data; + proc = (guacd_proc*) found->data; guac_common_list_unlock(bucket); - return client; + return proc; } -guac_client* guacd_client_map_remove(guacd_client_map* map, const char* id) { +guacd_proc* guacd_proc_map_remove(guacd_proc_map* map, const char* id) { - guac_client* client; + guacd_proc* proc; - guac_common_list* bucket = __guacd_client_find_bucket(map, id); + guac_common_list* bucket = __guacd_proc_find_bucket(map, id); guac_common_list_element* found; /* Retrieve corresponding element, if any */ guac_common_list_lock(bucket); - found = __guacd_client_find(bucket, id); + found = __guacd_proc_find(bucket, id); /* If no such element, fail */ if (found == NULL) { @@ -162,11 +165,11 @@ guac_client* guacd_client_map_remove(guacd_client_map* map, const char* id) { return NULL; } - client = (guac_client*) found->data; + proc = (guacd_proc*) found->data; guac_common_list_remove(bucket, found); guac_common_list_unlock(bucket); - return client; + return proc; } diff --git a/src/guacd/client-map.h b/src/guacd/proc-map.h similarity index 55% rename from src/guacd/client-map.h rename to src/guacd/proc-map.h index 8544bc4e..da73c516 100644 --- a/src/guacd/client-map.h +++ b/src/guacd/proc-map.h @@ -21,53 +21,58 @@ */ -#ifndef _GUACD_CLIENT_MAP_H -#define _GUACD_CLIENT_MAP_H +#ifndef _GUACD_PROC_MAP_H +#define _GUACD_PROC_MAP_H #include "config.h" -#include "client.h" #include "guac_list.h" +#include "proc.h" +#include "user.h" #include -#define GUACD_CLIENT_MAP_BUCKETS GUACD_CLIENT_MAX_CONNECTIONS*2 +/** + * The number of hash buckets in each process map. + */ +#define GUACD_PROC_MAP_BUCKETS GUACD_CLIENT_MAX_CONNECTIONS*2 /** * Set of all active connections to guacd, indexed by connection ID. */ -typedef struct guacd_client_map { +typedef struct guacd_proc_map { /** * Internal hash buckets. Each bucket is a linked list containing all * guac_client instances which hash to this bucket location. */ - guac_common_list* __buckets[GUACD_CLIENT_MAP_BUCKETS]; + guac_common_list* __buckets[GUACD_PROC_MAP_BUCKETS]; -} guacd_client_map; +} guacd_proc_map; /** - * Allocates a new client map, which persists for the life of guacd. + * Allocates a new client process map, which persists for the life of guacd. */ -guacd_client_map* guacd_client_map_alloc(); +guacd_proc_map* guacd_proc_map_alloc(); /** - * Adds the given client to the given client map. On success, zero is returned. - * If adding the client fails (due to lack of space, or duplicate ID), a - * non-zero value is returned instead. + * Adds the given process to the client process map. On success, zero is returned. If + * adding the client fails (due to lack of space, or duplicate ID), a non-zero + * value is returned instead. The client process is stored by the connection ID + * of the underlying guac_client. */ -int guacd_client_map_add(guacd_client_map* map, guac_client* client); +int guacd_proc_map_add(guacd_proc_map* map, guacd_proc* proc); /** - * Retrieves the client having the given ID, or NULL if no such client - * is stored. + * Retrieves the client process having the client with the given ID, or NULL if + * no such process is stored. */ -guac_client* guacd_client_map_retrieve(guacd_client_map* map, const char* id); +guacd_proc* guacd_proc_map_retrieve(guacd_proc_map* map, const char* id); /** - * Removes the client having the given ID, returning the corresponding client. - * If no such client exists, NULL is returned. + * Removes the client process having the client with the given ID, returning + * the corresponding process. If no such process exists, NULL is returned. */ -guac_client* guacd_client_map_remove(guacd_client_map* map, const char* id); +guacd_proc* guacd_proc_map_remove(guacd_proc_map* map, const char* id); #endif diff --git a/src/guacd/proc.c b/src/guacd/proc.c new file mode 100644 index 00000000..cc9eb4d5 --- /dev/null +++ b/src/guacd/proc.c @@ -0,0 +1,458 @@ +/* + * Copyright (C) 2014 Glyptodon LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "config.h" + +#include "log.h" +#include "move-fd.h" +#include "proc.h" +#include "proc-map.h" +#include "user.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +/** + * Copies the given array of mimetypes (strings) into a newly-allocated NULL- + * terminated array of strings. Both the array and the strings within the array + * are newly-allocated and must be later freed via guacd_free_mimetypes(). + * + * @param mimetypes + * The array of mimetypes to copy. + * + * @param count + * The number of mimetypes in the given array. + * + * @return + * A newly-allocated, NULL-terminated array containing newly-allocated + * copies of each of the mimetypes provided in the original mimetypes + * array. + */ +static char** guacd_copy_mimetypes(char** mimetypes, int count) { + + int i; + + /* Allocate sufficient space for NULL-terminated array of mimetypes */ + char** mimetypes_copy = malloc(sizeof(char*) * (count+1)); + + /* Copy each provided mimetype */ + for (i = 0; i < count; i++) + mimetypes_copy[i] = strdup(mimetypes[i]); + + /* Terminate with NULL */ + mimetypes_copy[count] = NULL; + + return mimetypes_copy; + +} + +/** + * Frees the given array of mimetypes, including the space allocated to each + * mimetype string within the array. The provided array of mimetypes MUST have + * been allocated with guacd_copy_mimetypes(). + * + * @param mimetypes + * The NULL-terminated array of mimetypes to free. This array MUST have + * been previously allocated with guacd_copy_mimetypes(). + */ +static void guacd_free_mimetypes(char** mimetypes) { + + char** current_mimetype = mimetypes; + + /* Free all strings within NULL-terminated mimetype array */ + while (*current_mimetype != NULL) { + free(*current_mimetype); + current_mimetype++; + } + + /* Free the array itself, now that its contents have been freed */ + free(mimetypes); + +} + +/** + * Handles the initial handshake of a user and all subsequent I/O. + */ +static int guacd_handle_user(guac_user* user) { + + guac_socket* socket = user->socket; + guac_client* client = user->client; + + /* Send args */ + if (guac_protocol_send_args(socket, client->args) + || guac_socket_flush(socket)) { + + /* Log error */ + guacd_log_handshake_failure(); + guacd_log_guac_error(GUAC_LOG_DEBUG, "Error sending \"args\" to new user"); + + return 1; + } + + guac_parser* parser = guac_parser_alloc(); + + /* Get optimal screen size */ + if (guac_parser_expect(parser, socket, GUACD_USEC_TIMEOUT, "size")) { + + /* Log error */ + guacd_log_handshake_failure(); + guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"size\""); + + guac_parser_free(parser); + return 1; + } + + /* Validate content of size instruction */ + if (parser->argc < 2) { + guacd_log(GUAC_LOG_ERROR, "Received \"size\" instruction lacked required arguments."); + guac_parser_free(parser); + return 1; + } + + /* Parse optimal screen dimensions from size instruction */ + user->info.optimal_width = atoi(parser->argv[0]); + user->info.optimal_height = atoi(parser->argv[1]); + + /* If DPI given, set the client resolution */ + if (parser->argc >= 3) + user->info.optimal_resolution = atoi(parser->argv[2]); + + /* Otherwise, use a safe default for rough backwards compatibility */ + else + user->info.optimal_resolution = 96; + + /* Get supported audio formats */ + if (guac_parser_expect(parser, socket, GUACD_USEC_TIMEOUT, "audio")) { + + /* Log error */ + guacd_log_handshake_failure(); + guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"audio\""); + + guac_parser_free(parser); + return 1; + } + + /* Store audio mimetypes */ + char** audio_mimetypes = guacd_copy_mimetypes(parser->argv, parser->argc); + user->info.audio_mimetypes = (const char**) audio_mimetypes; + + /* Get supported video formats */ + if (guac_parser_expect(parser, socket, GUACD_USEC_TIMEOUT, "video")) { + + /* Log error */ + guacd_log_handshake_failure(); + guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"video\""); + + guac_parser_free(parser); + return 1; + } + + /* Store video mimetypes */ + char** video_mimetypes = guacd_copy_mimetypes(parser->argv, parser->argc); + user->info.video_mimetypes = (const char**) video_mimetypes; + + /* Get supported image formats */ + if (guac_parser_expect(parser, socket, GUACD_USEC_TIMEOUT, "image")) { + + /* Log error */ + guacd_log_handshake_failure(); + guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"image\""); + + guac_parser_free(parser); + return 1; + } + + /* Store image mimetypes */ + char** image_mimetypes = guacd_copy_mimetypes(parser->argv, parser->argc); + user->info.image_mimetypes = (const char**) image_mimetypes; + + /* Get args from connect instruction */ + if (guac_parser_expect(parser, socket, GUACD_USEC_TIMEOUT, "connect")) { + + /* Log error */ + guacd_log_handshake_failure(); + guacd_log_guac_error(GUAC_LOG_DEBUG, "Error reading \"connect\""); + + guac_parser_free(parser); + return 1; + } + + /* Acknowledge connection availability */ + guac_protocol_send_ready(socket, client->connection_id); + guac_socket_flush(socket); + + /* Attempt join */ + if (guac_client_add_user(client, user, parser->argc, parser->argv)) + guacd_log(GUAC_LOG_ERROR, "User \"%s\" could NOT join connection \"%s\"", user->user_id, client->connection_id); + + /* Begin user connection if join successful */ + else { + + guacd_log(GUAC_LOG_INFO, "User \"%s\" joined connection \"%s\" (%i users now present)", + user->user_id, client->connection_id, client->connected_users); + + /* Handle user I/O, wait for connection to terminate */ + guacd_user_start(parser, user); + + /* Remove/free user */ + guac_client_remove_user(client, user); + guacd_log(GUAC_LOG_INFO, "User \"%s\" disconnected (%i users remain)", user->user_id, client->connected_users); + + } + + /* Free mimetype lists */ + guacd_free_mimetypes(audio_mimetypes); + guacd_free_mimetypes(video_mimetypes); + guacd_free_mimetypes(image_mimetypes); + + guac_parser_free(parser); + + /* Successful disconnect */ + return 0; + +} + +/** + * Parameters for the user thread. + */ +typedef struct guacd_user_thread_params { + + /** + * The process being joined. + */ + guacd_proc* proc; + + /** + * The file descriptor of the joining user's socket. + */ + int fd; + + /** + * Whether the joining user is the connection owner. + */ + int owner; + +} guacd_user_thread_params; + +/** + * Handles a user's entire connection and socket lifecycle. + */ +void* guacd_user_thread(void* data) { + + guacd_user_thread_params* params = (guacd_user_thread_params*) data; + guacd_proc* proc = params->proc; + guac_client* client = proc->client; + + /* Get guac_socket for user's file descriptor */ + guac_socket* socket = guac_socket_open(params->fd); + if (socket == NULL) + return NULL; + + /* Create skeleton user */ + guac_user* user = guac_user_alloc(); + user->socket = socket; + user->client = client; + user->owner = params->owner; + + /* Handle user connection from handshake until disconnect/completion */ + guacd_handle_user(user); + + /* Stop client and prevent future users if all users are disconnected */ + if (client->connected_users == 0) { + guacd_log(GUAC_LOG_INFO, "Last user of connection \"%s\" disconnected", client->connection_id); + guacd_proc_stop(proc); + } + + /* Clean up */ + guac_socket_free(socket); + guac_user_free(user); + free(params); + + return NULL; + +} + +/** + * Begins a new user connection under a given process, using the given file + * descriptor. + */ +static void guacd_proc_add_user(guacd_proc* proc, int fd, int owner) { + + guacd_user_thread_params* params = malloc(sizeof(guacd_user_thread_params)); + params->proc = proc; + params->fd = fd; + params->owner = owner; + + /* Start user thread */ + pthread_t user_thread; + pthread_create(&user_thread, NULL, guacd_user_thread, params); + pthread_detach(user_thread); + +} + +/** + * Starts protocol-specific handling on the given process. This function does + * NOT return. It initializes the process with protocol-specific handlers and + * then runs until the fd_socket is closed. + */ +static void guacd_exec_proc(guacd_proc* proc, const char* protocol) { + + /* Init client for selected protocol */ + if (guac_client_load_plugin(proc->client, protocol)) { + + /* Log error */ + if (guac_error == GUAC_STATUS_NOT_FOUND) + guacd_log(GUAC_LOG_WARNING, + "Support for protocol \"%s\" is not installed", protocol); + else + guacd_log_guac_error(GUAC_LOG_ERROR, + "Unable to load client plugin"); + + guac_client_free(proc->client); + close(proc->fd_socket); + free(proc); + exit(1); + } + + /* The first file descriptor is the owner */ + int owner = 1; + + /* Add each received file descriptor as a new user */ + int received_fd; + while ((received_fd = guacd_recv_fd(proc->fd_socket)) != -1) { + + guacd_proc_add_user(proc, received_fd, owner); + + /* Future file descriptors are not owners */ + owner = 0; + + } + + /* Stop and free client */ + guac_client_stop(proc->client); + guac_client_free(proc->client); + + /* Child is finished */ + close(proc->fd_socket); + free(proc); + exit(0); + +} + +guacd_proc* guacd_create_proc(guac_parser* parser, const char* protocol) { + + int sockets[2]; + + /* Open UNIX socket pair */ + if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets) < 0) { + guacd_log(GUAC_LOG_ERROR, "Error opening socket pair: %s", strerror(errno)); + return NULL; + } + + int parent_socket = sockets[0]; + int child_socket = sockets[1]; + + /* Allocate process */ + guacd_proc* proc = calloc(1, sizeof(guacd_proc)); + if (proc == NULL) { + close(parent_socket); + close(child_socket); + return NULL; + } + + /* Associate new client */ + proc->client = guac_client_alloc(); + if (proc->client == NULL) { + guacd_log_guac_error(GUAC_LOG_ERROR, "Unable to create client"); + close(parent_socket); + close(child_socket); + free(proc); + return NULL; + } + + /* Init logging */ + proc->client->log_handler = guacd_client_log; + + /* Fork */ + proc->pid = fork(); + if (proc->pid < 0) { + guacd_log(GUAC_LOG_ERROR, "Cannot fork child process: %s", strerror(errno)); + close(parent_socket); + close(child_socket); + guac_client_free(proc->client); + free(proc); + return NULL; + } + + /* Child */ + else if (proc->pid == 0) { + + /* Communicate with parent */ + proc->fd_socket = parent_socket; + close(child_socket); + + /* Start protocol-specific handling */ + guacd_exec_proc(proc, protocol); + + } + + /* Parent */ + else { + + /* Communicate with child */ + proc->fd_socket = child_socket; + close(parent_socket); + + } + + return proc; + +} + +void guacd_proc_stop(guacd_proc* proc) { + + /* Signal client to stop */ + guac_client_stop(proc->client); + + /* Shutdown socket - in-progress recvmsg() will not fail otherwise */ + if (shutdown(proc->fd_socket, SHUT_RDWR) == -1) + guacd_log(GUAC_LOG_ERROR, "Unable to shutdown internal socket for " + "connection %s. Corresponding process may remain running but " + "inactive.", proc->client->connection_id); + + /* Clean up our end of the socket */ + close(proc->fd_socket); + +} + diff --git a/src/guacd/proc.h b/src/guacd/proc.h new file mode 100644 index 00000000..95ef4742 --- /dev/null +++ b/src/guacd/proc.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2014 Glyptodon LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef GUACD_PROC_H +#define GUACD_PROC_H + +#include "config.h" + +#include +#include + +#include + +/** + * Process information of the internal remote desktop client. + */ +typedef struct guacd_proc { + + /** + * The process ID of the client. This will only be available to the + * parent process. The child process will see this as 0. + */ + pid_t pid; + + /** + * The file descriptor of the UNIX domain socket to use for sending and + * receiving file descriptors of new users. This parent will see this + * as the file descriptor for communicating with the child and vice + * versa. + */ + int fd_socket; + + /** + * The actual client instance. This will be visible to both child and + * parent process, but only the child will have a full guac_client + * instance, containing handlers from the plugin, etc. + * + * The parent process will receive a skeleton guac_client, containing only + * a proper connection_id and logging handlers. The actual + * protocol-specific handling will be absent. + */ + guac_client* client; + +} guacd_proc; + +/** + * Creates a new process for handling the given protocol, returning the process + * created. The created process runs in the background relative to the calling + * process. Within the child process, this function does not return - the + * entire child process simply terminates instead. + */ +guacd_proc* guacd_create_proc(guac_parser* parser, const char* protocol); + +/** + * Signals the given process to stop accepting new users and clean up. This + * will eventually cause the child process to exit. + */ +void guacd_proc_stop(guacd_proc* proc); + +#endif + diff --git a/src/guacd/socket-ssl.c b/src/guacd/socket-ssl.c index 751286d8..921164d3 100644 --- a/src/guacd/socket-ssl.c +++ b/src/guacd/socket-ssl.c @@ -113,6 +113,9 @@ static int __guac_socket_ssl_free_handler(guac_socket* socket) { guac_socket_ssl_data* data = (guac_socket_ssl_data*) socket->data; SSL_shutdown(data->ssl); + /* Close file descriptor */ + close(data->fd); + free(data); return 0; } diff --git a/src/guacd/socket-ssl.h b/src/guacd/socket-ssl.h index 3ad0a4da..e1cdc804 100644 --- a/src/guacd/socket-ssl.h +++ b/src/guacd/socket-ssl.h @@ -54,7 +54,8 @@ typedef struct guac_socket_ssl_data { } guac_socket_ssl_data; /** - * Creates a new guac_socket which will use SSL for all communication. + * Creates a new guac_socket which will use SSL for all communication. Freeing + * this guac_socket will automatically close the associated file descriptor. */ guac_socket* guac_socket_open_secure(SSL_CTX* context, int fd); diff --git a/src/guacd/user.c b/src/guacd/user.c new file mode 100644 index 00000000..0609831c --- /dev/null +++ b/src/guacd/user.c @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2013 Glyptodon LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "config.h" + +#include "log.h" +#include "user.h" + +#include +#include +#include +#include +#include +#include + +#include +#include + +void* guacd_user_input_thread(void* data) { + + guacd_user_input_thread_params* params = (guacd_user_input_thread_params*) data; + guac_user* user = params->user; + guac_parser* parser = params->parser; + guac_client* client = user->client; + guac_socket* socket = user->socket; + + /* Guacamole user input loop */ + while (client->state == GUAC_CLIENT_RUNNING && user->active) { + + /* Read instruction, stop on error */ + if (guac_parser_read(parser, socket, GUACD_USEC_TIMEOUT)) { + + if (guac_error == GUAC_STATUS_TIMEOUT) + guac_user_abort(user, GUAC_PROTOCOL_STATUS_CLIENT_TIMEOUT, "User is not responding."); + + else { + if (guac_error != GUAC_STATUS_CLOSED) + guacd_client_log_guac_error(client, GUAC_LOG_WARNING, + "Guacamole connection failure"); + guac_user_stop(user); + } + + return NULL; + } + + /* Reset guac_error and guac_error_message (user/client handlers are not + * guaranteed to set these) */ + guac_error = GUAC_STATUS_SUCCESS; + guac_error_message = NULL; + + /* Call handler, stop on error */ + if (guac_user_handle_instruction(user, parser->opcode, parser->argc, parser->argv) < 0) { + + /* Log error */ + guacd_client_log_guac_error(client, GUAC_LOG_WARNING, + "User connection aborted"); + + /* Log handler details */ + guac_user_log(user, GUAC_LOG_DEBUG, "Failing instruction handler in user was \"%s\"", parser->opcode); + + guac_user_stop(user); + return NULL; + } + + } + + return NULL; + +} + +int guacd_user_start(guac_parser* parser, guac_user* user) { + + guacd_user_input_thread_params params = { + .parser = parser, + .user = user + }; + + pthread_t input_thread; + + if (pthread_create(&input_thread, NULL, guacd_user_input_thread, (void*) ¶ms)) { + guac_user_log(user, GUAC_LOG_ERROR, "Unable to start input thread"); + guac_user_stop(user); + return -1; + } + + /* Wait for I/O threads */ + pthread_join(input_thread, NULL); + + /* Done */ + return 0; + +} + diff --git a/src/guacd/client.h b/src/guacd/user.h similarity index 59% rename from src/guacd/client.h rename to src/guacd/user.h index 214af2a0..cee0ae93 100644 --- a/src/guacd/client.h +++ b/src/guacd/user.h @@ -21,38 +21,14 @@ */ -#ifndef _GUACD_CLIENT_H -#define _GUACD_CLIENT_H +#ifndef _GUACD_USER_H +#define _GUACD_USER_H #include "config.h" -#include - -/** - * The time to allow between sync responses in milliseconds. If a sync - * instruction is sent to the client and no response is received within this - * timeframe, server messages will not be handled until a sync instruction is - * received from the client. - */ -#define GUACD_SYNC_THRESHOLD 500 - -/** - * The time to allow between server sync messages in milliseconds. A sync - * message from the server will be sent every GUACD_SYNC_FREQUENCY milliseconds. - * As this will induce a response from a client that is not malfunctioning, - * this is used to detect when a client has died. This must be set to a - * reasonable value to avoid clients being disconnected unnecessarily due - * to timeout. - */ -#define GUACD_SYNC_FREQUENCY 5000 - -/** - * The amount of time to wait after handling server messages. If a client - * plugin has a message handler, and sends instructions when server messages - * are being handled, there will be a pause of this many milliseconds before - * the next call to the message handler. - */ -#define GUACD_MESSAGE_HANDLE_FREQUENCY 50 +#include +#include +#include /** * The number of milliseconds to wait for messages in any phase before @@ -73,7 +49,34 @@ */ #define GUACD_CLIENT_MAX_CONNECTIONS 65536 -int guacd_client_start(guac_client* client); +/** + * Parameters required by the user input thread. + */ +typedef struct guacd_user_input_thread_params { + + /** + * The parser which will be used throughout the user's session. + */ + guac_parser* parser; + + /** + * A reference to the connected user. + */ + guac_user* user; + +} guacd_user_input_thread_params; + +/** + * Starts the input/output threads of a new user. This function will block + * until the user disconnects. + */ +int guacd_user_start(guac_parser* parser, guac_user* user); + +/** + * The thread which handles all user input, calling event handlers for received + * instructions. + */ +void* guacd_user_input_thread(void* data); #endif