407 lines
13 KiB
C
407 lines
13 KiB
C
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "auth.h"
|
|
#include "client.h"
|
|
#include "clipboard.h"
|
|
#include "common/clipboard.h"
|
|
#include "common/cursor.h"
|
|
#include "common/display.h"
|
|
#include "common/recording.h"
|
|
#include "cursor.h"
|
|
#include "display.h"
|
|
#include "log.h"
|
|
#include "settings.h"
|
|
#include "vnc.h"
|
|
|
|
#ifdef ENABLE_PULSE
|
|
#include "pulse/pulse.h"
|
|
#endif
|
|
|
|
#ifdef ENABLE_COMMON_SSH
|
|
#include "common-ssh/sftp.h"
|
|
#include "common-ssh/ssh.h"
|
|
#include "sftp.h"
|
|
#endif
|
|
|
|
#include <guacamole/client.h>
|
|
#include <guacamole/protocol.h>
|
|
#include <guacamole/socket.h>
|
|
#include <guacamole/timestamp.h>
|
|
#include <rfb/rfbclient.h>
|
|
#include <rfb/rfbproto.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
char* GUAC_VNC_CLIENT_KEY = "GUAC_VNC";
|
|
|
|
rfbClient* guac_vnc_get_client(guac_client* client) {
|
|
|
|
rfbClient* rfb_client = rfbGetClient(8, 3, 4); /* 32-bpp client */
|
|
guac_vnc_client* vnc_client = (guac_vnc_client*) client->data;
|
|
guac_vnc_settings* vnc_settings = vnc_client->settings;
|
|
|
|
/* Store Guac client in rfb client */
|
|
rfbClientSetClientData(rfb_client, GUAC_VNC_CLIENT_KEY, client);
|
|
|
|
/* Framebuffer update handler */
|
|
rfb_client->GotFrameBufferUpdate = guac_vnc_update;
|
|
rfb_client->GotCopyRect = guac_vnc_copyrect;
|
|
|
|
/* Do not handle clipboard and local cursor if read-only */
|
|
if (vnc_settings->read_only == 0) {
|
|
|
|
/* Clipboard */
|
|
rfb_client->GotXCutText = guac_vnc_cut_text;
|
|
|
|
/* Set remote cursor */
|
|
if (vnc_settings->remote_cursor) {
|
|
rfb_client->appData.useRemoteCursor = FALSE;
|
|
}
|
|
|
|
else {
|
|
/* Enable client-side cursor */
|
|
rfb_client->appData.useRemoteCursor = TRUE;
|
|
rfb_client->GotCursorShape = guac_vnc_cursor;
|
|
}
|
|
|
|
}
|
|
|
|
/* Password */
|
|
rfb_client->GetPassword = guac_vnc_get_password;
|
|
|
|
/* Depth */
|
|
guac_vnc_set_pixel_format(rfb_client, vnc_settings->color_depth);
|
|
|
|
/* Hook into allocation so we can handle resize. */
|
|
vnc_client->rfb_MallocFrameBuffer = rfb_client->MallocFrameBuffer;
|
|
rfb_client->MallocFrameBuffer = guac_vnc_malloc_framebuffer;
|
|
rfb_client->canHandleNewFBSize = 1;
|
|
|
|
/* Set hostname and port */
|
|
rfb_client->serverHost = strdup(vnc_settings->hostname);
|
|
rfb_client->serverPort = vnc_settings->port;
|
|
|
|
#ifdef ENABLE_VNC_REPEATER
|
|
/* Set repeater parameters if specified */
|
|
if (vnc_settings->dest_host) {
|
|
rfb_client->destHost = strdup(vnc_settings->dest_host);
|
|
rfb_client->destPort = vnc_settings->dest_port;
|
|
}
|
|
#endif
|
|
|
|
#ifdef ENABLE_VNC_LISTEN
|
|
/* If reverse connection enabled, start listening */
|
|
if (vnc_settings->reverse_connect) {
|
|
|
|
guac_client_log(client, GUAC_LOG_INFO, "Listening for connections on port %i", vnc_settings->port);
|
|
|
|
/* Listen for connection from server */
|
|
rfb_client->listenPort = vnc_settings->port;
|
|
if (listenForIncomingConnectionsNoFork(rfb_client, vnc_settings->listen_timeout*1000) <= 0)
|
|
return NULL;
|
|
|
|
}
|
|
#endif
|
|
|
|
/* Set encodings if provided */
|
|
if (vnc_settings->encodings)
|
|
rfb_client->appData.encodingsString = strdup(vnc_settings->encodings);
|
|
|
|
/* Connect */
|
|
if (rfbInitClient(rfb_client, NULL, NULL))
|
|
return rfb_client;
|
|
|
|
/* If connection fails, return NULL */
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/**
|
|
* Waits until data is available to be read from the given rfbClient, and thus
|
|
* a call to HandleRFBServerMessages() should not block. If the timeout elapses
|
|
* before data is available, zero is returned.
|
|
*
|
|
* @param rfb_client
|
|
* The rfbClient to wait for.
|
|
*
|
|
* @param timeout
|
|
* The maximum amount of time to wait, in microseconds.
|
|
*
|
|
* @returns
|
|
* A positive value if data is available, zero if the timeout elapses
|
|
* before data becomes available, or a negative value on error.
|
|
*/
|
|
static int guac_vnc_wait_for_messages(rfbClient* rfb_client, int timeout) {
|
|
|
|
/* Do not explicitly wait while data is on the buffer */
|
|
if (rfb_client->buffered)
|
|
return 1;
|
|
|
|
/* If no data on buffer, wait for data on socket */
|
|
return WaitForMessage(rfb_client, timeout);
|
|
|
|
}
|
|
|
|
void* guac_vnc_client_thread(void* data) {
|
|
|
|
guac_client* client = (guac_client*) data;
|
|
guac_vnc_client* vnc_client = (guac_vnc_client*) client->data;
|
|
guac_vnc_settings* settings = vnc_client->settings;
|
|
|
|
/* Configure clipboard encoding */
|
|
if (guac_vnc_set_clipboard_encoding(client, settings->clipboard_encoding)) {
|
|
guac_client_log(client, GUAC_LOG_INFO, "Using non-standard VNC "
|
|
"clipboard encoding: '%s'.", settings->clipboard_encoding);
|
|
}
|
|
|
|
/* Ensure connection is kept alive during lengthy connects */
|
|
guac_socket_require_keep_alive(client->socket);
|
|
|
|
/* Set up libvncclient logging */
|
|
rfbClientLog = guac_vnc_client_log_info;
|
|
rfbClientErr = guac_vnc_client_log_error;
|
|
|
|
/* Attempt connection */
|
|
rfbClient* rfb_client = guac_vnc_get_client(client);
|
|
int retries_remaining = settings->retries;
|
|
|
|
/* If unsuccessful, retry as many times as specified */
|
|
while (!rfb_client && retries_remaining > 0) {
|
|
|
|
guac_client_log(client, GUAC_LOG_INFO,
|
|
"Connect failed. Waiting %ims before retrying...",
|
|
GUAC_VNC_CONNECT_INTERVAL);
|
|
|
|
/* Wait for given interval then retry */
|
|
guac_timestamp_msleep(GUAC_VNC_CONNECT_INTERVAL);
|
|
rfb_client = guac_vnc_get_client(client);
|
|
retries_remaining--;
|
|
|
|
}
|
|
|
|
/* If the final connect attempt fails, return error */
|
|
if (!rfb_client) {
|
|
guac_client_abort(client, GUAC_PROTOCOL_STATUS_UPSTREAM_NOT_FOUND,
|
|
"Unable to connect to VNC server.");
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef ENABLE_PULSE
|
|
/* If audio is enabled, start streaming via PulseAudio */
|
|
if (settings->audio_enabled)
|
|
vnc_client->audio = guac_pa_stream_alloc(client,
|
|
settings->pa_servername);
|
|
#endif
|
|
|
|
#ifdef ENABLE_COMMON_SSH
|
|
guac_common_ssh_init(client);
|
|
|
|
/* Connect via SSH if SFTP is enabled */
|
|
if (settings->enable_sftp) {
|
|
|
|
/* Abort if username is missing */
|
|
if (settings->sftp_username == NULL) {
|
|
guac_client_abort(client, GUAC_PROTOCOL_STATUS_SERVER_ERROR,
|
|
"SFTP username is required if SFTP is enabled.");
|
|
return NULL;
|
|
}
|
|
|
|
guac_client_log(client, GUAC_LOG_DEBUG,
|
|
"Connecting via SSH for SFTP filesystem access.");
|
|
|
|
vnc_client->sftp_user =
|
|
guac_common_ssh_create_user(settings->sftp_username);
|
|
|
|
/* Import private key, if given */
|
|
if (settings->sftp_private_key != NULL) {
|
|
|
|
guac_client_log(client, GUAC_LOG_DEBUG,
|
|
"Authenticating with private key.");
|
|
|
|
/* Abort if private key cannot be read */
|
|
if (guac_common_ssh_user_import_key(vnc_client->sftp_user,
|
|
settings->sftp_private_key,
|
|
settings->sftp_passphrase)) {
|
|
guac_client_abort(client, GUAC_PROTOCOL_STATUS_SERVER_ERROR,
|
|
"Private key unreadable.");
|
|
return NULL;
|
|
}
|
|
|
|
}
|
|
|
|
/* Otherwise, use specified password */
|
|
else {
|
|
guac_client_log(client, GUAC_LOG_DEBUG,
|
|
"Authenticating with password.");
|
|
guac_common_ssh_user_set_password(vnc_client->sftp_user,
|
|
settings->sftp_password);
|
|
}
|
|
|
|
/* Attempt SSH connection */
|
|
vnc_client->sftp_session =
|
|
guac_common_ssh_create_session(client, settings->sftp_hostname,
|
|
settings->sftp_port, vnc_client->sftp_user, settings->sftp_server_alive_interval,
|
|
settings->sftp_host_key);
|
|
|
|
/* Fail if SSH connection does not succeed */
|
|
if (vnc_client->sftp_session == NULL) {
|
|
/* Already aborted within guac_common_ssh_create_session() */
|
|
return NULL;
|
|
}
|
|
|
|
/* Load filesystem */
|
|
vnc_client->sftp_filesystem =
|
|
guac_common_ssh_create_sftp_filesystem(vnc_client->sftp_session,
|
|
settings->sftp_root_directory, NULL);
|
|
|
|
/* Expose filesystem to connection owner */
|
|
guac_client_for_owner(client,
|
|
guac_common_ssh_expose_sftp_filesystem,
|
|
vnc_client->sftp_filesystem);
|
|
|
|
/* Abort if SFTP connection fails */
|
|
if (vnc_client->sftp_filesystem == NULL) {
|
|
guac_client_abort(client, GUAC_PROTOCOL_STATUS_UPSTREAM_ERROR,
|
|
"SFTP connection failed.");
|
|
return NULL;
|
|
}
|
|
|
|
/* Configure destination for basic uploads, if specified */
|
|
if (settings->sftp_directory != NULL)
|
|
guac_common_ssh_sftp_set_upload_path(
|
|
vnc_client->sftp_filesystem,
|
|
settings->sftp_directory);
|
|
|
|
guac_client_log(client, GUAC_LOG_DEBUG,
|
|
"SFTP connection succeeded.");
|
|
|
|
}
|
|
#endif
|
|
|
|
/* Set remaining client data */
|
|
vnc_client->rfb_client = rfb_client;
|
|
|
|
/* Set up screen recording, if requested */
|
|
if (settings->recording_path != NULL) {
|
|
vnc_client->recording = guac_common_recording_create(client,
|
|
settings->recording_path,
|
|
settings->recording_name,
|
|
settings->create_recording_path,
|
|
!settings->recording_exclude_output,
|
|
!settings->recording_exclude_mouse,
|
|
settings->recording_include_keys);
|
|
}
|
|
|
|
/* Create display */
|
|
vnc_client->display = guac_common_display_alloc(client,
|
|
rfb_client->width, rfb_client->height);
|
|
|
|
/* If not read-only, set an appropriate cursor */
|
|
if (settings->read_only == 0) {
|
|
if (settings->remote_cursor)
|
|
guac_common_cursor_set_dot(vnc_client->display->cursor);
|
|
else
|
|
guac_common_cursor_set_pointer(vnc_client->display->cursor);
|
|
|
|
}
|
|
|
|
guac_socket_flush(client->socket);
|
|
|
|
guac_timestamp last_frame_end = guac_timestamp_current();
|
|
|
|
/* Handle messages from VNC server while client is running */
|
|
while (client->state == GUAC_CLIENT_RUNNING) {
|
|
|
|
/* Wait for start of frame */
|
|
int wait_result = guac_vnc_wait_for_messages(rfb_client,
|
|
GUAC_VNC_FRAME_START_TIMEOUT);
|
|
if (wait_result > 0) {
|
|
|
|
int processing_lag = guac_client_get_processing_lag(client);
|
|
guac_timestamp frame_start = guac_timestamp_current();
|
|
|
|
/* Read server messages until frame is built */
|
|
do {
|
|
|
|
guac_timestamp frame_end;
|
|
int frame_remaining;
|
|
|
|
/* Handle any message received */
|
|
if (!HandleRFBServerMessage(rfb_client)) {
|
|
guac_client_abort(client,
|
|
GUAC_PROTOCOL_STATUS_UPSTREAM_ERROR,
|
|
"Error handling message from VNC server.");
|
|
break;
|
|
}
|
|
|
|
/* Calculate time remaining in frame */
|
|
frame_end = guac_timestamp_current();
|
|
frame_remaining = frame_start + GUAC_VNC_FRAME_DURATION
|
|
- frame_end;
|
|
|
|
/* Calculate time that client needs to catch up */
|
|
int time_elapsed = frame_end - last_frame_end;
|
|
int required_wait = processing_lag - time_elapsed;
|
|
|
|
/* Increase the duration of this frame if client is lagging */
|
|
if (required_wait > GUAC_VNC_FRAME_TIMEOUT)
|
|
wait_result = guac_vnc_wait_for_messages(rfb_client,
|
|
required_wait*1000);
|
|
|
|
/* Wait again if frame remaining */
|
|
else if (frame_remaining > 0)
|
|
wait_result = guac_vnc_wait_for_messages(rfb_client,
|
|
GUAC_VNC_FRAME_TIMEOUT*1000);
|
|
else
|
|
break;
|
|
|
|
} while (wait_result > 0);
|
|
|
|
/* Record end of frame, excluding server-side rendering time (we
|
|
* assume server-side rendering time will be consistent between any
|
|
* two subsequent frames, and that this time should thus be
|
|
* excluded from the required wait period of the next frame). */
|
|
last_frame_end = frame_start;
|
|
|
|
}
|
|
|
|
/* If an error occurs, log it and fail */
|
|
if (wait_result < 0)
|
|
guac_client_abort(client, GUAC_PROTOCOL_STATUS_UPSTREAM_ERROR, "Connection closed.");
|
|
|
|
/* Flush frame */
|
|
guac_common_surface_flush(vnc_client->display->default_surface);
|
|
guac_client_end_frame(client);
|
|
guac_socket_flush(client->socket);
|
|
|
|
}
|
|
|
|
/* Kill client and finish connection */
|
|
guac_client_stop(client);
|
|
guac_client_log(client, GUAC_LOG_INFO, "Internal VNC client disconnected");
|
|
return NULL;
|
|
|
|
}
|
|
|