| /* |
| * 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 "common/clipboard.h" |
| #include "common/cursor.h" |
| #include "terminal/buffer.h" |
| #include "terminal/color-scheme.h" |
| #include "terminal/common.h" |
| #include "terminal/display.h" |
| #include "terminal/palette.h" |
| #include "terminal/select.h" |
| #include "terminal/terminal.h" |
| #include "terminal/terminal_handlers.h" |
| #include "terminal/types.h" |
| #include "terminal/typescript.h" |
| |
| #include <ctype.h> |
| #include <errno.h> |
| #include <pthread.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/time.h> |
| #include <unistd.h> |
| #include <wchar.h> |
| |
| #include <guacamole/client.h> |
| #include <guacamole/error.h> |
| #include <guacamole/protocol.h> |
| #include <guacamole/socket.h> |
| #include <guacamole/timestamp.h> |
| |
| /** |
| * Sets the given range of columns to the given character. |
| */ |
| static void __guac_terminal_set_columns(guac_terminal* terminal, int row, |
| int start_column, int end_column, guac_terminal_char* character) { |
| |
| guac_terminal_display_set_columns(terminal->display, row + terminal->scroll_offset, |
| start_column, end_column, character); |
| |
| guac_terminal_buffer_set_columns(terminal->buffer, row, |
| start_column, end_column, character); |
| |
| /* Clear selection if region is modified */ |
| guac_terminal_select_touch(terminal, row, start_column, row, end_column); |
| |
| } |
| |
| /** |
| * Enforces a character break at the given edge, ensuring that the left side |
| * of the edge is the final column of a character, and the right side of the |
| * edge is the initial column of a DIFFERENT character. |
| * |
| * For a character in a column N, the left edge number is N, and the right |
| * edge is N+1. |
| */ |
| static void __guac_terminal_force_break(guac_terminal* terminal, int row, int edge) { |
| |
| guac_terminal_buffer_row* buffer_row = guac_terminal_buffer_get_row(terminal->buffer, row, 0); |
| |
| /* Ensure character to left of edge is unbroken */ |
| if (edge > 0) { |
| |
| int end_column = edge - 1; |
| int start_column = end_column; |
| |
| guac_terminal_char* start_char = &(buffer_row->characters[start_column]); |
| |
| /* Determine start column */ |
| while (start_column > 0 && start_char->value == GUAC_CHAR_CONTINUATION) { |
| start_char--; |
| start_column--; |
| } |
| |
| /* Advance to start of broken character if necessary */ |
| if (start_char->value != GUAC_CHAR_CONTINUATION && start_char->width < end_column - start_column + 1) { |
| start_column += start_char->width; |
| start_char += start_char->width; |
| } |
| |
| /* Clear character if broken */ |
| if (start_char->value == GUAC_CHAR_CONTINUATION || start_char->width != end_column - start_column + 1) { |
| |
| guac_terminal_char cleared_char; |
| cleared_char.value = ' '; |
| cleared_char.attributes = start_char->attributes; |
| cleared_char.width = 1; |
| |
| __guac_terminal_set_columns(terminal, row, start_column, end_column, &cleared_char); |
| |
| } |
| |
| } |
| |
| /* Ensure character to right of edge is unbroken */ |
| if (edge >= 0 && edge < buffer_row->length) { |
| |
| int start_column = edge; |
| int end_column = start_column; |
| |
| guac_terminal_char* start_char = &(buffer_row->characters[start_column]); |
| guac_terminal_char* end_char = &(buffer_row->characters[end_column]); |
| |
| /* Determine end column */ |
| while (end_column+1 < buffer_row->length && (end_char+1)->value == GUAC_CHAR_CONTINUATION) { |
| end_char++; |
| end_column++; |
| } |
| |
| /* Advance to start of broken character if necessary */ |
| if (start_char->value != GUAC_CHAR_CONTINUATION && start_char->width < end_column - start_column + 1) { |
| start_column += start_char->width; |
| start_char += start_char->width; |
| } |
| |
| /* Clear character if broken */ |
| if (start_char->value == GUAC_CHAR_CONTINUATION || start_char->width != end_column - start_column + 1) { |
| |
| guac_terminal_char cleared_char; |
| cleared_char.value = ' '; |
| cleared_char.attributes = start_char->attributes; |
| cleared_char.width = 1; |
| |
| __guac_terminal_set_columns(terminal, row, start_column, end_column, &cleared_char); |
| |
| } |
| |
| } |
| |
| } |
| |
| /** |
| * Returns the number of rows available within the terminal buffer, taking |
| * changes to the desired scrollback size into account. Regardless of the |
| * true buffer length, only the number of rows that should be made available |
| * will be returned. |
| * |
| * @param term |
| * The terminal whose effective buffer length should be retrieved. |
| * |
| * @return |
| * The number of rows effectively available within the terminal buffer, |
| * taking changes to the desired scrollback size into account. |
| */ |
| static int guac_terminal_effective_buffer_length(guac_terminal* term) { |
| |
| int scrollback = term->requested_scrollback; |
| |
| /* Limit available scrollback to defined maximum */ |
| if (scrollback > term->max_scrollback) |
| scrollback = term->max_scrollback; |
| |
| /* There must always be at least enough scrollback to cover the visible |
| * terminal display */ |
| else if (scrollback < term->term_height) |
| scrollback = term->term_height; |
| |
| /* If the buffer contains more rows than requested, pretend it only |
| * contains the requested number of rows */ |
| int effective_length = term->buffer->length; |
| if (effective_length > scrollback) |
| effective_length = scrollback; |
| |
| return effective_length; |
| |
| } |
| |
| int guac_terminal_available_scroll(guac_terminal* term) { |
| return guac_terminal_effective_buffer_length(term) - term->term_height; |
| } |
| |
| void guac_terminal_reset(guac_terminal* term) { |
| |
| int row; |
| |
| /* Set current state */ |
| term->char_handler = guac_terminal_echo; |
| term->active_char_set = 0; |
| term->char_mapping[0] = |
| term->char_mapping[1] = NULL; |
| |
| /* Reset cursor location */ |
| term->cursor_row = term->visible_cursor_row = term->saved_cursor_row = 0; |
| term->cursor_col = term->visible_cursor_col = term->saved_cursor_col = 0; |
| |
| /* Clear scrollback, buffer, and scroll region */ |
| term->buffer->top = 0; |
| term->buffer->length = 0; |
| term->scroll_start = 0; |
| term->scroll_end = term->term_height - 1; |
| term->scroll_offset = 0; |
| |
| /* Reset scrollbar bounds */ |
| guac_terminal_scrollbar_set_bounds(term->scrollbar, 0, 0); |
| guac_terminal_scrollbar_set_value(term->scrollbar, -term->scroll_offset); |
| |
| /* Reset flags */ |
| term->text_selected = false; |
| term->selection_committed = false; |
| term->application_cursor_keys = false; |
| term->automatic_carriage_return = false; |
| term->insert_mode = false; |
| |
| /* Reset tabs */ |
| term->tab_interval = 8; |
| memset(term->custom_tabs, 0, sizeof(term->custom_tabs)); |
| |
| /* Reset character attributes */ |
| term->current_attributes = term->default_char.attributes; |
| |
| /* Reset display palette */ |
| guac_terminal_display_reset_palette(term->display); |
| |
| /* Clear terminal */ |
| for (row=0; row<term->term_height; row++) |
| guac_terminal_set_columns(term, row, 0, term->term_width, &(term->default_char)); |
| |
| } |
| |
| /** |
| * Paints or repaints the background of the terminal display. This painting |
| * occurs beneath the actual terminal and scrollbar layers, and thus will not |
| * overwrite any text or other content currently on the screen. This is only |
| * necessary to paint over parts of the terminal background which may otherwise |
| * be transparent (the default layer background). |
| * |
| * @param terminal |
| * The terminal whose background should be painted or repainted. |
| * |
| * @param socket |
| * The socket over which instructions required to paint / repaint the |
| * terminal background should be send. |
| */ |
| static void guac_terminal_repaint_default_layer(guac_terminal* terminal, |
| guac_socket* socket) { |
| |
| int width = terminal->width; |
| int height = terminal->height; |
| guac_terminal_display* display = terminal->display; |
| |
| /* Get background color */ |
| const guac_terminal_color* color = &display->default_background; |
| |
| /* Reset size */ |
| guac_protocol_send_size(socket, GUAC_DEFAULT_LAYER, width, height); |
| |
| /* Paint background color */ |
| guac_protocol_send_rect(socket, GUAC_DEFAULT_LAYER, 0, 0, width, height); |
| guac_protocol_send_cfill(socket, GUAC_COMP_OVER, GUAC_DEFAULT_LAYER, |
| color->red, color->green, color->blue, 0xFF); |
| |
| } |
| |
| /** |
| * Automatically and continuously renders frames of terminal data while the |
| * associated guac_client is running. |
| * |
| * @param data |
| * A pointer to the guac_terminal that should be continuously rendered |
| * while its associated guac_client is running. |
| * |
| * @return |
| * Always NULL. |
| */ |
| void* guac_terminal_thread(void* data) { |
| |
| guac_terminal* terminal = (guac_terminal*) data; |
| guac_client* client = terminal->client; |
| |
| /* Render frames only while client is running */ |
| while (client->state == GUAC_CLIENT_RUNNING) { |
| |
| /* Stop rendering if an error occurs */ |
| if (guac_terminal_render_frame(terminal)) |
| break; |
| |
| /* Signal end of frame */ |
| guac_client_end_frame(client); |
| guac_socket_flush(client->socket); |
| |
| } |
| |
| /* The client has stopped or an error has occurred */ |
| return NULL; |
| |
| } |
| |
| guac_terminal* guac_terminal_create(guac_client* client, |
| guac_common_clipboard* clipboard, bool disable_copy, |
| int max_scrollback, const char* font_name, int font_size, int dpi, |
| int width, int height, const char* color_scheme, |
| const int backspace) { |
| |
| /* Build default character using default colors */ |
| guac_terminal_char default_char = { |
| .value = 0, |
| .attributes = { |
| .bold = false, |
| .half_bright = false, |
| .reverse = false, |
| .underscore = false |
| }, |
| .width = 1 |
| }; |
| |
| /* Initialized by guac_terminal_parse_color_scheme. */ |
| guac_terminal_color (*default_palette)[256] = (guac_terminal_color(*)[256]) |
| malloc(sizeof(guac_terminal_color[256])); |
| |
| guac_terminal_parse_color_scheme(client, color_scheme, |
| &default_char.attributes.foreground, |
| &default_char.attributes.background, |
| default_palette); |
| |
| /* Calculate available display area */ |
| int available_width = width - GUAC_TERMINAL_SCROLLBAR_WIDTH; |
| if (available_width < 0) |
| available_width = 0; |
| |
| guac_terminal* term = malloc(sizeof(guac_terminal)); |
| term->started = false; |
| term->client = client; |
| term->upload_path_handler = NULL; |
| term->file_download_handler = NULL; |
| |
| /* Copy initially-provided color scheme and font details */ |
| term->color_scheme = strdup(color_scheme); |
| term->font_name = strdup(font_name); |
| term->font_size = font_size; |
| |
| /* Set size of available screen area */ |
| term->outer_width = width; |
| term->outer_height = height; |
| |
| /* Init modified flag and conditional */ |
| term->modified = 0; |
| pthread_cond_init(&(term->modified_cond), NULL); |
| pthread_mutex_init(&(term->modified_lock), NULL); |
| |
| /* Maximum and requested scrollback are initially the same */ |
| term->max_scrollback = max_scrollback; |
| term->requested_scrollback = max_scrollback; |
| |
| /* Allocate enough space for maximum scrollback, bumping up internal |
| * storage as necessary to allow screen to be resized to maximum height */ |
| int initial_scrollback = max_scrollback; |
| if (initial_scrollback < GUAC_TERMINAL_MAX_ROWS) |
| initial_scrollback = GUAC_TERMINAL_MAX_ROWS; |
| |
| /* Init buffer */ |
| term->buffer = guac_terminal_buffer_alloc(initial_scrollback, |
| &default_char); |
| |
| /* Init display */ |
| term->display = guac_terminal_display_alloc(client, |
| font_name, font_size, dpi, |
| &default_char.attributes.foreground, |
| &default_char.attributes.background, |
| (guac_terminal_color(*)[256]) default_palette); |
| |
| /* Fail if display init failed */ |
| if (term->display == NULL) { |
| guac_client_log(client, GUAC_LOG_DEBUG, "Display initialization failed"); |
| free(term); |
| return NULL; |
| } |
| |
| /* Init common cursor */ |
| term->cursor = guac_common_cursor_alloc(client); |
| |
| /* Init terminal state */ |
| term->current_attributes = default_char.attributes; |
| term->default_char = default_char; |
| term->clipboard = clipboard; |
| term->disable_copy = disable_copy; |
| |
| /* Calculate character size */ |
| int rows = height / term->display->char_height; |
| int columns = available_width / term->display->char_width; |
| |
| /* Keep height within predefined maximum */ |
| if (rows > GUAC_TERMINAL_MAX_ROWS) { |
| rows = GUAC_TERMINAL_MAX_ROWS; |
| height = rows * term->display->char_height; |
| } |
| |
| /* Keep width within predefined maximum */ |
| if (columns > GUAC_TERMINAL_MAX_COLUMNS) { |
| columns = GUAC_TERMINAL_MAX_COLUMNS; |
| available_width = columns * term->display->char_width; |
| width = available_width + GUAC_TERMINAL_SCROLLBAR_WIDTH; |
| } |
| |
| /* Set pixel size */ |
| term->width = width; |
| term->height = height; |
| |
| term->term_width = columns; |
| term->term_height = rows; |
| |
| /* Open STDIN pipe */ |
| if (pipe(term->stdin_pipe_fd)) { |
| guac_error = GUAC_STATUS_SEE_ERRNO; |
| guac_error_message = "Unable to open pipe for STDIN"; |
| free(term); |
| return NULL; |
| } |
| |
| /* Read input from keyboard by default */ |
| term->input_stream = NULL; |
| |
| /* Init pipe stream (output to display by default) */ |
| term->pipe_stream = NULL; |
| |
| /* No typescript by default */ |
| term->typescript = NULL; |
| |
| /* Init terminal lock */ |
| pthread_mutex_init(&(term->lock), NULL); |
| |
| /* Repaint and resize overall display */ |
| guac_terminal_repaint_default_layer(term, client->socket); |
| guac_terminal_display_resize(term->display, |
| term->term_width, term->term_height); |
| |
| /* Allocate scrollbar */ |
| term->scrollbar = guac_terminal_scrollbar_alloc(client, GUAC_DEFAULT_LAYER, |
| width, height, term->term_height); |
| |
| /* Associate scrollbar with this terminal */ |
| term->scrollbar->data = term; |
| term->scrollbar->scroll_handler = guac_terminal_scroll_handler; |
| |
| /* Init terminal */ |
| guac_terminal_reset(term); |
| |
| term->mod_alt = |
| term->mod_ctrl = |
| term->mod_shift = 0; |
| |
| /* Initialize mouse cursor */ |
| term->current_cursor = GUAC_TERMINAL_CURSOR_BLANK; |
| guac_common_cursor_set_blank(term->cursor); |
| |
| /* Start terminal thread */ |
| if (pthread_create(&(term->thread), NULL, |
| guac_terminal_thread, (void*) term)) { |
| guac_terminal_free(term); |
| return NULL; |
| } |
| |
| /* Configure backspace */ |
| term->backspace = backspace; |
| |
| return term; |
| |
| } |
| |
| void guac_terminal_start(guac_terminal* term) { |
| term->started = true; |
| guac_terminal_notify(term); |
| } |
| |
| void guac_terminal_stop(guac_terminal* term) { |
| |
| /* Close input pipe and set fds to invalid */ |
| if (term->stdin_pipe_fd[1] != -1) { |
| close(term->stdin_pipe_fd[1]); |
| term->stdin_pipe_fd[1] = -1; |
| } |
| if (term->stdin_pipe_fd[0] != -1) { |
| close(term->stdin_pipe_fd[0]); |
| term->stdin_pipe_fd[0] = -1; |
| } |
| } |
| |
| void guac_terminal_free(guac_terminal* term) { |
| |
| /* Close user input pipe */ |
| guac_terminal_stop(term); |
| |
| /* Wait for render thread to finish */ |
| pthread_join(term->thread, NULL); |
| |
| /* Close and flush any open pipe stream */ |
| guac_terminal_pipe_stream_close(term); |
| |
| /* Close and flush any active typescript */ |
| guac_terminal_typescript_free(term->typescript); |
| |
| /* Free display */ |
| guac_terminal_display_free(term->display); |
| |
| /* Free buffer */ |
| guac_terminal_buffer_free(term->buffer); |
| |
| /* Free scrollbar */ |
| guac_terminal_scrollbar_free(term->scrollbar); |
| |
| /* Free copies of font and color scheme information */ |
| free((char*) term->color_scheme); |
| free((char*) term->font_name); |
| |
| /* Free the terminal itself */ |
| free(term); |
| |
| } |
| |
| /** |
| * Populate the given timespec with the current time, plus the given offset. |
| * |
| * @param ts |
| * The timespec structure to populate. |
| * |
| * @param offset_sec |
| * The offset from the current time to use when populating the given |
| * timespec, in seconds. |
| * |
| * @param offset_usec |
| * The offset from the current time to use when populating the given |
| * timespec, in microseconds. |
| */ |
| static void guac_terminal_get_absolute_time(struct timespec* ts, |
| int offset_sec, int offset_usec) { |
| |
| /* Get timeval */ |
| struct timeval tv; |
| gettimeofday(&tv, NULL); |
| |
| /* Update with offset */ |
| tv.tv_sec += offset_sec; |
| tv.tv_usec += offset_usec; |
| |
| /* Wrap to next second if necessary */ |
| if (tv.tv_usec >= 1000000) { |
| tv.tv_sec++; |
| tv.tv_usec -= 1000000; |
| } |
| |
| /* Convert to timespec */ |
| ts->tv_sec = tv.tv_sec; |
| ts->tv_nsec = tv.tv_usec * 1000; |
| |
| } |
| |
| /** |
| * Waits for the terminal state to be modified, returning only when the |
| * specified timeout has elapsed or a frame flush is desired. Note that the |
| * modified flag of the terminal will only be reset if no data remains to be |
| * read from STDOUT. |
| * |
| * @param terminal |
| * The terminal to wait on. |
| * |
| * @param msec_timeout |
| * The maximum amount of time to wait, in milliseconds. |
| * |
| * @return |
| * Non-zero if the terminal has been modified, zero if the timeout has |
| * elapsed without the terminal being modified. |
| */ |
| static int guac_terminal_wait(guac_terminal* terminal, int msec_timeout) { |
| |
| int retval = 1; |
| |
| pthread_mutex_t* mod_lock = &(terminal->modified_lock); |
| pthread_cond_t* mod_cond = &(terminal->modified_cond); |
| |
| /* Split provided milliseconds into microseconds and whole seconds */ |
| int secs = msec_timeout / 1000; |
| int usecs = (msec_timeout % 1000) * 1000; |
| |
| /* Calculate absolute timestamp from provided relative timeout */ |
| struct timespec timeout; |
| guac_terminal_get_absolute_time(&timeout, secs, usecs); |
| |
| /* Test for terminal modification */ |
| pthread_mutex_lock(mod_lock); |
| if (terminal->modified) |
| goto wait_complete; |
| |
| /* If not yet modified, wait for modification condition to be signaled */ |
| retval = pthread_cond_timedwait(mod_cond, mod_lock, &timeout) != ETIMEDOUT; |
| |
| wait_complete: |
| |
| /* Terminal is no longer modified */ |
| terminal->modified = 0; |
| pthread_mutex_unlock(mod_lock); |
| return retval; |
| |
| } |
| |
| int guac_terminal_render_frame(guac_terminal* terminal) { |
| |
| guac_client* client = terminal->client; |
| |
| int wait_result; |
| |
| /* Wait for data to be available */ |
| wait_result = guac_terminal_wait(terminal, 1000); |
| if (wait_result || !terminal->started) { |
| |
| guac_timestamp frame_start = guac_timestamp_current(); |
| |
| do { |
| |
| /* Calculate time remaining in frame */ |
| guac_timestamp frame_end = guac_timestamp_current(); |
| int frame_remaining = frame_start + GUAC_TERMINAL_FRAME_DURATION |
| - frame_end; |
| |
| /* Wait again if frame remaining */ |
| if (frame_remaining > 0 || !terminal->started) |
| wait_result = guac_terminal_wait(terminal, |
| GUAC_TERMINAL_FRAME_TIMEOUT); |
| else |
| break; |
| |
| } while (client->state == GUAC_CLIENT_RUNNING |
| && (wait_result > 0 || !terminal->started)); |
| |
| /* Flush terminal */ |
| guac_terminal_lock(terminal); |
| guac_terminal_flush(terminal); |
| guac_terminal_unlock(terminal); |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| int guac_terminal_read_stdin(guac_terminal* terminal, char* c, int size) { |
| int stdin_fd = terminal->stdin_pipe_fd[0]; |
| return read(stdin_fd, c, size); |
| } |
| |
| void guac_terminal_notify(guac_terminal* terminal) { |
| |
| pthread_mutex_t* mod_lock = &(terminal->modified_lock); |
| pthread_cond_t* mod_cond = &(terminal->modified_cond); |
| |
| pthread_mutex_lock(mod_lock); |
| |
| /* Signal modification */ |
| terminal->modified = 1; |
| pthread_cond_signal(mod_cond); |
| |
| pthread_mutex_unlock(mod_lock); |
| |
| } |
| |
| int guac_terminal_printf(guac_terminal* terminal, const char* format, ...) { |
| |
| int written; |
| |
| va_list ap; |
| char buffer[1024]; |
| |
| /* Print to buffer */ |
| va_start(ap, format); |
| written = vsnprintf(buffer, sizeof(buffer)-1, format, ap); |
| va_end(ap); |
| |
| if (written < 0) |
| return written; |
| |
| /* Write to STDOUT */ |
| return guac_terminal_write(terminal, buffer, written); |
| |
| } |
| |
| char* guac_terminal_prompt(guac_terminal* terminal, const char* title, |
| bool echo) { |
| |
| char buffer[1024]; |
| |
| int pos; |
| char in_byte; |
| |
| /* Prompting implicitly requires user input */ |
| guac_terminal_start(terminal); |
| |
| /* Print title */ |
| guac_terminal_printf(terminal, "%s", title); |
| |
| /* Read bytes until newline */ |
| pos = 0; |
| while (guac_terminal_read_stdin(terminal, &in_byte, 1) == 1) { |
| |
| /* Backspace */ |
| if (in_byte == 0x7F) { |
| if (pos > 0) { |
| guac_terminal_printf(terminal, "\b \b"); |
| pos--; |
| } |
| } |
| |
| /* CR (end of input */ |
| else if (in_byte == 0x0D) { |
| guac_terminal_printf(terminal, "\r\n"); |
| break; |
| } |
| |
| /* Otherwise, store byte if there is room */ |
| else if (pos < sizeof(buffer) - 1) { |
| |
| /* Store character, update buffers */ |
| buffer[pos++] = in_byte; |
| |
| /* Print character if echoing */ |
| if (echo) |
| guac_terminal_printf(terminal, "%c", in_byte); |
| else |
| guac_terminal_printf(terminal, "*"); |
| |
| } |
| |
| /* Ignore all other input */ |
| |
| } |
| |
| /* Terminate string */ |
| buffer[pos] = 0; |
| |
| /* Return newly-allocated string containing result */ |
| return strdup(buffer); |
| |
| } |
| |
| int guac_terminal_set(guac_terminal* term, int row, int col, int codepoint) { |
| |
| /* Calculate width in columns */ |
| int width = wcwidth(codepoint); |
| if (width < 0) |
| width = 1; |
| |
| /* Do nothing if glyph is empty */ |
| else if (width == 0) |
| return 0; |
| |
| /* Build character with current attributes */ |
| guac_terminal_char guac_char = { |
| .value = codepoint, |
| .attributes = term->current_attributes, |
| .width = width |
| }; |
| |
| guac_terminal_set_columns(term, row, col, col + width - 1, &guac_char); |
| |
| return 0; |
| |
| } |
| |
| void guac_terminal_commit_cursor(guac_terminal* term) { |
| |
| guac_terminal_char* guac_char; |
| |
| guac_terminal_buffer_row* old_row; |
| guac_terminal_buffer_row* new_row; |
| |
| /* If no change, done */ |
| if (term->visible_cursor_row == term->cursor_row && term->visible_cursor_col == term->cursor_col) |
| return; |
| |
| /* Get old and new rows with cursor */ |
| new_row = guac_terminal_buffer_get_row(term->buffer, term->cursor_row, term->cursor_col+1); |
| old_row = guac_terminal_buffer_get_row(term->buffer, term->visible_cursor_row, term->visible_cursor_col+1); |
| |
| /* Clear cursor */ |
| guac_char = &(old_row->characters[term->visible_cursor_col]); |
| guac_char->attributes.cursor = false; |
| guac_terminal_display_set_columns(term->display, term->visible_cursor_row + term->scroll_offset, |
| term->visible_cursor_col, term->visible_cursor_col, guac_char); |
| |
| /* Set cursor */ |
| guac_char = &(new_row->characters[term->cursor_col]); |
| guac_char->attributes.cursor = true; |
| guac_terminal_display_set_columns(term->display, term->cursor_row + term->scroll_offset, |
| term->cursor_col, term->cursor_col, guac_char); |
| |
| term->visible_cursor_row = term->cursor_row; |
| term->visible_cursor_col = term->cursor_col; |
| |
| return; |
| |
| } |
| |
| int guac_terminal_write(guac_terminal* term, const char* c, int size) { |
| |
| guac_terminal_lock(term); |
| while (size > 0) { |
| |
| /* Read and advance to next character */ |
| char current = *(c++); |
| size--; |
| |
| /* Write character to typescript, if any */ |
| if (term->typescript != NULL) |
| guac_terminal_typescript_write(term->typescript, current); |
| |
| /* Handle character and its meaning */ |
| term->char_handler(term, current); |
| |
| } |
| guac_terminal_unlock(term); |
| |
| guac_terminal_notify(term); |
| return 0; |
| |
| } |
| |
| int guac_terminal_scroll_up(guac_terminal* term, |
| int start_row, int end_row, int amount) { |
| |
| /* If scrolling entire display, update scroll offset */ |
| if (start_row == 0 && end_row == term->term_height - 1) { |
| |
| /* Scroll up visibly */ |
| guac_terminal_display_copy_rows(term->display, start_row + amount, end_row, -amount); |
| |
| /* Advance by scroll amount */ |
| term->buffer->top += amount; |
| if (term->buffer->top >= term->buffer->available) |
| term->buffer->top -= term->buffer->available; |
| |
| term->buffer->length += amount; |
| if (term->buffer->length > term->buffer->available) |
| term->buffer->length = term->buffer->available; |
| |
| /* Reset scrollbar bounds */ |
| guac_terminal_scrollbar_set_bounds(term->scrollbar, |
| -guac_terminal_available_scroll(term), 0); |
| |
| /* Update cursor location if within region */ |
| if (term->visible_cursor_row >= start_row && |
| term->visible_cursor_row <= end_row) |
| term->visible_cursor_row -= amount; |
| |
| /* Update selected region */ |
| if (term->text_selected) { |
| term->selection_start_row -= amount; |
| term->selection_end_row -= amount; |
| } |
| |
| } |
| |
| /* Otherwise, just copy row data upwards */ |
| else |
| guac_terminal_copy_rows(term, start_row + amount, end_row, -amount); |
| |
| /* Clear new area */ |
| guac_terminal_clear_range(term, |
| end_row - amount + 1, 0, |
| end_row, term->term_width - 1); |
| |
| return 0; |
| } |
| |
| int guac_terminal_scroll_down(guac_terminal* term, |
| int start_row, int end_row, int amount) { |
| |
| guac_terminal_copy_rows(term, start_row, end_row - amount, amount); |
| |
| /* Clear new area */ |
| guac_terminal_clear_range(term, |
| start_row, 0, |
| start_row + amount - 1, term->term_width - 1); |
| |
| return 0; |
| } |
| |
| int guac_terminal_clear_columns(guac_terminal* term, |
| int row, int start_col, int end_col) { |
| |
| /* Build space */ |
| guac_terminal_char blank; |
| blank.value = 0; |
| blank.attributes = term->current_attributes; |
| blank.width = 1; |
| |
| /* Clear */ |
| guac_terminal_set_columns(term, |
| row, start_col, end_col, &blank); |
| |
| return 0; |
| |
| } |
| |
| int guac_terminal_clear_range(guac_terminal* term, |
| int start_row, int start_col, |
| int end_row, int end_col) { |
| |
| /* If not at far left, must clear sub-region to far right */ |
| if (start_col > 0) { |
| |
| /* Clear from start_col to far right */ |
| guac_terminal_clear_columns(term, |
| start_row, start_col, term->term_width - 1); |
| |
| /* One less row to clear */ |
| start_row++; |
| } |
| |
| /* If not at far right, must clear sub-region to far left */ |
| if (end_col < term->term_width - 1) { |
| |
| /* Clear from far left to end_col */ |
| guac_terminal_clear_columns(term, end_row, 0, end_col); |
| |
| /* One less row to clear */ |
| end_row--; |
| |
| } |
| |
| /* Remaining region now guaranteed rectangular. Clear, if possible */ |
| if (start_row <= end_row) { |
| |
| int row; |
| for (row=start_row; row<=end_row; row++) { |
| |
| /* Clear entire row */ |
| guac_terminal_clear_columns(term, row, 0, term->term_width - 1); |
| |
| } |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| /** |
| * Returns whether the given character would be visible relative to the |
| * background of the given terminal. |
| * |
| * @param term |
| * The guac_terminal to test the character against. |
| * |
| * @param c |
| * The character being tested. |
| * |
| * @return |
| * true if the given character is different from the terminal background, |
| * false otherwise. |
| */ |
| static bool guac_terminal_is_visible(guac_terminal* term, |
| guac_terminal_char* c) { |
| |
| /* Continuation characters are NEVER visible */ |
| if (c->value == GUAC_CHAR_CONTINUATION) |
| return false; |
| |
| /* Characters with glyphs are ALWAYS visible */ |
| if (guac_terminal_has_glyph(c->value)) |
| return true; |
| |
| const guac_terminal_color* background; |
| |
| /* Determine actual background color of character */ |
| if (c->attributes.reverse != c->attributes.cursor) |
| background = &c->attributes.foreground; |
| else |
| background = &c->attributes.background; |
| |
| /* Blank characters are visible if their background color differs from that |
| * of the terminal */ |
| return guac_terminal_colorcmp(background, |
| &term->default_char.attributes.background) != 0; |
| |
| } |
| |
| void guac_terminal_scroll_display_down(guac_terminal* terminal, |
| int scroll_amount) { |
| |
| int start_row, end_row; |
| int dest_row; |
| int row, column; |
| |
| /* Limit scroll amount by size of scrollback buffer */ |
| if (scroll_amount > terminal->scroll_offset) |
| scroll_amount = terminal->scroll_offset; |
| |
| /* If not scrolling at all, don't bother trying */ |
| if (scroll_amount <= 0) |
| return; |
| |
| /* Shift screen up */ |
| if (terminal->term_height > scroll_amount) |
| guac_terminal_display_copy_rows(terminal->display, |
| scroll_amount, terminal->term_height - 1, |
| -scroll_amount); |
| |
| /* Advance by scroll amount */ |
| terminal->scroll_offset -= scroll_amount; |
| guac_terminal_scrollbar_set_value(terminal->scrollbar, -terminal->scroll_offset); |
| |
| /* Get row range */ |
| end_row = terminal->term_height - terminal->scroll_offset - 1; |
| start_row = end_row - scroll_amount + 1; |
| dest_row = terminal->term_height - scroll_amount; |
| |
| /* Draw new rows from scrollback */ |
| for (row=start_row; row<=end_row; row++) { |
| |
| /* Get row from scrollback */ |
| guac_terminal_buffer_row* buffer_row = |
| guac_terminal_buffer_get_row(terminal->buffer, row, 0); |
| |
| /* Clear row */ |
| guac_terminal_display_set_columns(terminal->display, |
| dest_row, 0, terminal->display->width, &(terminal->default_char)); |
| |
| /* Draw row */ |
| guac_terminal_char* current = buffer_row->characters; |
| for (column=0; column<buffer_row->length; column++) { |
| |
| /* Only draw if not blank */ |
| if (guac_terminal_is_visible(terminal, current)) |
| guac_terminal_display_set_columns(terminal->display, dest_row, column, column, current); |
| |
| current++; |
| |
| } |
| |
| /* Next row */ |
| dest_row++; |
| |
| } |
| |
| guac_terminal_notify(terminal); |
| |
| } |
| |
| void guac_terminal_scroll_display_up(guac_terminal* terminal, |
| int scroll_amount) { |
| |
| int start_row, end_row; |
| int dest_row; |
| int row, column; |
| |
| /* Limit scroll amount by size of scrollback buffer */ |
| int available_scroll = guac_terminal_available_scroll(terminal); |
| if (terminal->scroll_offset + scroll_amount > available_scroll) |
| scroll_amount = available_scroll - terminal->scroll_offset; |
| |
| /* If not scrolling at all, don't bother trying */ |
| if (scroll_amount <= 0) |
| return; |
| |
| /* Shift screen down */ |
| if (terminal->term_height > scroll_amount) |
| guac_terminal_display_copy_rows(terminal->display, |
| 0, terminal->term_height - scroll_amount - 1, |
| scroll_amount); |
| |
| /* Advance by scroll amount */ |
| terminal->scroll_offset += scroll_amount; |
| guac_terminal_scrollbar_set_value(terminal->scrollbar, -terminal->scroll_offset); |
| |
| /* Get row range */ |
| start_row = -terminal->scroll_offset; |
| end_row = start_row + scroll_amount - 1; |
| dest_row = 0; |
| |
| /* Draw new rows from scrollback */ |
| for (row=start_row; row<=end_row; row++) { |
| |
| /* Get row from scrollback */ |
| guac_terminal_buffer_row* buffer_row = |
| guac_terminal_buffer_get_row(terminal->buffer, row, 0); |
| |
| /* Clear row */ |
| guac_terminal_display_set_columns(terminal->display, |
| dest_row, 0, terminal->display->width, &(terminal->default_char)); |
| |
| /* Draw row */ |
| guac_terminal_char* current = buffer_row->characters; |
| for (column=0; column<buffer_row->length; column++) { |
| |
| /* Only draw if not blank */ |
| if (guac_terminal_is_visible(terminal, current)) |
| guac_terminal_display_set_columns(terminal->display, dest_row, column, column, current); |
| |
| current++; |
| |
| } |
| |
| /* Next row */ |
| dest_row++; |
| |
| } |
| |
| guac_terminal_notify(terminal); |
| |
| } |
| |
| void guac_terminal_copy_columns(guac_terminal* terminal, int row, |
| int start_column, int end_column, int offset) { |
| |
| guac_terminal_display_copy_columns(terminal->display, row + terminal->scroll_offset, |
| start_column, end_column, offset); |
| |
| guac_terminal_buffer_copy_columns(terminal->buffer, row, |
| start_column, end_column, offset); |
| |
| /* Clear selection if region is modified */ |
| guac_terminal_select_touch(terminal, row, start_column, row, end_column); |
| |
| /* Update cursor location if within region */ |
| if (row == terminal->visible_cursor_row && |
| terminal->visible_cursor_col >= start_column && |
| terminal->visible_cursor_col <= end_column) |
| terminal->visible_cursor_col += offset; |
| |
| /* Force breaks around destination region */ |
| __guac_terminal_force_break(terminal, row, start_column + offset); |
| __guac_terminal_force_break(terminal, row, end_column + offset + 1); |
| |
| } |
| |
| void guac_terminal_copy_rows(guac_terminal* terminal, |
| int start_row, int end_row, int offset) { |
| |
| guac_terminal_display_copy_rows(terminal->display, |
| start_row + terminal->scroll_offset, end_row + terminal->scroll_offset, offset); |
| |
| guac_terminal_buffer_copy_rows(terminal->buffer, |
| start_row, end_row, offset); |
| |
| /* Clear selection if region is modified */ |
| guac_terminal_select_touch(terminal, start_row, 0, end_row, |
| terminal->term_width); |
| |
| /* Update cursor location if within region */ |
| if (terminal->visible_cursor_row >= start_row && |
| terminal->visible_cursor_row <= end_row) |
| terminal->visible_cursor_row += offset; |
| |
| } |
| |
| void guac_terminal_set_columns(guac_terminal* terminal, int row, |
| int start_column, int end_column, guac_terminal_char* character) { |
| |
| __guac_terminal_set_columns(terminal, row, start_column, end_column, character); |
| |
| /* If visible cursor in current row, preserve state */ |
| if (row == terminal->visible_cursor_row |
| && terminal->visible_cursor_col >= start_column |
| && terminal->visible_cursor_col <= end_column) { |
| |
| /* Create copy of character with cursor attribute set */ |
| guac_terminal_char cursor_character = *character; |
| cursor_character.attributes.cursor = true; |
| |
| __guac_terminal_set_columns(terminal, row, |
| terminal->visible_cursor_col, terminal->visible_cursor_col, &cursor_character); |
| |
| } |
| |
| /* Force breaks around destination region */ |
| __guac_terminal_force_break(terminal, row, start_column); |
| __guac_terminal_force_break(terminal, row, end_column + 1); |
| |
| } |
| |
| static void __guac_terminal_redraw_rect(guac_terminal* term, int start_row, int start_col, int end_row, int end_col) { |
| |
| int row, col; |
| |
| /* Redraw region */ |
| for (row=start_row; row<=end_row; row++) { |
| |
| guac_terminal_buffer_row* buffer_row = |
| guac_terminal_buffer_get_row(term->buffer, row - term->scroll_offset, 0); |
| |
| /* Clear row */ |
| guac_terminal_display_set_columns(term->display, |
| row, start_col, end_col, &(term->default_char)); |
| |
| /* Copy characters */ |
| for (col=start_col; col <= end_col && col < buffer_row->length; col++) { |
| |
| /* Only redraw if not blank */ |
| guac_terminal_char* c = &(buffer_row->characters[col]); |
| if (guac_terminal_is_visible(term, c)) |
| guac_terminal_display_set_columns(term->display, row, col, col, c); |
| |
| } |
| |
| } |
| |
| } |
| |
| /** |
| * Internal terminal resize routine. Accepts width/height in CHARACTERS |
| * (not pixels like the public function). |
| */ |
| static void __guac_terminal_resize(guac_terminal* term, int width, int height) { |
| |
| /* If height is decreasing, shift display up */ |
| if (height < term->term_height) { |
| |
| int shift_amount; |
| |
| /* Get number of rows actually occupying terminal space */ |
| int used_height = guac_terminal_effective_buffer_length(term); |
| if (used_height > term->term_height) |
| used_height = term->term_height; |
| |
| shift_amount = used_height - height; |
| |
| /* If the new terminal bottom covers N rows, shift up N rows */ |
| if (shift_amount > 0) { |
| |
| guac_terminal_display_copy_rows(term->display, |
| shift_amount, term->display->height - 1, -shift_amount); |
| |
| /* Update buffer top and cursor row based on shift */ |
| term->buffer->top += shift_amount; |
| term->cursor_row -= shift_amount; |
| term->visible_cursor_row -= shift_amount; |
| |
| /* Redraw characters within old region */ |
| __guac_terminal_redraw_rect(term, height - shift_amount, 0, height-1, width-1); |
| |
| } |
| |
| } |
| |
| /* Resize display */ |
| guac_terminal_display_flush(term->display); |
| guac_terminal_display_resize(term->display, width, height); |
| |
| /* Reraw any characters on right if widening */ |
| if (width > term->term_width) |
| __guac_terminal_redraw_rect(term, 0, term->term_width-1, height-1, width-1); |
| |
| /* If height is increasing, shift display down */ |
| if (height > term->term_height) { |
| |
| /* If undisplayed rows exist in the buffer, shift them into view */ |
| int available_scroll = guac_terminal_available_scroll(term); |
| if (available_scroll > 0) { |
| |
| /* If the new terminal bottom reveals N rows, shift down N rows */ |
| int shift_amount = height - term->term_height; |
| |
| /* The maximum amount we can shift is the number of undisplayed rows */ |
| if (shift_amount > available_scroll) |
| shift_amount = available_scroll; |
| |
| /* Update buffer top and cursor row based on shift */ |
| term->buffer->top -= shift_amount; |
| term->cursor_row += shift_amount; |
| term->visible_cursor_row += shift_amount; |
| |
| /* If scrolled enough, use scroll to fulfill entire resize */ |
| if (term->scroll_offset >= shift_amount) { |
| |
| term->scroll_offset -= shift_amount; |
| guac_terminal_scrollbar_set_value(term->scrollbar, -term->scroll_offset); |
| |
| /* Draw characters from scroll at bottom */ |
| __guac_terminal_redraw_rect(term, term->term_height, 0, term->term_height + shift_amount - 1, width-1); |
| |
| } |
| |
| /* Otherwise, fulfill with as much scroll as possible */ |
| else { |
| |
| /* Draw characters from scroll at bottom */ |
| __guac_terminal_redraw_rect(term, term->term_height, 0, term->term_height + term->scroll_offset - 1, width-1); |
| |
| /* Update shift_amount and scroll based on new rows */ |
| shift_amount -= term->scroll_offset; |
| term->scroll_offset = 0; |
| guac_terminal_scrollbar_set_value(term->scrollbar, -term->scroll_offset); |
| |
| /* If anything remains, move screen as necessary */ |
| if (shift_amount > 0) { |
| |
| guac_terminal_display_copy_rows(term->display, |
| 0, term->display->height - shift_amount - 1, shift_amount); |
| |
| /* Draw characters at top from scroll */ |
| __guac_terminal_redraw_rect(term, 0, 0, shift_amount - 1, width-1); |
| |
| } |
| |
| } |
| |
| } /* end if undisplayed rows exist */ |
| |
| } |
| |
| /* Keep cursor on screen */ |
| if (term->cursor_row < 0) term->cursor_row = 0; |
| if (term->cursor_row >= height) term->cursor_row = height-1; |
| if (term->cursor_col < 0) term->cursor_col = 0; |
| if (term->cursor_col >= width) term->cursor_col = width-1; |
| |
| /* Commit new dimensions */ |
| term->term_width = width; |
| term->term_height = height; |
| |
| } |
| |
| int guac_terminal_resize(guac_terminal* terminal, int width, int height) { |
| |
| guac_terminal_display* display = terminal->display; |
| guac_client* client = display->client; |
| |
| /* Acquire exclusive access to terminal */ |
| guac_terminal_lock(terminal); |
| |
| /* Set size of available screen area */ |
| terminal->outer_width = width; |
| terminal->outer_height = height; |
| |
| /* Calculate available display area */ |
| int available_width = width - GUAC_TERMINAL_SCROLLBAR_WIDTH; |
| if (available_width < 0) |
| available_width = 0; |
| |
| /* Calculate dimensions */ |
| int rows = height / display->char_height; |
| int columns = available_width / display->char_width; |
| |
| /* Keep height within predefined maximum */ |
| if (rows > GUAC_TERMINAL_MAX_ROWS) { |
| rows = GUAC_TERMINAL_MAX_ROWS; |
| height = rows * display->char_height; |
| } |
| |
| /* Keep width within predefined maximum */ |
| if (columns > GUAC_TERMINAL_MAX_COLUMNS) { |
| columns = GUAC_TERMINAL_MAX_COLUMNS; |
| available_width = columns * display->char_width; |
| width = available_width + GUAC_TERMINAL_SCROLLBAR_WIDTH; |
| } |
| |
| /* Set pixel sizes */ |
| terminal->width = width; |
| terminal->height = height; |
| |
| /* Resize default layer to given pixel dimensions */ |
| guac_terminal_repaint_default_layer(terminal, client->socket); |
| |
| /* Resize terminal if row/column dimensions have changed */ |
| if (columns != terminal->term_width || rows != terminal->term_height) { |
| |
| guac_client_log(client, GUAC_LOG_DEBUG, |
| "Resizing terminal to %ix%i", rows, columns); |
| |
| /* Resize terminal */ |
| __guac_terminal_resize(terminal, columns, rows); |
| |
| /* Reset scroll region */ |
| terminal->scroll_end = rows - 1; |
| |
| } |
| |
| /* Notify scrollbar of resize */ |
| guac_terminal_scrollbar_parent_resized(terminal->scrollbar, width, height, rows); |
| guac_terminal_scrollbar_set_bounds(terminal->scrollbar, |
| -guac_terminal_available_scroll(terminal), 0); |
| |
| |
| /* Release terminal */ |
| guac_terminal_unlock(terminal); |
| |
| guac_terminal_notify(terminal); |
| return 0; |
| |
| } |
| |
| void guac_terminal_flush(guac_terminal* terminal) { |
| |
| /* Flush typescript if in use */ |
| if (terminal->typescript != NULL) |
| guac_terminal_typescript_flush(terminal->typescript); |
| |
| /* Flush pipe stream if automatic flushing is enabled */ |
| if (terminal->pipe_stream_flags & GUAC_TERMINAL_PIPE_AUTOFLUSH) |
| guac_terminal_pipe_stream_flush(terminal); |
| |
| /* Flush display state */ |
| guac_terminal_select_redraw(terminal); |
| guac_terminal_commit_cursor(terminal); |
| guac_terminal_display_flush(terminal->display); |
| guac_terminal_scrollbar_flush(terminal->scrollbar); |
| |
| } |
| |
| void guac_terminal_lock(guac_terminal* terminal) { |
| pthread_mutex_lock(&(terminal->lock)); |
| } |
| |
| void guac_terminal_unlock(guac_terminal* terminal) { |
| pthread_mutex_unlock(&(terminal->lock)); |
| } |
| |
| int guac_terminal_send_data(guac_terminal* term, const char* data, int length) { |
| |
| /* Block all other sources of input if input is coming from a stream */ |
| if (term->input_stream != NULL) |
| return 0; |
| |
| return guac_terminal_write_all(term->stdin_pipe_fd[1], data, length); |
| |
| } |
| |
| int guac_terminal_send_string(guac_terminal* term, const char* data) { |
| |
| /* Block all other sources of input if input is coming from a stream */ |
| if (term->input_stream != NULL) |
| return 0; |
| |
| return guac_terminal_write_all(term->stdin_pipe_fd[1], data, strlen(data)); |
| |
| } |
| |
| static int __guac_terminal_send_key(guac_terminal* term, int keysym, int pressed) { |
| |
| /* Ignore user input if terminal is not started */ |
| if (!term->started) { |
| guac_client_log(term->client, GUAC_LOG_DEBUG, "Ignoring user input " |
| "while terminal has not yet started."); |
| return 0; |
| } |
| |
| /* Hide mouse cursor if not already hidden */ |
| if (term->current_cursor != GUAC_TERMINAL_CURSOR_BLANK) { |
| term->current_cursor = GUAC_TERMINAL_CURSOR_BLANK; |
| guac_common_cursor_set_blank(term->cursor); |
| guac_terminal_notify(term); |
| } |
| |
| /* Track modifiers */ |
| if (keysym == 0xFFE3) |
| term->mod_ctrl = pressed; |
| else if (keysym == 0xFFE9) |
| term->mod_alt = pressed; |
| else if (keysym == 0xFFE1) |
| term->mod_shift = pressed; |
| |
| /* If key pressed */ |
| else if (pressed) { |
| |
| /* Ctrl+Shift+V shortcut for paste */ |
| if (keysym == 'V' && term->mod_ctrl) |
| return guac_terminal_send_data(term, term->clipboard->buffer, term->clipboard->length); |
| |
| /* Shift+PgUp / Shift+PgDown shortcuts for scrolling */ |
| if (term->mod_shift) { |
| |
| /* Page up */ |
| if (keysym == 0xFF55) { |
| guac_terminal_scroll_display_up(term, term->term_height); |
| return 0; |
| } |
| |
| /* Page down */ |
| if (keysym == 0xFF56) { |
| guac_terminal_scroll_display_down(term, term->term_height); |
| return 0; |
| } |
| |
| } |
| |
| /* Reset scroll */ |
| if (term->scroll_offset != 0) |
| guac_terminal_scroll_display_down(term, term->scroll_offset); |
| |
| /* If alt being held, also send escape character */ |
| if (term->mod_alt) |
| guac_terminal_send_string(term, "\x1B"); |
| |
| /* Translate Ctrl+letter to control code */ |
| if (term->mod_ctrl) { |
| |
| char data; |
| |
| /* Keysyms for '@' through '_' are all conveniently in C0 order */ |
| if (keysym >= '@' && keysym <= '_') |
| data = (char) (keysym - '@'); |
| |
| /* Handle lowercase as well */ |
| else if (keysym >= 'a' && keysym <= 'z') |
| data = (char) (keysym - 'a' + 1); |
| |
| /* Ctrl+? is DEL (0x7f) */ |
| else if (keysym == '?') |
| data = 0x7F; |
| |
| /* Map Ctrl+2 to same result as Ctrl+@ */ |
| else if (keysym == '2') |
| data = 0x00; |
| |
| /* Map Ctrl+3 through Ctrl-7 to the remaining C0 characters such that Ctrl+6 is the same as Ctrl+^ */ |
| else if (keysym >= '3' && keysym <= '7') |
| data = (char) (keysym - '3' + 0x1B); |
| |
| /* Otherwise ignore */ |
| else |
| return 0; |
| |
| return guac_terminal_send_data(term, &data, 1); |
| |
| } |
| |
| /* Translate Unicode to UTF-8 */ |
| else if ((keysym >= 0x00 && keysym <= 0xFF) || ((keysym & 0xFFFF0000) == 0x01000000)) { |
| |
| int length; |
| char data[5]; |
| |
| length = guac_terminal_encode_utf8(keysym & 0xFFFF, data); |
| return guac_terminal_send_data(term, data, length); |
| |
| } |
| |
| /* Typeable keys of number pad */ |
| else if (keysym >= 0xFFAA && keysym <= 0xFFB9) { |
| char value = keysym - 0xFF80; |
| guac_terminal_send_data(term, &value, sizeof(value)); |
| } |
| |
| /* Non-printable keys */ |
| else { |
| |
| /* Backspace can vary based on configuration of terminal by client. */ |
| if (keysym == 0xFF08) { |
| char backspace_str[] = { term->backspace, '\0' }; |
| return guac_terminal_send_string(term, backspace_str); |
| } |
| if (keysym == 0xFF09 || keysym == 0xFF89) return guac_terminal_send_string(term, "\x09"); /* Tab */ |
| if (keysym == 0xFF0D || keysym == 0xFF8D) return guac_terminal_send_string(term, "\x0D"); /* Enter */ |
| if (keysym == 0xFF1B) return guac_terminal_send_string(term, "\x1B"); /* Esc */ |
| |
| if (keysym == 0xFF50 || keysym == 0xFF95) return guac_terminal_send_string(term, "\x1B[1~"); /* Home */ |
| |
| /* Arrow keys w/ application cursor */ |
| if (term->application_cursor_keys) { |
| if (keysym == 0xFF51 || keysym == 0xFF96) return guac_terminal_send_string(term, "\x1BOD"); /* Left */ |
| if (keysym == 0xFF52 || keysym == 0xFF97) return guac_terminal_send_string(term, "\x1BOA"); /* Up */ |
| if (keysym == 0xFF53 || keysym == 0xFF98) return guac_terminal_send_string(term, "\x1BOC"); /* Right */ |
| if (keysym == 0xFF54 || keysym == 0xFF99) return guac_terminal_send_string(term, "\x1BOB"); /* Down */ |
| } |
| else { |
| if (keysym == 0xFF51 || keysym == 0xFF96) return guac_terminal_send_string(term, "\x1B[D"); /* Left */ |
| if (keysym == 0xFF52 || keysym == 0xFF97) return guac_terminal_send_string(term, "\x1B[A"); /* Up */ |
| if (keysym == 0xFF53 || keysym == 0xFF98) return guac_terminal_send_string(term, "\x1B[C"); /* Right */ |
| if (keysym == 0xFF54 || keysym == 0xFF99) return guac_terminal_send_string(term, "\x1B[B"); /* Down */ |
| } |
| |
| if (keysym == 0xFF55 || keysym == 0xFF9A) return guac_terminal_send_string(term, "\x1B[5~"); /* Page up */ |
| if (keysym == 0xFF56 || keysym == 0xFF9B) return guac_terminal_send_string(term, "\x1B[6~"); /* Page down */ |
| if (keysym == 0xFF57 || keysym == 0xFF9C) return guac_terminal_send_string(term, "\x1B[4~"); /* End */ |
| |
| if (keysym == 0xFF63 || keysym == 0xFF9E) return guac_terminal_send_string(term, "\x1B[2~"); /* Insert */ |
| |
| if (keysym == 0xFFBE || keysym == 0xFF91) return guac_terminal_send_string(term, "\x1B[[A"); /* F1 */ |
| if (keysym == 0xFFBF || keysym == 0xFF92) return guac_terminal_send_string(term, "\x1B[[B"); /* F2 */ |
| if (keysym == 0xFFC0 || keysym == 0xFF93) return guac_terminal_send_string(term, "\x1B[[C"); /* F3 */ |
| if (keysym == 0xFFC1 || keysym == 0xFF94) return guac_terminal_send_string(term, "\x1B[[D"); /* F4 */ |
| if (keysym == 0xFFC2) return guac_terminal_send_string(term, "\x1B[[E"); /* F5 */ |
| |
| if (keysym == 0xFFC3) return guac_terminal_send_string(term, "\x1B[17~"); /* F6 */ |
| if (keysym == 0xFFC4) return guac_terminal_send_string(term, "\x1B[18~"); /* F7 */ |
| if (keysym == 0xFFC5) return guac_terminal_send_string(term, "\x1B[19~"); /* F8 */ |
| if (keysym == 0xFFC6) return guac_terminal_send_string(term, "\x1B[20~"); /* F9 */ |
| if (keysym == 0xFFC7) return guac_terminal_send_string(term, "\x1B[21~"); /* F10 */ |
| if (keysym == 0xFFC8) return guac_terminal_send_string(term, "\x1B[22~"); /* F11 */ |
| if (keysym == 0xFFC9) return guac_terminal_send_string(term, "\x1B[23~"); /* F12 */ |
| |
| if (keysym == 0xFFFF || keysym == 0xFF9F) return guac_terminal_send_string(term, "\x1B[3~"); /* Delete */ |
| |
| /* Ignore unknown keys */ |
| guac_client_log(term->client, GUAC_LOG_DEBUG, |
| "Ignoring unknown keysym: 0x%X", keysym); |
| } |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| int guac_terminal_send_key(guac_terminal* term, int keysym, int pressed) { |
| |
| int result; |
| |
| guac_terminal_lock(term); |
| result = __guac_terminal_send_key(term, keysym, pressed); |
| guac_terminal_unlock(term); |
| |
| return result; |
| |
| } |
| |
| static int __guac_terminal_send_mouse(guac_terminal* term, guac_user* user, |
| int x, int y, int mask) { |
| |
| /* Ignore user input if terminal is not started */ |
| if (!term->started) { |
| guac_client_log(term->client, GUAC_LOG_DEBUG, "Ignoring user input " |
| "while terminal has not yet started."); |
| return 0; |
| } |
| |
| /* Determine which buttons were just released and pressed */ |
| int released_mask = term->mouse_mask & ~mask; |
| int pressed_mask = ~term->mouse_mask & mask; |
| |
| /* Store current mouse location/state */ |
| guac_common_cursor_update(term->cursor, user, x, y, mask); |
| |
| /* Notify scrollbar, do not handle anything handled by scrollbar */ |
| if (guac_terminal_scrollbar_handle_mouse(term->scrollbar, x, y, mask)) { |
| |
| /* Set pointer cursor if mouse is over scrollbar */ |
| if (term->current_cursor != GUAC_TERMINAL_CURSOR_POINTER) { |
| term->current_cursor = GUAC_TERMINAL_CURSOR_POINTER; |
| guac_common_cursor_set_pointer(term->cursor); |
| guac_terminal_notify(term); |
| } |
| |
| guac_terminal_notify(term); |
| return 0; |
| |
| } |
| |
| term->mouse_mask = mask; |
| |
| /* Show mouse cursor if not already shown */ |
| if (term->current_cursor != GUAC_TERMINAL_CURSOR_IBAR) { |
| term->current_cursor = GUAC_TERMINAL_CURSOR_IBAR; |
| guac_common_cursor_set_ibar(term->cursor); |
| guac_terminal_notify(term); |
| } |
| |
| /* Paste contents of clipboard on right or middle mouse button up */ |
| if ((released_mask & GUAC_CLIENT_MOUSE_RIGHT) || (released_mask & GUAC_CLIENT_MOUSE_MIDDLE)) |
| return guac_terminal_send_data(term, term->clipboard->buffer, term->clipboard->length); |
| |
| /* If left mouse button was just released, stop selection */ |
| if (released_mask & GUAC_CLIENT_MOUSE_LEFT) |
| guac_terminal_select_end(term); |
| |
| /* Update selection state contextually while the left mouse button is |
| * pressed */ |
| else if (mask & GUAC_CLIENT_MOUSE_LEFT) { |
| |
| int row = y / term->display->char_height - term->scroll_offset; |
| int col = x / term->display->char_width; |
| |
| /* If mouse button was already just pressed, start a new selection or |
| * resume the existing selection depending on whether shift is held */ |
| if (pressed_mask & GUAC_CLIENT_MOUSE_LEFT) { |
| if (term->mod_shift) |
| guac_terminal_select_resume(term, row, col); |
| else |
| guac_terminal_select_start(term, row, col); |
| } |
| |
| /* In all other cases, simply update the existing selection as long as |
| * the mouse button is pressed */ |
| else |
| guac_terminal_select_update(term, row, col); |
| |
| } |
| |
| /* Scroll up if wheel moved up */ |
| if (released_mask & GUAC_CLIENT_MOUSE_SCROLL_UP) |
| guac_terminal_scroll_display_up(term, GUAC_TERMINAL_WHEEL_SCROLL_AMOUNT); |
| |
| /* Scroll down if wheel moved down */ |
| if (released_mask & GUAC_CLIENT_MOUSE_SCROLL_DOWN) |
| guac_terminal_scroll_display_down(term, GUAC_TERMINAL_WHEEL_SCROLL_AMOUNT); |
| |
| return 0; |
| |
| } |
| |
| int guac_terminal_send_mouse(guac_terminal* term, guac_user* user, |
| int x, int y, int mask) { |
| |
| int result; |
| |
| guac_terminal_lock(term); |
| result = __guac_terminal_send_mouse(term, user, x, y, mask); |
| guac_terminal_unlock(term); |
| |
| return result; |
| |
| } |
| |
| void guac_terminal_scroll_handler(guac_terminal_scrollbar* scrollbar, int value) { |
| |
| guac_terminal* terminal = (guac_terminal*) scrollbar->data; |
| |
| /* Calculate change in scroll offset */ |
| int delta = -value - terminal->scroll_offset; |
| |
| /* Update terminal based on change in scroll offset */ |
| if (delta < 0) |
| guac_terminal_scroll_display_down(terminal, -delta); |
| else if (delta > 0) |
| guac_terminal_scroll_display_up(terminal, delta); |
| |
| /* Update scrollbar value */ |
| guac_terminal_scrollbar_set_value(scrollbar, value); |
| |
| } |
| |
| int guac_terminal_sendf(guac_terminal* term, const char* format, ...) { |
| |
| int written; |
| |
| va_list ap; |
| char buffer[1024]; |
| |
| /* Block all other sources of input if input is coming from a stream */ |
| if (term->input_stream != NULL) |
| return 0; |
| |
| /* Print to buffer */ |
| va_start(ap, format); |
| written = vsnprintf(buffer, sizeof(buffer)-1, format, ap); |
| va_end(ap); |
| |
| if (written < 0) |
| return written; |
| |
| /* Write to STDIN */ |
| return guac_terminal_write_all(term->stdin_pipe_fd[1], buffer, written); |
| |
| } |
| |
| void guac_terminal_set_tab(guac_terminal* term, int column) { |
| |
| int i; |
| |
| /* Search for available space, set if available */ |
| for (i=0; i<GUAC_TERMINAL_MAX_TABS; i++) { |
| |
| /* Set tab if space free */ |
| if (term->custom_tabs[i] == 0) { |
| term->custom_tabs[i] = column+1; |
| break; |
| } |
| |
| } |
| |
| } |
| |
| void guac_terminal_unset_tab(guac_terminal* term, int column) { |
| |
| int i; |
| |
| /* Search for given tab, unset if found */ |
| for (i=0; i<GUAC_TERMINAL_MAX_TABS; i++) { |
| |
| /* Unset tab if found */ |
| if (term->custom_tabs[i] == column+1) { |
| term->custom_tabs[i] = 0; |
| break; |
| } |
| |
| } |
| |
| } |
| |
| void guac_terminal_clear_tabs(guac_terminal* term) { |
| term->tab_interval = 0; |
| memset(term->custom_tabs, 0, sizeof(term->custom_tabs)); |
| } |
| |
| int guac_terminal_next_tab(guac_terminal* term, int column) { |
| |
| int i; |
| |
| /* Determine tab stop from interval */ |
| int tabstop; |
| if (term->tab_interval != 0) |
| tabstop = (column / term->tab_interval + 1) * term->tab_interval; |
| else |
| tabstop = term->term_width - 1; |
| |
| /* Walk custom tabs, trying to find an earlier occurrence */ |
| for (i=0; i<GUAC_TERMINAL_MAX_TABS; i++) { |
| |
| int custom_tabstop = term->custom_tabs[i] - 1; |
| if (custom_tabstop != -1 && custom_tabstop > column && custom_tabstop < tabstop) |
| tabstop = custom_tabstop; |
| |
| } |
| |
| return tabstop; |
| } |
| |
| void guac_terminal_pipe_stream_open(guac_terminal* term, const char* name, |
| int flags) { |
| |
| guac_client* client = term->client; |
| guac_socket* socket = client->socket; |
| |
| /* Close existing stream, if any */ |
| guac_terminal_pipe_stream_close(term); |
| |
| /* Allocate and assign new pipe stream */ |
| term->pipe_stream = guac_client_alloc_stream(client); |
| term->pipe_buffer_length = 0; |
| term->pipe_stream_flags = flags; |
| |
| /* Open new pipe stream */ |
| guac_protocol_send_pipe(socket, term->pipe_stream, "text/plain", name); |
| |
| /* Log redirect at debug level */ |
| guac_client_log(client, GUAC_LOG_DEBUG, "Terminal output now directed to " |
| "pipe \"%s\" (flags=%i).", name, flags); |
| |
| } |
| |
| void guac_terminal_pipe_stream_write(guac_terminal* term, char c) { |
| |
| /* Append byte to buffer only if pipe is open */ |
| if (term->pipe_stream != NULL) { |
| |
| /* Flush buffer if no space is available */ |
| if (term->pipe_buffer_length == sizeof(term->pipe_buffer)) |
| guac_terminal_pipe_stream_flush(term); |
| |
| /* Append single byte to buffer */ |
| term->pipe_buffer[term->pipe_buffer_length++] = c; |
| |
| } |
| |
| } |
| |
| void guac_terminal_pipe_stream_flush(guac_terminal* term) { |
| |
| guac_client* client = term->client; |
| guac_socket* socket = client->socket; |
| guac_stream* pipe_stream = term->pipe_stream; |
| |
| /* Write blob if data exists in buffer */ |
| if (pipe_stream != NULL && term->pipe_buffer_length > 0) { |
| guac_protocol_send_blob(socket, pipe_stream, |
| term->pipe_buffer, term->pipe_buffer_length); |
| term->pipe_buffer_length = 0; |
| } |
| |
| } |
| |
| void guac_terminal_pipe_stream_close(guac_terminal* term) { |
| |
| guac_client* client = term->client; |
| guac_socket* socket = client->socket; |
| guac_stream* pipe_stream = term->pipe_stream; |
| |
| /* Close any existing pipe */ |
| if (pipe_stream != NULL) { |
| |
| /* Write end of stream */ |
| guac_terminal_pipe_stream_flush(term); |
| guac_protocol_send_end(socket, pipe_stream); |
| |
| /* Destroy stream */ |
| guac_client_free_stream(client, pipe_stream); |
| term->pipe_stream = NULL; |
| |
| /* Log redirect at debug level */ |
| guac_client_log(client, GUAC_LOG_DEBUG, |
| "Terminal output now redirected to display."); |
| |
| } |
| |
| } |
| |
| int guac_terminal_create_typescript(guac_terminal* term, const char* path, |
| const char* name, int create_path) { |
| |
| /* Create typescript */ |
| term->typescript = guac_terminal_typescript_alloc(path, name, create_path); |
| |
| /* Log failure */ |
| if (term->typescript == NULL) { |
| guac_client_log(term->client, GUAC_LOG_ERROR, |
| "Creation of typescript failed: %s", strerror(errno)); |
| return 1; |
| } |
| |
| /* If typescript was successfully created, log filenames */ |
| guac_client_log(term->client, GUAC_LOG_INFO, |
| "Typescript of terminal session will be saved to \"%s\". " |
| "Timing file is \"%s\".", |
| term->typescript->data_filename, |
| term->typescript->timing_filename); |
| |
| /* Typescript creation succeeded */ |
| return 0; |
| |
| } |
| |
| void guac_terminal_dup(guac_terminal* term, guac_user* user, |
| guac_socket* socket) { |
| |
| /* Synchronize display state with new user */ |
| guac_terminal_repaint_default_layer(term, socket); |
| guac_terminal_display_dup(term->display, user, socket); |
| |
| /* Synchronize mouse cursor */ |
| guac_common_cursor_dup(term->cursor, user, socket); |
| |
| /* Paint scrollbar for joining user */ |
| guac_terminal_scrollbar_dup(term->scrollbar, user, socket); |
| |
| } |
| |
| void guac_terminal_apply_color_scheme(guac_terminal* terminal, |
| const char* color_scheme) { |
| |
| guac_client* client = terminal->client; |
| guac_terminal_char* default_char = &terminal->default_char; |
| guac_terminal_display* display = terminal->display; |
| |
| /* Reinitialize default terminal colors with values from color scheme */ |
| guac_terminal_parse_color_scheme(client, color_scheme, |
| &default_char->attributes.foreground, |
| &default_char->attributes.background, |
| display->default_palette); |
| |
| /* Reinitialize default attributes of buffer and display */ |
| guac_terminal_display_reset_palette(display); |
| display->default_foreground = default_char->attributes.foreground; |
| display->default_background = default_char->attributes.background; |
| |
| /* Redraw terminal text and background */ |
| guac_terminal_repaint_default_layer(terminal, client->socket); |
| __guac_terminal_redraw_rect(terminal, 0, 0, |
| terminal->term_height - 1, |
| terminal->term_width - 1); |
| |
| /* Acquire exclusive access to terminal */ |
| guac_terminal_lock(terminal); |
| |
| /* Update stored copy of color scheme */ |
| free((char*) terminal->color_scheme); |
| terminal->color_scheme = strdup(color_scheme); |
| |
| /* Release terminal */ |
| guac_terminal_unlock(terminal); |
| |
| guac_terminal_notify(terminal); |
| |
| } |
| |
| void guac_terminal_apply_font(guac_terminal* terminal, const char* font_name, |
| int font_size, int dpi) { |
| |
| guac_client* client = terminal->client; |
| guac_terminal_display* display = terminal->display; |
| |
| if (guac_terminal_display_set_font(display, font_name, font_size, dpi)) |
| return; |
| |
| /* Resize terminal to fit available region, now that font metrics may be |
| * different */ |
| guac_terminal_resize(terminal, terminal->outer_width, |
| terminal->outer_height); |
| |
| /* Redraw terminal text and background */ |
| guac_terminal_repaint_default_layer(terminal, client->socket); |
| __guac_terminal_redraw_rect(terminal, 0, 0, |
| terminal->term_height - 1, |
| terminal->term_width - 1); |
| |
| /* Acquire exclusive access to terminal */ |
| guac_terminal_lock(terminal); |
| |
| /* Update stored copy of font name, if changed */ |
| if (font_name != NULL) |
| terminal->font_name = strdup(font_name); |
| |
| /* Update stored copy of font size, if changed */ |
| if (font_size != -1) |
| terminal->font_size = font_size; |
| |
| /* Release terminal */ |
| guac_terminal_unlock(terminal); |
| |
| guac_terminal_notify(terminal); |
| |
| } |
| |