2009-10-22 19:41:51 +00:00
|
|
|
/* $OpenBSD$ */
|
|
|
|
|
|
|
|
/*
|
2016-01-19 15:59:12 +00:00
|
|
|
* Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
|
2009-10-22 19:41:51 +00:00
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
|
* copyright notice and this permission notice appear in all copies.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
|
* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
|
|
|
|
* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
2013-03-24 09:28:59 +00:00
|
|
|
#include <sys/ioctl.h>
|
2015-10-27 13:23:24 +00:00
|
|
|
#include <sys/uio.h>
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2013-11-13 20:43:36 +00:00
|
|
|
#include <errno.h>
|
2009-11-04 20:50:11 +00:00
|
|
|
#include <event.h>
|
2009-10-22 19:41:51 +00:00
|
|
|
#include <fcntl.h>
|
2015-10-27 13:23:24 +00:00
|
|
|
#include <imsg.h>
|
2009-10-22 19:41:51 +00:00
|
|
|
#include <paths.h>
|
2012-07-10 11:53:01 +00:00
|
|
|
#include <stdlib.h>
|
2013-03-25 11:53:54 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
2009-10-22 19:41:51 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "tmux.h"
|
|
|
|
|
2016-10-10 21:29:23 +00:00
|
|
|
static void server_client_free(int, short, void *);
|
|
|
|
static void server_client_check_focus(struct window_pane *);
|
|
|
|
static void server_client_check_resize(struct window_pane *);
|
2019-05-03 14:51:30 +00:00
|
|
|
static key_code server_client_check_mouse(struct client *, struct key_event *);
|
2016-10-10 21:29:23 +00:00
|
|
|
static void server_client_repeat_timer(int, short, void *);
|
2016-10-11 09:30:36 +00:00
|
|
|
static void server_client_click_timer(int, short, void *);
|
2016-10-10 21:29:23 +00:00
|
|
|
static void server_client_check_exit(struct client *);
|
|
|
|
static void server_client_check_redraw(struct client *);
|
|
|
|
static void server_client_set_title(struct client *);
|
|
|
|
static void server_client_reset_state(struct client *);
|
|
|
|
static int server_client_assume_paste(struct session *);
|
2019-05-07 20:01:41 +00:00
|
|
|
static void server_client_clear_overlay(struct client *);
|
2019-08-28 07:34:32 +00:00
|
|
|
static void server_client_resize_event(int, short, void *);
|
2016-10-10 21:29:23 +00:00
|
|
|
|
|
|
|
static void server_client_dispatch(struct imsg *, void *);
|
|
|
|
static void server_client_dispatch_command(struct client *, struct imsg *);
|
|
|
|
static void server_client_dispatch_identify(struct client *, struct imsg *);
|
|
|
|
static void server_client_dispatch_shell(struct client *);
|
2019-12-12 11:39:56 +00:00
|
|
|
static void server_client_dispatch_write_ready(struct client *,
|
|
|
|
struct imsg *);
|
|
|
|
static void server_client_dispatch_read_data(struct client *,
|
|
|
|
struct imsg *);
|
|
|
|
static void server_client_dispatch_read_done(struct client *,
|
|
|
|
struct imsg *);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2017-05-29 20:37:30 +00:00
|
|
|
/* Number of attached clients. */
|
|
|
|
u_int
|
|
|
|
server_client_how_many(void)
|
|
|
|
{
|
|
|
|
struct client *c;
|
|
|
|
u_int n;
|
|
|
|
|
|
|
|
n = 0;
|
|
|
|
TAILQ_FOREACH(c, &clients, entry) {
|
|
|
|
if (c->session != NULL && (~c->flags & CLIENT_DETACHING))
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
return (n);
|
|
|
|
}
|
|
|
|
|
2019-05-07 20:01:41 +00:00
|
|
|
/* Overlay timer callback. */
|
2017-03-09 17:06:35 +00:00
|
|
|
static void
|
2019-05-07 20:01:41 +00:00
|
|
|
server_client_overlay_timer(__unused int fd, __unused short events, void *data)
|
2017-03-09 17:06:35 +00:00
|
|
|
{
|
2019-05-07 20:01:41 +00:00
|
|
|
server_client_clear_overlay(data);
|
2017-03-09 17:06:35 +00:00
|
|
|
}
|
|
|
|
|
2019-05-07 20:01:41 +00:00
|
|
|
/* Set an overlay on client. */
|
2017-03-09 17:06:35 +00:00
|
|
|
void
|
2019-05-07 20:01:41 +00:00
|
|
|
server_client_set_overlay(struct client *c, u_int delay, overlay_draw_cb drawcb,
|
|
|
|
overlay_key_cb keycb, overlay_free_cb freecb, void *data)
|
2017-03-09 17:06:35 +00:00
|
|
|
{
|
|
|
|
struct timeval tv;
|
|
|
|
|
2019-05-08 18:07:12 +00:00
|
|
|
if (c->overlay_draw != NULL)
|
|
|
|
server_client_clear_overlay(c);
|
|
|
|
|
2017-03-09 17:06:35 +00:00
|
|
|
tv.tv_sec = delay / 1000;
|
|
|
|
tv.tv_usec = (delay % 1000) * 1000L;
|
|
|
|
|
2019-05-07 20:01:41 +00:00
|
|
|
if (event_initialized(&c->overlay_timer))
|
|
|
|
evtimer_del(&c->overlay_timer);
|
|
|
|
evtimer_set(&c->overlay_timer, server_client_overlay_timer, c);
|
2017-08-16 12:12:54 +00:00
|
|
|
if (delay != 0)
|
2019-05-07 20:01:41 +00:00
|
|
|
evtimer_add(&c->overlay_timer, &tv);
|
|
|
|
|
|
|
|
c->overlay_draw = drawcb;
|
|
|
|
c->overlay_key = keycb;
|
|
|
|
c->overlay_free = freecb;
|
|
|
|
c->overlay_data = data;
|
2017-03-09 17:06:35 +00:00
|
|
|
|
|
|
|
c->tty.flags |= (TTY_FREEZE|TTY_NOCURSOR);
|
|
|
|
server_redraw_client(c);
|
|
|
|
}
|
|
|
|
|
2019-05-07 20:01:41 +00:00
|
|
|
/* Clear overlay mode on client. */
|
2018-08-02 11:44:07 +00:00
|
|
|
static void
|
2019-05-07 20:01:41 +00:00
|
|
|
server_client_clear_overlay(struct client *c)
|
2017-03-09 17:06:35 +00:00
|
|
|
{
|
2019-05-07 20:01:41 +00:00
|
|
|
if (c->overlay_draw == NULL)
|
2017-03-09 17:06:35 +00:00
|
|
|
return;
|
|
|
|
|
2019-05-07 20:01:41 +00:00
|
|
|
if (event_initialized(&c->overlay_timer))
|
|
|
|
evtimer_del(&c->overlay_timer);
|
|
|
|
|
|
|
|
if (c->overlay_free != NULL)
|
|
|
|
c->overlay_free(c);
|
|
|
|
|
|
|
|
c->overlay_draw = NULL;
|
|
|
|
c->overlay_key = NULL;
|
2017-03-09 17:06:35 +00:00
|
|
|
|
|
|
|
c->tty.flags &= ~(TTY_FREEZE|TTY_NOCURSOR);
|
|
|
|
server_redraw_client(c);
|
|
|
|
}
|
|
|
|
|
2015-06-04 23:27:51 +00:00
|
|
|
/* Check if this client is inside this server. */
|
|
|
|
int
|
|
|
|
server_client_check_nested(struct client *c)
|
|
|
|
{
|
|
|
|
struct environ_entry *envent;
|
|
|
|
struct window_pane *wp;
|
|
|
|
|
2015-10-28 09:51:55 +00:00
|
|
|
envent = environ_find(c->environ, "TMUX");
|
2015-06-04 23:27:51 +00:00
|
|
|
if (envent == NULL || *envent->value == '\0')
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
RB_FOREACH(wp, window_pane_tree, &all_window_panes) {
|
2017-04-05 10:49:46 +00:00
|
|
|
if (strcmp(wp->tty, c->ttyname) == 0)
|
2015-06-04 23:27:51 +00:00
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2015-04-20 15:34:56 +00:00
|
|
|
/* Set client key table. */
|
|
|
|
void
|
2015-12-12 18:32:24 +00:00
|
|
|
server_client_set_key_table(struct client *c, const char *name)
|
2015-04-20 15:34:56 +00:00
|
|
|
{
|
2015-12-12 18:32:24 +00:00
|
|
|
if (name == NULL)
|
|
|
|
name = server_client_get_key_table(c);
|
|
|
|
|
2015-04-20 15:34:56 +00:00
|
|
|
key_bindings_unref_table(c->keytable);
|
|
|
|
c->keytable = key_bindings_get_table(name, 1);
|
|
|
|
c->keytable->references++;
|
|
|
|
}
|
|
|
|
|
2015-12-12 18:32:24 +00:00
|
|
|
/* Get default key table. */
|
|
|
|
const char *
|
|
|
|
server_client_get_key_table(struct client *c)
|
|
|
|
{
|
|
|
|
struct session *s = c->session;
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
if (s == NULL)
|
|
|
|
return ("root");
|
|
|
|
|
|
|
|
name = options_get_string(s->options, "key-table");
|
|
|
|
if (*name == '\0')
|
|
|
|
return ("root");
|
|
|
|
return (name);
|
|
|
|
}
|
|
|
|
|
2017-04-21 16:04:18 +00:00
|
|
|
/* Is this table the default key table? */
|
|
|
|
static int
|
|
|
|
server_client_is_default_key_table(struct client *c, struct key_table *table)
|
2016-10-11 07:23:34 +00:00
|
|
|
{
|
2017-04-21 16:04:18 +00:00
|
|
|
return (strcmp(table->name, server_client_get_key_table(c)) == 0);
|
2016-10-11 07:23:34 +00:00
|
|
|
}
|
|
|
|
|
2009-10-22 19:41:51 +00:00
|
|
|
/* Create a new client. */
|
2017-12-19 15:00:39 +00:00
|
|
|
struct client *
|
2009-10-22 19:41:51 +00:00
|
|
|
server_client_create(int fd)
|
|
|
|
{
|
|
|
|
struct client *c;
|
|
|
|
|
2011-01-08 01:52:36 +00:00
|
|
|
setblocking(fd, 0);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
|
|
|
c = xcalloc(1, sizeof *c);
|
2015-06-05 18:01:12 +00:00
|
|
|
c->references = 1;
|
2015-10-27 13:23:24 +00:00
|
|
|
c->peer = proc_add_peer(server_proc, fd, server_client_dispatch, c);
|
2009-12-03 22:50:09 +00:00
|
|
|
|
2009-11-03 20:29:47 +00:00
|
|
|
if (gettimeofday(&c->creation_time, NULL) != 0)
|
2009-10-22 19:41:51 +00:00
|
|
|
fatal("gettimeofday failed");
|
2009-11-03 22:40:40 +00:00
|
|
|
memcpy(&c->activity_time, &c->creation_time, sizeof c->activity_time);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-10-28 09:51:55 +00:00
|
|
|
c->environ = environ_create();
|
2013-10-10 12:29:35 +00:00
|
|
|
|
2015-07-17 06:53:47 +00:00
|
|
|
c->fd = -1;
|
2015-10-31 08:13:58 +00:00
|
|
|
c->cwd = NULL;
|
2015-07-13 15:51:31 +00:00
|
|
|
|
2016-10-16 17:55:14 +00:00
|
|
|
TAILQ_INIT(&c->queue);
|
2013-03-24 09:54:10 +00:00
|
|
|
|
2009-10-22 19:41:51 +00:00
|
|
|
c->tty.fd = -1;
|
|
|
|
c->title = NULL;
|
|
|
|
|
|
|
|
c->session = NULL;
|
2010-12-20 00:17:22 +00:00
|
|
|
c->last_session = NULL;
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
|
2009-10-22 19:41:51 +00:00
|
|
|
c->tty.sx = 80;
|
|
|
|
c->tty.sy = 24;
|
|
|
|
|
2019-03-16 17:14:07 +00:00
|
|
|
status_init(c);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
|
|
|
c->message_string = NULL;
|
2015-04-25 18:33:59 +00:00
|
|
|
TAILQ_INIT(&c->message_log);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
|
|
|
c->prompt_string = NULL;
|
|
|
|
c->prompt_buffer = NULL;
|
|
|
|
c->prompt_index = 0;
|
|
|
|
|
2019-12-12 11:39:56 +00:00
|
|
|
RB_INIT(&c->files);
|
|
|
|
|
2013-03-24 09:28:59 +00:00
|
|
|
c->flags |= CLIENT_FOCUSED;
|
|
|
|
|
2015-04-20 15:34:56 +00:00
|
|
|
c->keytable = key_bindings_get_table("root", 1);
|
|
|
|
c->keytable->references++;
|
|
|
|
|
2009-11-05 00:05:00 +00:00
|
|
|
evtimer_set(&c->repeat_timer, server_client_repeat_timer, c);
|
2016-10-11 09:30:36 +00:00
|
|
|
evtimer_set(&c->click_timer, server_client_click_timer, c);
|
2009-11-05 00:05:00 +00:00
|
|
|
|
2015-04-24 23:17:11 +00:00
|
|
|
TAILQ_INSERT_TAIL(&clients, c, entry);
|
2015-10-20 21:12:08 +00:00
|
|
|
log_debug("new client %p", c);
|
2017-12-19 15:00:39 +00:00
|
|
|
return (c);
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
|
2012-05-06 07:38:17 +00:00
|
|
|
/* Open client terminal if needed. */
|
|
|
|
int
|
2014-02-23 00:53:06 +00:00
|
|
|
server_client_open(struct client *c, char **cause)
|
2012-05-06 07:38:17 +00:00
|
|
|
{
|
2012-06-18 13:16:42 +00:00
|
|
|
if (c->flags & CLIENT_CONTROL)
|
|
|
|
return (0);
|
|
|
|
|
2014-04-16 08:02:31 +00:00
|
|
|
if (strcmp(c->ttyname, "/dev/tty") == 0) {
|
|
|
|
*cause = xstrdup("can't use /dev/tty");
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
2012-05-06 07:38:17 +00:00
|
|
|
if (!(c->flags & CLIENT_TERMINAL)) {
|
2014-02-14 13:59:01 +00:00
|
|
|
*cause = xstrdup("not a terminal");
|
2012-05-06 07:38:17 +00:00
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
2014-02-23 00:53:06 +00:00
|
|
|
if (tty_open(&c->tty, cause) != 0)
|
2012-05-06 07:38:17 +00:00
|
|
|
return (-1);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2009-10-22 19:41:51 +00:00
|
|
|
/* Lost a client. */
|
|
|
|
void
|
|
|
|
server_client_lost(struct client *c)
|
|
|
|
{
|
2015-04-25 18:33:59 +00:00
|
|
|
struct message_entry *msg, *msg1;
|
2019-12-12 11:39:56 +00:00
|
|
|
struct client_file *cf;
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-06-05 18:01:12 +00:00
|
|
|
c->flags |= CLIENT_DEAD;
|
|
|
|
|
2019-05-07 20:01:41 +00:00
|
|
|
server_client_clear_overlay(c);
|
2015-06-05 18:01:12 +00:00
|
|
|
status_prompt_clear(c);
|
|
|
|
status_message_clear(c);
|
|
|
|
|
2019-12-12 11:39:56 +00:00
|
|
|
RB_FOREACH(cf, client_files, &c->files) {
|
|
|
|
cf->error = EINTR;
|
|
|
|
file_fire_done(cf);
|
|
|
|
}
|
2015-06-05 18:01:12 +00:00
|
|
|
|
2015-04-24 23:17:11 +00:00
|
|
|
TAILQ_REMOVE(&clients, c, entry);
|
2015-10-20 21:12:08 +00:00
|
|
|
log_debug("lost client %p", c);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If CLIENT_TERMINAL hasn't been set, then tty_init hasn't been called
|
|
|
|
* and tty_free might close an unrelated fd.
|
|
|
|
*/
|
|
|
|
if (c->flags & CLIENT_TERMINAL)
|
|
|
|
tty_free(&c->tty);
|
2013-10-10 12:26:34 +00:00
|
|
|
free(c->ttyname);
|
|
|
|
free(c->term);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2019-03-15 14:46:58 +00:00
|
|
|
status_free(c);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2012-07-10 11:53:01 +00:00
|
|
|
free(c->title);
|
2015-10-31 08:13:58 +00:00
|
|
|
free((void *)c->cwd);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2009-11-05 00:05:00 +00:00
|
|
|
evtimer_del(&c->repeat_timer);
|
2016-10-11 09:30:36 +00:00
|
|
|
evtimer_del(&c->click_timer);
|
2009-11-05 00:05:00 +00:00
|
|
|
|
2015-04-20 15:34:56 +00:00
|
|
|
key_bindings_unref_table(c->keytable);
|
|
|
|
|
2012-07-10 11:53:01 +00:00
|
|
|
free(c->message_string);
|
2014-02-14 13:59:01 +00:00
|
|
|
if (event_initialized(&c->message_timer))
|
2012-03-17 18:24:07 +00:00
|
|
|
evtimer_del(&c->message_timer);
|
2015-04-25 18:33:59 +00:00
|
|
|
TAILQ_FOREACH_SAFE(msg, &c->message_log, entry, msg1) {
|
2012-07-10 11:53:01 +00:00
|
|
|
free(msg->msg);
|
2015-04-25 18:33:59 +00:00
|
|
|
TAILQ_REMOVE(&c->message_log, msg, entry);
|
|
|
|
free(msg);
|
2009-11-18 13:16:33 +00:00
|
|
|
}
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2018-08-29 09:50:32 +00:00
|
|
|
free(c->prompt_saved);
|
2012-07-10 11:53:01 +00:00
|
|
|
free(c->prompt_string);
|
|
|
|
free(c->prompt_buffer);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2017-05-01 12:20:55 +00:00
|
|
|
format_lost_client(c);
|
2015-10-28 09:51:55 +00:00
|
|
|
environ_free(c->environ);
|
2011-08-20 20:37:30 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
proc_remove_peer(c->peer);
|
|
|
|
c->peer = NULL;
|
2009-11-04 21:47:42 +00:00
|
|
|
|
2015-06-05 18:06:30 +00:00
|
|
|
server_client_unref(c);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2012-04-11 06:16:14 +00:00
|
|
|
server_add_accept(0); /* may be more file descriptors now */
|
|
|
|
|
2009-10-22 19:41:51 +00:00
|
|
|
recalculate_sizes();
|
2010-09-26 20:43:30 +00:00
|
|
|
server_check_unattached();
|
2009-11-11 08:00:42 +00:00
|
|
|
server_update_socket();
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
|
2015-06-05 18:01:12 +00:00
|
|
|
/* Remove reference from a client. */
|
|
|
|
void
|
2015-06-05 18:06:30 +00:00
|
|
|
server_client_unref(struct client *c)
|
2015-06-05 18:01:12 +00:00
|
|
|
{
|
2015-10-20 21:12:08 +00:00
|
|
|
log_debug("unref client %p (%d references)", c, c->references);
|
2015-06-05 18:01:12 +00:00
|
|
|
|
|
|
|
c->references--;
|
|
|
|
if (c->references == 0)
|
|
|
|
event_once(-1, EV_TIMEOUT, server_client_free, c, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free dead client. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2015-11-18 14:27:44 +00:00
|
|
|
server_client_free(__unused int fd, __unused short events, void *arg)
|
2015-06-05 18:01:12 +00:00
|
|
|
{
|
|
|
|
struct client *c = arg;
|
|
|
|
|
2015-10-20 21:12:08 +00:00
|
|
|
log_debug("free client %p (%d references)", c, c->references);
|
2015-06-05 18:01:12 +00:00
|
|
|
|
2016-10-16 17:55:14 +00:00
|
|
|
if (!TAILQ_EMPTY(&c->queue))
|
|
|
|
fatalx("queue not empty");
|
|
|
|
|
2017-04-05 10:49:46 +00:00
|
|
|
if (c->references == 0) {
|
|
|
|
free((void *)c->name);
|
2015-06-05 18:01:12 +00:00
|
|
|
free(c);
|
2017-04-05 10:49:46 +00:00
|
|
|
}
|
2015-06-05 18:01:12 +00:00
|
|
|
}
|
|
|
|
|
2017-04-19 14:00:28 +00:00
|
|
|
/* Suspend a client. */
|
|
|
|
void
|
|
|
|
server_client_suspend(struct client *c)
|
|
|
|
{
|
2017-05-16 12:57:26 +00:00
|
|
|
struct session *s = c->session;
|
2017-04-19 14:00:28 +00:00
|
|
|
|
|
|
|
if (s == NULL || (c->flags & CLIENT_DETACHING))
|
|
|
|
return;
|
|
|
|
|
|
|
|
tty_stop_tty(&c->tty);
|
|
|
|
c->flags |= CLIENT_SUSPENDED;
|
|
|
|
proc_send(c->peer, MSG_SUSPEND, -1, NULL, 0);
|
|
|
|
}
|
|
|
|
|
2015-12-08 01:10:31 +00:00
|
|
|
/* Detach a client. */
|
|
|
|
void
|
|
|
|
server_client_detach(struct client *c, enum msgtype msgtype)
|
|
|
|
{
|
2017-05-16 12:57:26 +00:00
|
|
|
struct session *s = c->session;
|
2015-12-08 01:10:31 +00:00
|
|
|
|
2017-04-19 14:00:28 +00:00
|
|
|
if (s == NULL || (c->flags & CLIENT_DETACHING))
|
2015-12-08 01:10:31 +00:00
|
|
|
return;
|
|
|
|
|
2017-04-19 14:00:28 +00:00
|
|
|
c->flags |= CLIENT_DETACHING;
|
2016-10-16 22:06:40 +00:00
|
|
|
notify_client("client-detached", c);
|
2017-07-12 09:07:52 +00:00
|
|
|
proc_send(c->peer, msgtype, -1, s->name, strlen(s->name) + 1);
|
2015-12-08 01:10:31 +00:00
|
|
|
}
|
|
|
|
|
2017-01-13 11:56:43 +00:00
|
|
|
/* Execute command to replace a client. */
|
2017-01-13 10:12:12 +00:00
|
|
|
void
|
|
|
|
server_client_exec(struct client *c, const char *cmd)
|
|
|
|
{
|
|
|
|
struct session *s = c->session;
|
2017-01-13 11:56:43 +00:00
|
|
|
char *msg;
|
|
|
|
const char *shell;
|
2017-01-13 10:12:12 +00:00
|
|
|
size_t cmdsize, shellsize;
|
|
|
|
|
|
|
|
if (*cmd == '\0')
|
|
|
|
return;
|
|
|
|
cmdsize = strlen(cmd) + 1;
|
|
|
|
|
|
|
|
if (s != NULL)
|
|
|
|
shell = options_get_string(s->options, "default-shell");
|
|
|
|
else
|
|
|
|
shell = options_get_string(global_s_options, "default-shell");
|
2020-03-17 11:10:12 +00:00
|
|
|
if (!checkshell(shell))
|
|
|
|
shell = _PATH_BSHELL;
|
2017-01-13 10:12:12 +00:00
|
|
|
shellsize = strlen(shell) + 1;
|
|
|
|
|
|
|
|
msg = xmalloc(cmdsize + shellsize);
|
|
|
|
memcpy(msg, cmd, cmdsize);
|
|
|
|
memcpy(msg + cmdsize, shell, shellsize);
|
|
|
|
|
|
|
|
proc_send(c->peer, MSG_EXEC, -1, msg, cmdsize + shellsize);
|
|
|
|
free(msg);
|
|
|
|
}
|
|
|
|
|
2012-01-29 09:37:02 +00:00
|
|
|
/* Check for mouse keys. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static key_code
|
2019-05-03 14:51:30 +00:00
|
|
|
server_client_check_mouse(struct client *c, struct key_event *event)
|
2012-01-29 09:37:02 +00:00
|
|
|
{
|
2019-05-03 14:51:30 +00:00
|
|
|
struct mouse_event *m = &event->m;
|
2016-10-11 09:30:36 +00:00
|
|
|
struct session *s = c->session;
|
2019-03-18 20:53:33 +00:00
|
|
|
struct winlink *wl;
|
2016-10-11 09:30:36 +00:00
|
|
|
struct window_pane *wp;
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
u_int x, y, b, sx, sy, px, py;
|
2020-03-16 06:12:42 +00:00
|
|
|
int ignore = 0;
|
2016-10-11 09:30:36 +00:00
|
|
|
key_code key;
|
|
|
|
struct timeval tv;
|
2019-03-18 20:53:33 +00:00
|
|
|
struct style_range *sr;
|
2019-05-12 18:16:33 +00:00
|
|
|
enum { NOTYPE,
|
|
|
|
MOVE,
|
|
|
|
DOWN,
|
|
|
|
UP,
|
|
|
|
DRAG,
|
|
|
|
WHEEL,
|
|
|
|
DOUBLE,
|
|
|
|
TRIPLE } type = NOTYPE;
|
2019-05-03 14:51:30 +00:00
|
|
|
enum { NOWHERE,
|
|
|
|
PANE,
|
|
|
|
STATUS,
|
|
|
|
STATUS_LEFT,
|
|
|
|
STATUS_RIGHT,
|
|
|
|
STATUS_DEFAULT,
|
2019-05-12 18:16:33 +00:00
|
|
|
BORDER } where = NOWHERE;
|
2015-04-19 21:34:21 +00:00
|
|
|
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
log_debug("%s mouse %02x at %u,%u (last %u,%u) (%d)", c->name, m->b,
|
|
|
|
m->x, m->y, m->lx, m->ly, c->tty.mouse_drag_flag);
|
2015-04-19 21:34:21 +00:00
|
|
|
|
|
|
|
/* What type of event is this? */
|
2020-03-12 13:16:16 +00:00
|
|
|
if (event->key == KEYC_DOUBLECLICK) {
|
|
|
|
type = DOUBLE;
|
|
|
|
x = m->x, y = m->y, b = m->b;
|
2020-03-16 06:12:42 +00:00
|
|
|
ignore = 1;
|
2020-03-12 13:16:16 +00:00
|
|
|
log_debug("double-click at %u,%u", x, y);
|
|
|
|
} else if ((m->sgr_type != ' ' &&
|
2017-02-01 09:55:07 +00:00
|
|
|
MOUSE_DRAG(m->sgr_b) &&
|
|
|
|
MOUSE_BUTTONS(m->sgr_b) == 3) ||
|
|
|
|
(m->sgr_type == ' ' &&
|
|
|
|
MOUSE_DRAG(m->b) &&
|
|
|
|
MOUSE_BUTTONS(m->b) == 3 &&
|
|
|
|
MOUSE_BUTTONS(m->lb) == 3)) {
|
|
|
|
type = MOVE;
|
|
|
|
x = m->x, y = m->y, b = 0;
|
|
|
|
log_debug("move at %u,%u", x, y);
|
|
|
|
} else if (MOUSE_DRAG(m->b)) {
|
2015-04-19 21:34:21 +00:00
|
|
|
type = DRAG;
|
|
|
|
if (c->tty.mouse_drag_flag) {
|
|
|
|
x = m->x, y = m->y, b = m->b;
|
2019-05-03 18:42:40 +00:00
|
|
|
if (x == m->lx && y == m->ly)
|
|
|
|
return (KEYC_UNKNOWN);
|
2015-04-19 21:34:21 +00:00
|
|
|
log_debug("drag update at %u,%u", x, y);
|
|
|
|
} else {
|
2019-05-03 16:51:29 +00:00
|
|
|
x = m->lx, y = m->ly, b = m->lb;
|
2015-04-19 21:34:21 +00:00
|
|
|
log_debug("drag start at %u,%u", x, y);
|
2012-01-29 09:37:02 +00:00
|
|
|
}
|
2015-04-19 21:34:21 +00:00
|
|
|
} else if (MOUSE_WHEEL(m->b)) {
|
|
|
|
type = WHEEL;
|
|
|
|
x = m->x, y = m->y, b = m->b;
|
|
|
|
log_debug("wheel at %u,%u", x, y);
|
2016-11-16 11:37:16 +00:00
|
|
|
} else if (MOUSE_RELEASE(m->b)) {
|
2015-04-19 21:34:21 +00:00
|
|
|
type = UP;
|
|
|
|
x = m->x, y = m->y, b = m->lb;
|
|
|
|
log_debug("up at %u,%u", x, y);
|
|
|
|
} else {
|
2016-10-11 09:30:36 +00:00
|
|
|
if (c->flags & CLIENT_DOUBLECLICK) {
|
|
|
|
evtimer_del(&c->click_timer);
|
|
|
|
c->flags &= ~CLIENT_DOUBLECLICK;
|
|
|
|
if (m->b == c->click_button) {
|
2020-03-12 13:16:16 +00:00
|
|
|
type = NOTYPE;
|
|
|
|
c->flags |= CLIENT_TRIPLECLICK;
|
2016-10-11 09:30:36 +00:00
|
|
|
goto add_timer;
|
|
|
|
}
|
|
|
|
} else if (c->flags & CLIENT_TRIPLECLICK) {
|
|
|
|
evtimer_del(&c->click_timer);
|
|
|
|
c->flags &= ~CLIENT_TRIPLECLICK;
|
|
|
|
if (m->b == c->click_button) {
|
|
|
|
type = TRIPLE;
|
|
|
|
x = m->x, y = m->y, b = m->b;
|
|
|
|
log_debug("triple-click at %u,%u", x, y);
|
2020-03-16 06:12:42 +00:00
|
|
|
ignore = 1;
|
2016-10-11 09:30:36 +00:00
|
|
|
goto have_event;
|
|
|
|
}
|
2020-03-16 06:12:42 +00:00
|
|
|
} else
|
|
|
|
c->flags |= CLIENT_DOUBLECLICK;
|
2016-10-11 09:30:36 +00:00
|
|
|
|
2020-03-16 06:12:42 +00:00
|
|
|
add_timer:
|
2015-04-19 21:34:21 +00:00
|
|
|
type = DOWN;
|
|
|
|
x = m->x, y = m->y, b = m->b;
|
|
|
|
log_debug("down at %u,%u", x, y);
|
2016-10-11 09:30:36 +00:00
|
|
|
|
|
|
|
if (KEYC_CLICK_TIMEOUT != 0) {
|
2020-03-12 13:16:16 +00:00
|
|
|
memcpy(&c->click_event, m, sizeof c->click_event);
|
2016-10-11 09:30:36 +00:00
|
|
|
c->click_button = m->b;
|
|
|
|
|
|
|
|
tv.tv_sec = KEYC_CLICK_TIMEOUT / 1000;
|
|
|
|
tv.tv_usec = (KEYC_CLICK_TIMEOUT % 1000) * 1000L;
|
|
|
|
evtimer_del(&c->click_timer);
|
|
|
|
evtimer_add(&c->click_timer, &tv);
|
|
|
|
}
|
2012-01-29 09:37:02 +00:00
|
|
|
}
|
2016-10-11 09:30:36 +00:00
|
|
|
|
|
|
|
have_event:
|
2015-04-19 21:34:21 +00:00
|
|
|
if (type == NOTYPE)
|
2015-12-12 18:19:00 +00:00
|
|
|
return (KEYC_UNKNOWN);
|
2012-01-29 09:37:02 +00:00
|
|
|
|
2018-08-22 20:06:14 +00:00
|
|
|
/* Save the session. */
|
2015-04-19 21:34:21 +00:00
|
|
|
m->s = s->id;
|
2018-08-22 20:06:14 +00:00
|
|
|
m->w = -1;
|
2020-03-16 06:12:42 +00:00
|
|
|
m->ignore = ignore;
|
2015-04-19 21:34:21 +00:00
|
|
|
|
|
|
|
/* Is this on the status line? */
|
|
|
|
m->statusat = status_at_line(c);
|
2019-07-06 20:56:34 +00:00
|
|
|
m->statuslines = status_line_size(c);
|
2019-03-18 20:53:33 +00:00
|
|
|
if (m->statusat != -1 &&
|
|
|
|
y >= (u_int)m->statusat &&
|
2019-07-06 20:56:34 +00:00
|
|
|
y < m->statusat + m->statuslines) {
|
2019-03-18 20:53:33 +00:00
|
|
|
sr = status_get_range(c, x, y - m->statusat);
|
2019-03-25 18:59:55 +00:00
|
|
|
if (sr == NULL) {
|
|
|
|
where = STATUS_DEFAULT;
|
|
|
|
} else {
|
|
|
|
switch (sr->type) {
|
|
|
|
case STYLE_RANGE_NONE:
|
2019-03-25 09:22:09 +00:00
|
|
|
return (KEYC_UNKNOWN);
|
2019-03-25 18:59:55 +00:00
|
|
|
case STYLE_RANGE_LEFT:
|
|
|
|
where = STATUS_LEFT;
|
|
|
|
break;
|
|
|
|
case STYLE_RANGE_RIGHT:
|
|
|
|
where = STATUS_RIGHT;
|
|
|
|
break;
|
|
|
|
case STYLE_RANGE_WINDOW:
|
2019-11-28 09:56:25 +00:00
|
|
|
wl = winlink_find_by_index(&s->windows,
|
|
|
|
sr->argument);
|
2019-03-25 18:59:55 +00:00
|
|
|
if (wl == NULL)
|
|
|
|
return (KEYC_UNKNOWN);
|
|
|
|
m->w = wl->window->id;
|
2019-03-25 09:22:09 +00:00
|
|
|
|
2019-03-25 18:59:55 +00:00
|
|
|
where = STATUS;
|
|
|
|
break;
|
|
|
|
}
|
2018-08-22 20:06:14 +00:00
|
|
|
}
|
|
|
|
}
|
2015-04-19 21:34:21 +00:00
|
|
|
|
|
|
|
/* Not on status line. Adjust position and check for border or pane. */
|
|
|
|
if (where == NOWHERE) {
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
px = x;
|
2019-07-06 20:56:34 +00:00
|
|
|
if (m->statusat == 0 && y >= m->statuslines)
|
|
|
|
py = y - m->statuslines;
|
2015-04-19 21:34:21 +00:00
|
|
|
else if (m->statusat > 0 && y >= (u_int)m->statusat)
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
py = m->statusat - 1;
|
|
|
|
else
|
|
|
|
py = y;
|
|
|
|
|
|
|
|
tty_window_offset(&c->tty, &m->ox, &m->oy, &sx, &sy);
|
|
|
|
log_debug("mouse window @%u at %u,%u (%ux%u)",
|
|
|
|
s->curw->window->id, m->ox, m->oy, sx, sy);
|
|
|
|
if (px > sx || py > sy)
|
|
|
|
return (KEYC_UNKNOWN);
|
|
|
|
px = px + m->ox;
|
|
|
|
py = py + m->oy;
|
2015-04-19 21:34:21 +00:00
|
|
|
|
2018-09-11 06:37:54 +00:00
|
|
|
/* Try the pane borders if not zoomed. */
|
|
|
|
if (~s->curw->window->flags & WINDOW_ZOOMED) {
|
|
|
|
TAILQ_FOREACH(wp, &s->curw->window->panes, entry) {
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
if ((wp->xoff + wp->sx == px &&
|
|
|
|
wp->yoff <= 1 + py &&
|
|
|
|
wp->yoff + wp->sy >= py) ||
|
|
|
|
(wp->yoff + wp->sy == py &&
|
|
|
|
wp->xoff <= 1 + px &&
|
|
|
|
wp->xoff + wp->sx >= px))
|
2018-09-11 06:37:54 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (wp != NULL)
|
|
|
|
where = BORDER;
|
2015-04-19 21:34:21 +00:00
|
|
|
}
|
2018-09-11 06:37:54 +00:00
|
|
|
|
|
|
|
/* Otherwise try inside the pane. */
|
|
|
|
if (where == NOWHERE) {
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
wp = window_get_active_at(s->curw->window, px, py);
|
2018-09-11 06:37:54 +00:00
|
|
|
if (wp != NULL)
|
2015-04-19 21:34:21 +00:00
|
|
|
where = PANE;
|
|
|
|
}
|
2018-09-11 06:37:54 +00:00
|
|
|
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == NOWHERE)
|
2015-12-12 18:19:00 +00:00
|
|
|
return (KEYC_UNKNOWN);
|
2018-09-11 06:37:54 +00:00
|
|
|
if (where == PANE)
|
|
|
|
log_debug("mouse %u,%u on pane %%%u", x, y, wp->id);
|
|
|
|
else if (where == BORDER)
|
|
|
|
log_debug("mouse on pane %%%u border", wp->id);
|
2015-04-19 21:34:21 +00:00
|
|
|
m->wp = wp->id;
|
|
|
|
m->w = wp->window->id;
|
|
|
|
} else
|
|
|
|
m->wp = -1;
|
|
|
|
|
|
|
|
/* Stop dragging if needed. */
|
2016-11-16 11:37:16 +00:00
|
|
|
if (type != DRAG && type != WHEEL && c->tty.mouse_drag_flag) {
|
2015-04-19 21:34:21 +00:00
|
|
|
if (c->tty.mouse_drag_release != NULL)
|
|
|
|
c->tty.mouse_drag_release(c, m);
|
|
|
|
|
|
|
|
c->tty.mouse_drag_update = NULL;
|
|
|
|
c->tty.mouse_drag_release = NULL;
|
|
|
|
|
2016-03-01 12:04:43 +00:00
|
|
|
/*
|
2016-03-18 07:28:27 +00:00
|
|
|
* End a mouse drag by passing a MouseDragEnd key corresponding
|
|
|
|
* to the button that started the drag.
|
2016-03-01 12:04:43 +00:00
|
|
|
*/
|
|
|
|
switch (c->tty.mouse_drag_flag) {
|
|
|
|
case 1:
|
|
|
|
if (where == PANE)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND1_PANE;
|
2016-03-01 12:04:43 +00:00
|
|
|
if (where == STATUS)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND1_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDRAGEND1_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDRAGEND1_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDRAGEND1_STATUS_DEFAULT;
|
2016-03-01 12:04:43 +00:00
|
|
|
if (where == BORDER)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND1_BORDER;
|
2016-03-01 12:04:43 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (where == PANE)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND2_PANE;
|
2016-03-01 12:04:43 +00:00
|
|
|
if (where == STATUS)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND2_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDRAGEND2_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDRAGEND2_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDRAGEND2_STATUS_DEFAULT;
|
2016-03-01 12:04:43 +00:00
|
|
|
if (where == BORDER)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND2_BORDER;
|
2016-03-01 12:04:43 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
if (where == PANE)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND3_PANE;
|
2016-03-01 12:04:43 +00:00
|
|
|
if (where == STATUS)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND3_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDRAGEND3_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDRAGEND3_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDRAGEND3_STATUS_DEFAULT;
|
2016-03-01 12:04:43 +00:00
|
|
|
if (where == BORDER)
|
2016-03-18 07:28:27 +00:00
|
|
|
key = KEYC_MOUSEDRAGEND3_BORDER;
|
2016-03-01 12:04:43 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
key = KEYC_MOUSE;
|
|
|
|
break;
|
|
|
|
}
|
2015-04-19 21:34:21 +00:00
|
|
|
c->tty.mouse_drag_flag = 0;
|
2020-02-19 14:25:00 +00:00
|
|
|
goto out;
|
2012-01-29 09:37:02 +00:00
|
|
|
}
|
|
|
|
|
2015-04-19 21:34:21 +00:00
|
|
|
/* Convert to a key binding. */
|
2015-12-12 18:19:00 +00:00
|
|
|
key = KEYC_UNKNOWN;
|
2015-04-19 21:34:21 +00:00
|
|
|
switch (type) {
|
|
|
|
case NOTYPE:
|
|
|
|
break;
|
2017-02-01 09:55:07 +00:00
|
|
|
case MOVE:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEMOVE_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEMOVE_STATUS;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEMOVE_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEMOVE_STATUS_RIGHT;
|
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEMOVE_STATUS_DEFAULT;
|
2017-02-01 09:55:07 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEMOVE_BORDER;
|
|
|
|
break;
|
2015-04-19 21:34:21 +00:00
|
|
|
case DRAG:
|
2016-11-24 18:45:45 +00:00
|
|
|
if (c->tty.mouse_drag_update != NULL)
|
|
|
|
key = KEYC_DRAGGING;
|
|
|
|
else {
|
2015-04-19 21:34:21 +00:00
|
|
|
switch (MOUSE_BUTTONS(b)) {
|
|
|
|
case 0:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEDRAG1_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEDRAG1_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDRAG1_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDRAG1_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDRAG1_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEDRAG1_BORDER;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEDRAG2_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEDRAG2_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDRAG2_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDRAG2_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDRAG2_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEDRAG2_BORDER;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEDRAG3_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEDRAG3_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDRAG3_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDRAG3_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDRAG3_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEDRAG3_BORDER;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-01-29 09:37:02 +00:00
|
|
|
|
2016-03-01 12:04:43 +00:00
|
|
|
/*
|
|
|
|
* Begin a drag by setting the flag to a non-zero value that
|
|
|
|
* corresponds to the mouse button in use.
|
|
|
|
*/
|
|
|
|
c->tty.mouse_drag_flag = MOUSE_BUTTONS(b) + 1;
|
2015-04-19 21:34:21 +00:00
|
|
|
break;
|
|
|
|
case WHEEL:
|
|
|
|
if (MOUSE_BUTTONS(b) == MOUSE_WHEEL_UP) {
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_WHEELUP_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_WHEELUP_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_WHEELUP_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_WHEELUP_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_WHEELUP_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_WHEELUP_BORDER;
|
|
|
|
} else {
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_WHEELDOWN_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_WHEELDOWN_STATUS;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_WHEELDOWN_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_WHEELDOWN_STATUS_RIGHT;
|
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_WHEELDOWN_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_WHEELDOWN_BORDER;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case UP:
|
|
|
|
switch (MOUSE_BUTTONS(b)) {
|
|
|
|
case 0:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEUP1_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEUP1_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEUP1_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEUP1_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEUP1_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEUP1_BORDER;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEUP2_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEUP2_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEUP2_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEUP2_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEUP2_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEUP2_BORDER;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEUP3_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEUP3_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEUP3_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEUP3_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEUP3_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEUP3_BORDER;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case DOWN:
|
|
|
|
switch (MOUSE_BUTTONS(b)) {
|
|
|
|
case 0:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEDOWN1_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEDOWN1_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDOWN1_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDOWN1_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDOWN1_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEDOWN1_BORDER;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEDOWN2_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEDOWN2_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDOWN2_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDOWN2_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDOWN2_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEDOWN2_BORDER;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_MOUSEDOWN3_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_MOUSEDOWN3_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_MOUSEDOWN3_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_MOUSEDOWN3_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_MOUSEDOWN3_STATUS_DEFAULT;
|
2015-04-19 21:34:21 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_MOUSEDOWN3_BORDER;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2016-10-11 09:30:36 +00:00
|
|
|
case DOUBLE:
|
|
|
|
switch (MOUSE_BUTTONS(b)) {
|
|
|
|
case 0:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_DOUBLECLICK1_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_DOUBLECLICK1_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_DOUBLECLICK1_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_DOUBLECLICK1_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_DOUBLECLICK1_STATUS_DEFAULT;
|
2016-10-11 09:30:36 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_DOUBLECLICK1_BORDER;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_DOUBLECLICK2_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_DOUBLECLICK2_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_DOUBLECLICK2_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_DOUBLECLICK2_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_DOUBLECLICK2_STATUS_DEFAULT;
|
2016-10-11 09:30:36 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_DOUBLECLICK2_BORDER;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_DOUBLECLICK3_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_DOUBLECLICK3_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_DOUBLECLICK3_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_DOUBLECLICK3_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_DOUBLECLICK3_STATUS_DEFAULT;
|
2016-10-11 09:30:36 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_DOUBLECLICK3_BORDER;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TRIPLE:
|
|
|
|
switch (MOUSE_BUTTONS(b)) {
|
|
|
|
case 0:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_TRIPLECLICK1_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_TRIPLECLICK1_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_TRIPLECLICK1_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_TRIPLECLICK1_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_TRIPLECLICK1_STATUS_DEFAULT;
|
2016-10-11 09:30:36 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_TRIPLECLICK1_BORDER;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_TRIPLECLICK2_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_TRIPLECLICK2_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_TRIPLECLICK2_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_TRIPLECLICK2_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_TRIPLECLICK2_STATUS_DEFAULT;
|
2016-10-11 09:30:36 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_TRIPLECLICK2_BORDER;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (where == PANE)
|
|
|
|
key = KEYC_TRIPLECLICK3_PANE;
|
|
|
|
if (where == STATUS)
|
|
|
|
key = KEYC_TRIPLECLICK3_STATUS;
|
2018-08-22 20:06:14 +00:00
|
|
|
if (where == STATUS_LEFT)
|
|
|
|
key = KEYC_TRIPLECLICK3_STATUS_LEFT;
|
|
|
|
if (where == STATUS_RIGHT)
|
|
|
|
key = KEYC_TRIPLECLICK3_STATUS_RIGHT;
|
2019-03-25 18:59:55 +00:00
|
|
|
if (where == STATUS_DEFAULT)
|
|
|
|
key = KEYC_TRIPLECLICK3_STATUS_DEFAULT;
|
2016-10-11 09:30:36 +00:00
|
|
|
if (where == BORDER)
|
|
|
|
key = KEYC_TRIPLECLICK3_BORDER;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2015-04-19 21:34:21 +00:00
|
|
|
}
|
2015-12-12 18:19:00 +00:00
|
|
|
if (key == KEYC_UNKNOWN)
|
|
|
|
return (KEYC_UNKNOWN);
|
2015-04-19 21:34:21 +00:00
|
|
|
|
2020-02-19 14:25:00 +00:00
|
|
|
out:
|
2015-04-19 21:34:21 +00:00
|
|
|
/* Apply modifiers if any. */
|
|
|
|
if (b & MOUSE_MASK_META)
|
|
|
|
key |= KEYC_ESCAPE;
|
|
|
|
if (b & MOUSE_MASK_CTRL)
|
|
|
|
key |= KEYC_CTRL;
|
|
|
|
if (b & MOUSE_MASK_SHIFT)
|
|
|
|
key |= KEYC_SHIFT;
|
|
|
|
|
2020-02-19 14:25:00 +00:00
|
|
|
if (log_get_level() != 0)
|
|
|
|
log_debug("mouse key is %s", key_string_lookup_key (key));
|
2015-04-19 21:34:21 +00:00
|
|
|
return (key);
|
2012-01-29 09:37:02 +00:00
|
|
|
}
|
|
|
|
|
2013-01-15 22:55:29 +00:00
|
|
|
/* Is this fast enough to probably be a paste? */
|
2016-10-10 21:29:23 +00:00
|
|
|
static int
|
2013-01-15 22:55:29 +00:00
|
|
|
server_client_assume_paste(struct session *s)
|
|
|
|
{
|
|
|
|
struct timeval tv;
|
2013-01-30 17:00:17 +00:00
|
|
|
int t;
|
2013-01-15 22:55:29 +00:00
|
|
|
|
2015-10-27 15:58:42 +00:00
|
|
|
if ((t = options_get_number(s->options, "assume-paste-time")) == 0)
|
2013-01-18 02:10:29 +00:00
|
|
|
return (0);
|
2013-01-15 22:55:29 +00:00
|
|
|
|
|
|
|
timersub(&s->activity_time, &s->last_activity_time, &tv);
|
2015-11-19 22:46:46 +00:00
|
|
|
if (tv.tv_sec == 0 && tv.tv_usec < t * 1000) {
|
|
|
|
log_debug("session %s pasting (flag %d)", s->name,
|
|
|
|
!!(s->flags & SESSION_PASTING));
|
|
|
|
if (s->flags & SESSION_PASTING)
|
|
|
|
return (1);
|
|
|
|
s->flags |= SESSION_PASTING;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
log_debug("session %s not pasting", s->name);
|
|
|
|
s->flags &= ~SESSION_PASTING;
|
2013-01-18 02:10:29 +00:00
|
|
|
return (0);
|
2013-01-15 22:55:29 +00:00
|
|
|
}
|
|
|
|
|
2019-09-19 09:02:30 +00:00
|
|
|
/* Has the latest client changed? */
|
|
|
|
static void
|
|
|
|
server_client_update_latest(struct client *c)
|
|
|
|
{
|
|
|
|
struct window *w;
|
|
|
|
|
|
|
|
if (c->session == NULL)
|
|
|
|
return;
|
|
|
|
w = c->session->curw->window;
|
|
|
|
|
|
|
|
if (w->latest == c)
|
|
|
|
return;
|
|
|
|
w->latest = c;
|
|
|
|
|
|
|
|
if (options_get_number(w->options, "window-size") == WINDOW_SIZE_LATEST)
|
|
|
|
recalculate_size(w);
|
|
|
|
}
|
|
|
|
|
2019-05-03 14:51:30 +00:00
|
|
|
/*
|
|
|
|
* Handle data key input from client. This owns and can modify the key event it
|
|
|
|
* is given and is responsible for freeing it.
|
|
|
|
*/
|
2019-05-07 11:24:03 +00:00
|
|
|
static enum cmd_retval
|
2019-05-03 14:51:30 +00:00
|
|
|
server_client_key_callback(struct cmdq_item *item, void *data)
|
2009-11-05 08:45:08 +00:00
|
|
|
{
|
2019-05-03 14:51:30 +00:00
|
|
|
struct client *c = item->client;
|
|
|
|
struct key_event *event = data;
|
|
|
|
key_code key = event->key;
|
|
|
|
struct mouse_event *m = &event->m;
|
2019-03-12 11:16:49 +00:00
|
|
|
struct session *s = c->session;
|
|
|
|
struct winlink *wl;
|
|
|
|
struct window_pane *wp;
|
|
|
|
struct window_mode_entry *wme;
|
|
|
|
struct timeval tv;
|
|
|
|
struct key_table *table, *first;
|
|
|
|
struct key_binding *bd;
|
|
|
|
int xtimeout, flags;
|
|
|
|
struct cmd_find_state fs;
|
|
|
|
key_code key0;
|
2009-11-05 08:45:08 +00:00
|
|
|
|
|
|
|
/* Check the client is good to accept input. */
|
2020-01-28 08:06:11 +00:00
|
|
|
if (s == NULL || (c->flags & CLIENT_UNATTACHEDFLAGS))
|
2019-05-03 14:51:30 +00:00
|
|
|
goto out;
|
2018-12-18 13:20:44 +00:00
|
|
|
wl = s->curw;
|
2013-03-21 18:47:01 +00:00
|
|
|
|
2009-11-05 08:45:08 +00:00
|
|
|
/* Update the activity timer. */
|
|
|
|
if (gettimeofday(&c->activity_time, NULL) != 0)
|
|
|
|
fatal("gettimeofday failed");
|
2015-08-28 13:01:03 +00:00
|
|
|
session_update_activity(s, &c->activity_time);
|
2009-11-05 08:45:08 +00:00
|
|
|
|
|
|
|
/* Check for mouse keys. */
|
2016-11-24 18:45:45 +00:00
|
|
|
m->valid = 0;
|
2020-03-12 13:16:16 +00:00
|
|
|
if (key == KEYC_MOUSE || key == KEYC_DOUBLECLICK) {
|
2010-02-06 22:55:31 +00:00
|
|
|
if (c->flags & CLIENT_READONLY)
|
2019-05-03 14:51:30 +00:00
|
|
|
goto out;
|
|
|
|
key = server_client_check_mouse(c, event);
|
2015-12-12 18:19:00 +00:00
|
|
|
if (key == KEYC_UNKNOWN)
|
2019-05-03 14:51:30 +00:00
|
|
|
goto out;
|
2015-04-19 21:34:21 +00:00
|
|
|
|
|
|
|
m->valid = 1;
|
|
|
|
m->key = key;
|
2016-11-24 14:38:55 +00:00
|
|
|
|
|
|
|
/*
|
2016-11-24 18:45:45 +00:00
|
|
|
* Mouse drag is in progress, so fire the callback (now that
|
|
|
|
* the mouse event is valid).
|
2016-11-24 14:38:55 +00:00
|
|
|
*/
|
2020-02-19 14:25:00 +00:00
|
|
|
if ((key & KEYC_MASK_KEY) == KEYC_DRAGGING) {
|
2016-11-24 18:45:45 +00:00
|
|
|
c->tty.mouse_drag_update(c, m);
|
2019-05-03 14:51:30 +00:00
|
|
|
goto out;
|
2016-11-24 18:45:45 +00:00
|
|
|
}
|
2019-05-03 14:51:30 +00:00
|
|
|
}
|
2009-11-05 08:45:08 +00:00
|
|
|
|
2016-11-24 13:46:50 +00:00
|
|
|
/* Find affected pane. */
|
2017-08-30 10:33:57 +00:00
|
|
|
if (!KEYC_IS_MOUSE(key) || cmd_find_from_mouse(&fs, m, 0) != 0)
|
|
|
|
cmd_find_from_session(&fs, s, 0);
|
2017-04-22 08:56:24 +00:00
|
|
|
wp = fs.wp;
|
2016-11-24 13:46:50 +00:00
|
|
|
|
|
|
|
/* Forward mouse keys if disabled. */
|
2017-01-11 22:36:07 +00:00
|
|
|
if (KEYC_IS_MOUSE(key) && !options_get_number(s->options, "mouse"))
|
2018-07-17 18:02:40 +00:00
|
|
|
goto forward_key;
|
2016-11-24 13:46:50 +00:00
|
|
|
|
2015-04-20 15:34:56 +00:00
|
|
|
/* Treat everything as a regular key when pasting is detected. */
|
2015-10-26 23:16:18 +00:00
|
|
|
if (!KEYC_IS_MOUSE(key) && server_client_assume_paste(s))
|
2018-07-17 18:02:40 +00:00
|
|
|
goto forward_key;
|
2013-01-15 22:55:29 +00:00
|
|
|
|
2016-10-11 07:23:34 +00:00
|
|
|
/*
|
|
|
|
* Work out the current key table. If the pane is in a mode, use
|
|
|
|
* the mode table instead of the default key table.
|
|
|
|
*/
|
2017-04-21 16:04:18 +00:00
|
|
|
if (server_client_is_default_key_table(c, c->keytable) &&
|
|
|
|
wp != NULL &&
|
2019-03-12 11:16:49 +00:00
|
|
|
(wme = TAILQ_FIRST(&wp->modes)) != NULL &&
|
|
|
|
wme->mode->key_table != NULL)
|
|
|
|
table = key_bindings_get_table(wme->mode->key_table(wme), 1);
|
2016-10-11 07:23:34 +00:00
|
|
|
else
|
2017-04-21 16:04:18 +00:00
|
|
|
table = c->keytable;
|
|
|
|
first = table;
|
2016-10-11 07:23:34 +00:00
|
|
|
|
2018-07-17 18:02:40 +00:00
|
|
|
table_changed:
|
2016-12-07 09:16:13 +00:00
|
|
|
/*
|
|
|
|
* The prefix always takes precedence and forces a switch to the prefix
|
|
|
|
* table, unless we are already there.
|
|
|
|
*/
|
2017-06-13 07:12:33 +00:00
|
|
|
key0 = (key & ~KEYC_XTERM);
|
|
|
|
if ((key0 == (key_code)options_get_number(s->options, "prefix") ||
|
|
|
|
key0 == (key_code)options_get_number(s->options, "prefix2")) &&
|
2016-12-07 09:16:13 +00:00
|
|
|
strcmp(table->name, "prefix") != 0) {
|
|
|
|
server_client_set_key_table(c, "prefix");
|
|
|
|
server_status_client(c);
|
2019-05-03 14:51:30 +00:00
|
|
|
goto out;
|
2016-12-07 09:16:13 +00:00
|
|
|
}
|
2017-06-06 15:49:35 +00:00
|
|
|
flags = c->flags;
|
2016-12-07 09:16:13 +00:00
|
|
|
|
2018-11-07 08:06:28 +00:00
|
|
|
try_again:
|
2017-04-21 16:04:18 +00:00
|
|
|
/* Log key table. */
|
|
|
|
if (wp == NULL)
|
|
|
|
log_debug("key table %s (no pane)", table->name);
|
|
|
|
else
|
|
|
|
log_debug("key table %s (pane %%%u)", table->name, wp->id);
|
2017-04-21 19:33:07 +00:00
|
|
|
if (c->flags & CLIENT_REPEAT)
|
|
|
|
log_debug("currently repeating");
|
2017-04-21 16:04:18 +00:00
|
|
|
|
2015-04-20 15:34:56 +00:00
|
|
|
/* Try to see if there is a key binding in the current table. */
|
2018-08-02 11:44:07 +00:00
|
|
|
bd = key_bindings_get(table, key0);
|
2015-04-20 15:34:56 +00:00
|
|
|
if (bd != NULL) {
|
|
|
|
/*
|
|
|
|
* Key was matched in this table. If currently repeating but a
|
|
|
|
* non-repeating binding was found, stop repeating and try
|
|
|
|
* again in the root table.
|
|
|
|
*/
|
2017-04-21 14:01:19 +00:00
|
|
|
if ((c->flags & CLIENT_REPEAT) &&
|
|
|
|
(~bd->flags & KEY_BINDING_REPEAT)) {
|
2018-11-07 08:06:28 +00:00
|
|
|
log_debug("found in key table %s (not repeating)",
|
|
|
|
table->name);
|
2015-12-12 18:32:24 +00:00
|
|
|
server_client_set_key_table(c, NULL);
|
2018-11-07 08:06:28 +00:00
|
|
|
first = table = c->keytable;
|
2015-04-20 15:34:56 +00:00
|
|
|
c->flags &= ~CLIENT_REPEAT;
|
2013-03-21 16:14:09 +00:00
|
|
|
server_status_client(c);
|
2018-07-17 18:02:40 +00:00
|
|
|
goto table_changed;
|
2009-11-05 08:45:08 +00:00
|
|
|
}
|
2017-04-21 16:04:18 +00:00
|
|
|
log_debug("found in key table %s", table->name);
|
2013-01-15 22:55:29 +00:00
|
|
|
|
2015-04-20 15:34:56 +00:00
|
|
|
/*
|
|
|
|
* Take a reference to this table to make sure the key binding
|
|
|
|
* doesn't disappear.
|
|
|
|
*/
|
|
|
|
table->references++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a repeating key, start the timer. Otherwise reset
|
|
|
|
* the client back to the root table.
|
|
|
|
*/
|
2015-10-27 15:58:42 +00:00
|
|
|
xtimeout = options_get_number(s->options, "repeat-time");
|
2017-04-21 14:01:19 +00:00
|
|
|
if (xtimeout != 0 && (bd->flags & KEY_BINDING_REPEAT)) {
|
2015-04-20 15:34:56 +00:00
|
|
|
c->flags |= CLIENT_REPEAT;
|
|
|
|
|
|
|
|
tv.tv_sec = xtimeout / 1000;
|
|
|
|
tv.tv_usec = (xtimeout % 1000) * 1000L;
|
|
|
|
evtimer_del(&c->repeat_timer);
|
|
|
|
evtimer_add(&c->repeat_timer, &tv);
|
|
|
|
} else {
|
2009-11-05 08:45:08 +00:00
|
|
|
c->flags &= ~CLIENT_REPEAT;
|
2015-12-12 18:32:24 +00:00
|
|
|
server_client_set_key_table(c, NULL);
|
2009-11-05 08:45:08 +00:00
|
|
|
}
|
2015-04-20 15:34:56 +00:00
|
|
|
server_status_client(c);
|
|
|
|
|
2017-04-22 08:56:24 +00:00
|
|
|
/* Execute the key binding. */
|
2019-05-03 14:51:30 +00:00
|
|
|
key_bindings_dispatch(bd, item, c, m, &fs);
|
2015-04-20 15:34:56 +00:00
|
|
|
key_bindings_unref_table(table);
|
2019-05-03 14:51:30 +00:00
|
|
|
goto out;
|
2009-11-05 08:45:08 +00:00
|
|
|
}
|
|
|
|
|
2015-04-20 15:34:56 +00:00
|
|
|
/*
|
2018-07-17 18:02:40 +00:00
|
|
|
* No match, try the ANY key.
|
2015-04-20 15:34:56 +00:00
|
|
|
*/
|
2018-07-16 08:48:22 +00:00
|
|
|
if (key0 != KEYC_ANY) {
|
|
|
|
key0 = KEYC_ANY;
|
2018-07-17 18:02:40 +00:00
|
|
|
goto try_again;
|
2018-07-16 08:48:22 +00:00
|
|
|
}
|
2018-07-17 18:02:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* No match in this table. If not in the root table or if repeating,
|
|
|
|
* switch the client back to the root table and try again.
|
|
|
|
*/
|
|
|
|
log_debug("not found in key table %s", table->name);
|
2017-04-21 16:04:18 +00:00
|
|
|
if (!server_client_is_default_key_table(c, table) ||
|
|
|
|
(c->flags & CLIENT_REPEAT)) {
|
2018-11-07 08:06:28 +00:00
|
|
|
log_debug("trying in root table");
|
2015-12-12 18:32:24 +00:00
|
|
|
server_client_set_key_table(c, NULL);
|
2018-11-07 08:06:28 +00:00
|
|
|
table = c->keytable;
|
|
|
|
if (c->flags & CLIENT_REPEAT)
|
|
|
|
first = table;
|
2009-11-05 08:45:08 +00:00
|
|
|
c->flags &= ~CLIENT_REPEAT;
|
2015-04-20 15:34:56 +00:00
|
|
|
server_status_client(c);
|
2018-07-17 18:02:40 +00:00
|
|
|
goto table_changed;
|
2009-11-05 08:45:08 +00:00
|
|
|
}
|
|
|
|
|
2017-04-21 16:04:18 +00:00
|
|
|
/*
|
|
|
|
* No match in the root table either. If this wasn't the first table
|
|
|
|
* tried, don't pass the key to the pane.
|
|
|
|
*/
|
2017-06-06 15:49:35 +00:00
|
|
|
if (first != table && (~flags & CLIENT_REPEAT)) {
|
2015-12-12 18:32:24 +00:00
|
|
|
server_client_set_key_table(c, NULL);
|
2015-04-20 15:34:56 +00:00
|
|
|
server_status_client(c);
|
2019-05-03 14:51:30 +00:00
|
|
|
goto out;
|
2009-11-05 08:45:08 +00:00
|
|
|
}
|
|
|
|
|
2018-07-17 18:02:40 +00:00
|
|
|
forward_key:
|
2015-10-26 23:16:18 +00:00
|
|
|
if (c->flags & CLIENT_READONLY)
|
2019-05-03 14:51:30 +00:00
|
|
|
goto out;
|
2015-10-26 23:16:18 +00:00
|
|
|
if (wp != NULL)
|
2018-12-18 13:20:44 +00:00
|
|
|
window_pane_key(wp, c, s, wl, key, m);
|
2019-05-03 14:51:30 +00:00
|
|
|
|
|
|
|
out:
|
2019-09-19 09:02:30 +00:00
|
|
|
if (s != NULL)
|
|
|
|
server_client_update_latest(c);
|
2019-05-03 14:51:30 +00:00
|
|
|
free(event);
|
|
|
|
return (CMD_RETURN_NORMAL);
|
2009-11-05 08:45:08 +00:00
|
|
|
}
|
|
|
|
|
2019-05-07 11:24:03 +00:00
|
|
|
/* Handle a key event. */
|
|
|
|
int
|
|
|
|
server_client_handle_key(struct client *c, struct key_event *event)
|
|
|
|
{
|
|
|
|
struct session *s = c->session;
|
|
|
|
struct cmdq_item *item;
|
|
|
|
|
|
|
|
/* Check the client is good to accept input. */
|
2020-01-28 08:06:11 +00:00
|
|
|
if (s == NULL || (c->flags & CLIENT_UNATTACHEDFLAGS))
|
2019-05-07 11:24:03 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
/*
|
2019-07-02 20:09:19 +00:00
|
|
|
* Key presses in overlay mode and the command prompt are a special
|
|
|
|
* case. The queue might be blocked so they need to be processed
|
|
|
|
* immediately rather than queued.
|
2019-05-07 11:24:03 +00:00
|
|
|
*/
|
2019-07-02 20:09:19 +00:00
|
|
|
if (~c->flags & CLIENT_READONLY) {
|
|
|
|
status_message_clear(c);
|
|
|
|
if (c->prompt_string != NULL) {
|
|
|
|
if (status_prompt_key(c, event->key) == 0)
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
if (c->overlay_key != NULL) {
|
|
|
|
switch (c->overlay_key(c, event)) {
|
|
|
|
case 0:
|
|
|
|
return (0);
|
|
|
|
case 1:
|
|
|
|
server_client_clear_overlay(c);
|
|
|
|
return (0);
|
|
|
|
}
|
2019-06-26 18:28:31 +00:00
|
|
|
}
|
2019-07-17 17:46:51 +00:00
|
|
|
server_client_clear_overlay(c);
|
2019-05-07 11:24:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add the key to the queue so it happens after any commands queued by
|
|
|
|
* previous keys.
|
|
|
|
*/
|
|
|
|
item = cmdq_get_callback(server_client_key_callback, event);
|
|
|
|
cmdq_append(c, item);
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2009-10-22 20:04:21 +00:00
|
|
|
/* Client functions that need to happen every loop. */
|
|
|
|
void
|
|
|
|
server_client_loop(void)
|
|
|
|
{
|
|
|
|
struct client *c;
|
|
|
|
struct window *w;
|
|
|
|
struct window_pane *wp;
|
2019-06-11 13:09:00 +00:00
|
|
|
struct winlink *wl;
|
|
|
|
struct session *s;
|
2019-11-01 20:26:21 +00:00
|
|
|
int focus, attached, resize;
|
2009-10-22 20:04:21 +00:00
|
|
|
|
2015-04-24 23:17:11 +00:00
|
|
|
TAILQ_FOREACH(c, &clients, entry) {
|
2010-07-24 20:11:59 +00:00
|
|
|
server_client_check_exit(c);
|
|
|
|
if (c->session != NULL) {
|
|
|
|
server_client_check_redraw(c);
|
|
|
|
server_client_reset_state(c);
|
|
|
|
}
|
2009-10-22 20:04:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Any windows will have been redrawn as part of clients, so clear
|
2013-03-24 09:28:59 +00:00
|
|
|
* their flags now. Also check pane focus and resize.
|
2019-11-01 20:26:21 +00:00
|
|
|
*
|
|
|
|
* As an optimization, panes in windows that are in an attached session
|
|
|
|
* but not the current window are not resized (this reduces the amount
|
|
|
|
* of work needed when, for example, resizing an X terminal a
|
|
|
|
* lot). Windows in no attached session are resized immediately since
|
|
|
|
* that is likely to have come from a command like split-window and be
|
|
|
|
* what the user wanted.
|
2009-10-22 20:04:21 +00:00
|
|
|
*/
|
2016-10-19 09:22:07 +00:00
|
|
|
focus = options_get_number(global_options, "focus-events");
|
2015-04-22 15:30:11 +00:00
|
|
|
RB_FOREACH(w, windows, &windows) {
|
2019-11-01 20:26:21 +00:00
|
|
|
attached = resize = 0;
|
2019-06-11 13:09:00 +00:00
|
|
|
TAILQ_FOREACH(wl, &w->winlinks, wentry) {
|
|
|
|
s = wl->session;
|
2019-11-01 20:26:21 +00:00
|
|
|
if (s->attached != 0)
|
|
|
|
attached = 1;
|
|
|
|
if (s->attached != 0 && s->curw == wl) {
|
|
|
|
resize = 1;
|
2019-06-11 13:09:00 +00:00
|
|
|
break;
|
2019-11-01 20:26:21 +00:00
|
|
|
}
|
2019-06-11 13:09:00 +00:00
|
|
|
}
|
2019-11-01 20:26:21 +00:00
|
|
|
if (!attached)
|
|
|
|
resize = 1;
|
2013-03-24 09:28:59 +00:00
|
|
|
TAILQ_FOREACH(wp, &w->panes, entry) {
|
2019-06-20 19:29:38 +00:00
|
|
|
if (wp->fd != -1) {
|
2016-10-19 09:22:07 +00:00
|
|
|
if (focus)
|
|
|
|
server_client_check_focus(wp);
|
2019-11-01 20:26:21 +00:00
|
|
|
if (resize)
|
2019-06-20 19:29:38 +00:00
|
|
|
server_client_check_resize(wp);
|
2013-04-21 21:32:00 +00:00
|
|
|
}
|
2009-10-22 20:04:21 +00:00
|
|
|
wp->flags &= ~PANE_REDRAW;
|
2013-03-24 09:28:59 +00:00
|
|
|
}
|
2015-08-29 08:54:41 +00:00
|
|
|
check_window_name(w);
|
2013-03-24 09:28:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-31 11:00:00 +00:00
|
|
|
/* Check if we need to force a resize. */
|
|
|
|
static int
|
|
|
|
server_client_resize_force(struct window_pane *wp)
|
|
|
|
{
|
|
|
|
struct timeval tv = { .tv_usec = 100000 };
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are resizing to the same size as when we entered the loop
|
|
|
|
* (that is, to the same size the application currently thinks it is),
|
|
|
|
* tmux may have gone through several resizes internally and thrown
|
|
|
|
* away parts of the screen. So we need the application to actually
|
|
|
|
* redraw even though its final size has not changed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (wp->flags & PANE_RESIZEFORCE) {
|
|
|
|
wp->flags &= ~PANE_RESIZEFORCE;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wp->sx != wp->osx ||
|
|
|
|
wp->sy != wp->osy ||
|
|
|
|
wp->sx <= 1 ||
|
|
|
|
wp->sy <= 1)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
log_debug("%s: %%%u forcing resize", __func__, wp->id);
|
2019-11-28 09:45:15 +00:00
|
|
|
window_pane_send_resize(wp, -1);
|
2017-05-31 11:00:00 +00:00
|
|
|
|
|
|
|
evtimer_add(&wp->resize_timer, &tv);
|
|
|
|
wp->flags |= PANE_RESIZEFORCE;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2019-08-28 07:34:32 +00:00
|
|
|
/* Resize a pane. */
|
2016-09-28 08:30:44 +00:00
|
|
|
static void
|
2019-08-28 07:34:32 +00:00
|
|
|
server_client_resize_pane(struct window_pane *wp)
|
2013-03-24 09:28:59 +00:00
|
|
|
{
|
2017-05-31 10:15:51 +00:00
|
|
|
log_debug("%s: %%%u resize to %u,%u", __func__, wp->id, wp->sx, wp->sy);
|
2019-11-28 09:45:15 +00:00
|
|
|
window_pane_send_resize(wp, 0);
|
2013-03-24 09:28:59 +00:00
|
|
|
|
|
|
|
wp->flags &= ~PANE_RESIZE;
|
2017-05-31 10:15:51 +00:00
|
|
|
|
|
|
|
wp->osx = wp->sx;
|
|
|
|
wp->osy = wp->sy;
|
2013-03-24 09:28:59 +00:00
|
|
|
}
|
|
|
|
|
2019-08-28 07:34:32 +00:00
|
|
|
/* Start the resize timer. */
|
|
|
|
static void
|
|
|
|
server_client_start_resize_timer(struct window_pane *wp)
|
|
|
|
{
|
|
|
|
struct timeval tv = { .tv_usec = 250000 };
|
|
|
|
|
|
|
|
if (!evtimer_pending(&wp->resize_timer, NULL))
|
|
|
|
evtimer_add(&wp->resize_timer, &tv);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Resize timer event. */
|
|
|
|
static void
|
|
|
|
server_client_resize_event(__unused int fd, __unused short events, void *data)
|
|
|
|
{
|
|
|
|
struct window_pane *wp = data;
|
|
|
|
|
|
|
|
evtimer_del(&wp->resize_timer);
|
|
|
|
|
|
|
|
if (~wp->flags & PANE_RESIZE)
|
|
|
|
return;
|
|
|
|
log_debug("%s: %%%u timer fired (was%s resized)", __func__, wp->id,
|
|
|
|
(wp->flags & PANE_RESIZED) ? "" : " not");
|
|
|
|
|
|
|
|
if (wp->saved_grid == NULL && (wp->flags & PANE_RESIZED)) {
|
|
|
|
log_debug("%s: %%%u deferring timer", __func__, wp->id);
|
|
|
|
server_client_start_resize_timer(wp);
|
|
|
|
} else if (!server_client_resize_force(wp)) {
|
|
|
|
log_debug("%s: %%%u resizing pane", __func__, wp->id);
|
|
|
|
server_client_resize_pane(wp);
|
|
|
|
}
|
|
|
|
wp->flags &= ~PANE_RESIZED;
|
|
|
|
}
|
|
|
|
|
2016-09-28 08:30:44 +00:00
|
|
|
/* Check if pane should be resized. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2016-09-28 08:30:44 +00:00
|
|
|
server_client_check_resize(struct window_pane *wp)
|
|
|
|
{
|
2019-08-28 07:34:32 +00:00
|
|
|
if (~wp->flags & PANE_RESIZE)
|
2016-09-28 08:30:44 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (!event_initialized(&wp->resize_timer))
|
|
|
|
evtimer_set(&wp->resize_timer, server_client_resize_event, wp);
|
|
|
|
|
2019-08-28 07:34:32 +00:00
|
|
|
if (!evtimer_pending(&wp->resize_timer, NULL)) {
|
|
|
|
log_debug("%s: %%%u starting timer", __func__, wp->id);
|
|
|
|
server_client_resize_pane(wp);
|
|
|
|
server_client_start_resize_timer(wp);
|
|
|
|
} else
|
|
|
|
log_debug("%s: %%%u timer running", __func__, wp->id);
|
2016-09-28 08:30:44 +00:00
|
|
|
}
|
|
|
|
|
2013-03-24 09:28:59 +00:00
|
|
|
/* Check whether pane should be focused. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2013-03-24 09:28:59 +00:00
|
|
|
server_client_check_focus(struct window_pane *wp)
|
|
|
|
{
|
|
|
|
struct client *c;
|
2013-06-23 13:10:46 +00:00
|
|
|
int push;
|
|
|
|
|
|
|
|
/* Do we need to push the focus state? */
|
|
|
|
push = wp->flags & PANE_FOCUSPUSH;
|
|
|
|
wp->flags &= ~PANE_FOCUSPUSH;
|
2013-03-24 09:28:59 +00:00
|
|
|
|
|
|
|
/* If we're not the active pane in our window, we're not focused. */
|
|
|
|
if (wp->window->active != wp)
|
|
|
|
goto not_focused;
|
|
|
|
|
|
|
|
/* If we're in a mode, we're not focused. */
|
|
|
|
if (wp->screen != &wp->base)
|
|
|
|
goto not_focused;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If our window is the current window in any focused clients with an
|
|
|
|
* attached session, we're focused.
|
|
|
|
*/
|
2015-04-24 23:17:11 +00:00
|
|
|
TAILQ_FOREACH(c, &clients, entry) {
|
|
|
|
if (c->session == NULL || !(c->flags & CLIENT_FOCUSED))
|
2013-03-24 09:28:59 +00:00
|
|
|
continue;
|
2018-08-18 20:08:52 +00:00
|
|
|
if (c->session->attached == 0)
|
2013-03-24 09:28:59 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (c->session->curw->window == wp->window)
|
|
|
|
goto focused;
|
2009-10-22 20:04:21 +00:00
|
|
|
}
|
2013-03-24 09:28:59 +00:00
|
|
|
|
|
|
|
not_focused:
|
2018-07-04 12:25:26 +00:00
|
|
|
if (push || (wp->flags & PANE_FOCUSED)) {
|
|
|
|
if (wp->base.mode & MODE_FOCUSON)
|
|
|
|
bufferevent_write(wp->event, "\033[O", 3);
|
|
|
|
notify_pane("pane-focus-out", wp);
|
|
|
|
}
|
2013-03-24 09:28:59 +00:00
|
|
|
wp->flags &= ~PANE_FOCUSED;
|
|
|
|
return;
|
|
|
|
|
|
|
|
focused:
|
2018-07-04 12:25:26 +00:00
|
|
|
if (push || !(wp->flags & PANE_FOCUSED)) {
|
|
|
|
if (wp->base.mode & MODE_FOCUSON)
|
|
|
|
bufferevent_write(wp->event, "\033[I", 3);
|
|
|
|
notify_pane("pane-focus-in", wp);
|
2019-04-18 10:11:52 +00:00
|
|
|
session_update_activity(c->session, NULL);
|
2018-07-04 12:25:26 +00:00
|
|
|
}
|
2013-03-24 09:28:59 +00:00
|
|
|
wp->flags |= PANE_FOCUSED;
|
2009-10-22 20:04:21 +00:00
|
|
|
}
|
|
|
|
|
2009-11-05 08:45:08 +00:00
|
|
|
/*
|
|
|
|
* Update cursor position and mode settings. The scroll region and attributes
|
|
|
|
* are cleared when idle (waiting for an event) as this is the most likely time
|
|
|
|
* a user may interrupt tmux, for example with ~^Z in ssh(1). This is a
|
|
|
|
* compromise between excessive resets and likelihood of an interrupt.
|
|
|
|
*
|
|
|
|
* tty_region/tty_reset/tty_update_mode already take care of not resetting
|
|
|
|
* things that are already in their default state.
|
|
|
|
*/
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2009-11-05 08:45:08 +00:00
|
|
|
server_client_reset_state(struct client *c)
|
2009-10-22 19:41:51 +00:00
|
|
|
{
|
2009-11-05 08:45:08 +00:00
|
|
|
struct window *w = c->session->curw->window;
|
2017-02-01 09:55:07 +00:00
|
|
|
struct window_pane *wp = w->active, *loop;
|
2009-11-05 08:45:08 +00:00
|
|
|
struct screen *s = wp->screen;
|
2015-10-27 15:58:42 +00:00
|
|
|
struct options *oo = c->session->options;
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
int mode, cursor = 0;
|
|
|
|
u_int cx = 0, cy = 0, ox, oy, sx, sy;
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2016-04-30 18:59:02 +00:00
|
|
|
if (c->flags & (CLIENT_CONTROL|CLIENT_SUSPENDED))
|
2013-03-21 18:47:01 +00:00
|
|
|
return;
|
2019-05-08 18:07:12 +00:00
|
|
|
if (c->overlay_draw != NULL)
|
|
|
|
return;
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
mode = s->mode;
|
2013-03-21 18:47:01 +00:00
|
|
|
|
2016-11-15 15:17:28 +00:00
|
|
|
tty_region_off(&c->tty);
|
|
|
|
tty_margin_off(&c->tty);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
Support for windows larger than visible on the attached client. This has
been a limitation for a long time.
There are two new options, window-size and default-size, and a new
command, resize-window. The force-width and force-height options and the
session_width and session_height formats have been removed.
The new window-size option tells tmux how to work out the size of
windows: largest means it picks the size of the largest session,
smallest the smallest session (similar to the old behaviour) and manual
means that it does not automatically resize windows. The default is
currently largest but this may change. aggressive-resize modifies the
choice of session for largest and smallest as it did before.
If a window is in a session attached to a client that is too small, only
part of the window is shown. tmux attempts to keep the cursor visible,
so the part of the window displayed is changed as the cursor moves (with
a small delay, to try and avoid excess redrawing when applications
redraw status lines or similar that are not currently visible). The
offset of the visible portion of the window is shown in status-right.
Drawing windows which are larger than the client is not as efficient as
those which fit, particularly when the cursor moves, so it is
recommended to avoid using this on slow machines or networks (set
window-size to smallest or manual).
The resize-window command can be used to resize a window manually. If it
is used, the window-size option is automatically set to manual for the
window (undo this with "setw -u window-size"). resize-window works in a
similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and
-A flags. -a sets the window to the size of the smallest client (what it
would be if window-size was smallest) and -A the largest.
For the same behaviour as force-width or force-height, use resize-window
-x or -y, and "setw -u window-size" to revert to automatic sizing..
If the global window-size option is set to manual, the default-size
option is used for new windows. If -x or -y is used with new-session,
that sets the default-size option for the new session.
The maximum size of a window is 10000x10000. But expect applications to
complain and much higher memory use if making a window excessively
big. The minimum size is the size required for the current layout
including borders.
The refresh-client command can be used to pan around a window, -U -D -L
-R moves up, down, left or right and -c returns to automatic cursor
tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
|
|
|
/* Move cursor to pane cursor and offset. */
|
|
|
|
cursor = 0;
|
|
|
|
tty_window_offset(&c->tty, &ox, &oy, &sx, &sy);
|
|
|
|
if (wp->xoff + s->cx >= ox && wp->xoff + s->cx <= ox + sx &&
|
|
|
|
wp->yoff + s->cy >= oy && wp->yoff + s->cy <= oy + sy) {
|
|
|
|
cursor = 1;
|
|
|
|
|
|
|
|
cx = wp->xoff + s->cx - ox;
|
|
|
|
cy = wp->yoff + s->cy - oy;
|
|
|
|
|
|
|
|
if (status_at_line(c) == 0)
|
|
|
|
cy += status_line_size(c);
|
|
|
|
}
|
|
|
|
if (!cursor)
|
|
|
|
mode &= ~MODE_CURSOR;
|
|
|
|
tty_cursor(&c->tty, cx, cy);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2011-05-08 20:34:12 +00:00
|
|
|
/*
|
2015-04-19 21:34:21 +00:00
|
|
|
* Set mouse mode if requested. To support dragging, always use button
|
|
|
|
* mode.
|
2011-05-08 20:34:12 +00:00
|
|
|
*/
|
2017-02-01 09:55:07 +00:00
|
|
|
if (options_get_number(oo, "mouse")) {
|
|
|
|
mode &= ~ALL_MOUSE_MODES;
|
|
|
|
TAILQ_FOREACH(loop, &w->panes, entry) {
|
|
|
|
if (loop->screen->mode & MODE_MOUSE_ALL)
|
|
|
|
mode |= MODE_MOUSE_ALL;
|
|
|
|
}
|
|
|
|
if (~mode & MODE_MOUSE_ALL)
|
|
|
|
mode |= MODE_MOUSE_BUTTON;
|
|
|
|
}
|
2011-01-03 23:35:21 +00:00
|
|
|
|
2017-03-09 22:00:46 +00:00
|
|
|
/* Clear bracketed paste mode if at the prompt. */
|
|
|
|
if (c->prompt_string != NULL)
|
|
|
|
mode &= ~MODE_BRACKETPASTE;
|
|
|
|
|
2011-01-03 23:35:21 +00:00
|
|
|
/* Set the terminal mode and reset attributes. */
|
2011-05-20 19:03:58 +00:00
|
|
|
tty_update_mode(&c->tty, mode, s);
|
2009-10-22 19:41:51 +00:00
|
|
|
tty_reset(&c->tty);
|
|
|
|
}
|
|
|
|
|
2009-11-05 00:05:00 +00:00
|
|
|
/* Repeat time callback. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2015-11-18 14:27:44 +00:00
|
|
|
server_client_repeat_timer(__unused int fd, __unused short events, void *data)
|
2009-11-05 00:05:00 +00:00
|
|
|
{
|
|
|
|
struct client *c = data;
|
|
|
|
|
2013-03-21 16:14:09 +00:00
|
|
|
if (c->flags & CLIENT_REPEAT) {
|
2015-12-12 18:32:24 +00:00
|
|
|
server_client_set_key_table(c, NULL);
|
2015-04-20 15:34:56 +00:00
|
|
|
c->flags &= ~CLIENT_REPEAT;
|
|
|
|
server_status_client(c);
|
2013-03-21 16:14:09 +00:00
|
|
|
}
|
2009-11-05 00:05:00 +00:00
|
|
|
}
|
|
|
|
|
2016-10-11 09:30:36 +00:00
|
|
|
/* Double-click callback. */
|
|
|
|
static void
|
|
|
|
server_client_click_timer(__unused int fd, __unused short events, void *data)
|
|
|
|
{
|
2020-03-12 13:16:16 +00:00
|
|
|
struct client *c = data;
|
|
|
|
struct key_event *event;
|
|
|
|
|
|
|
|
log_debug("click timer expired");
|
2016-10-11 09:30:36 +00:00
|
|
|
|
2020-03-12 13:16:16 +00:00
|
|
|
if (c->flags & CLIENT_TRIPLECLICK) {
|
|
|
|
/*
|
|
|
|
* Waiting for a third click that hasn't happened, so this must
|
|
|
|
* have been a double click.
|
|
|
|
*/
|
|
|
|
event = xmalloc(sizeof *event);
|
|
|
|
event->key = KEYC_DOUBLECLICK;
|
|
|
|
memcpy(&event->m, &c->click_event, sizeof event->m);
|
|
|
|
if (!server_client_handle_key(c, event))
|
|
|
|
free(event);
|
|
|
|
}
|
2016-10-11 09:30:36 +00:00
|
|
|
c->flags &= ~(CLIENT_DOUBLECLICK|CLIENT_TRIPLECLICK);
|
|
|
|
}
|
|
|
|
|
2010-07-24 20:11:59 +00:00
|
|
|
/* Check if client should be exited. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2010-07-24 20:11:59 +00:00
|
|
|
server_client_check_exit(struct client *c)
|
|
|
|
{
|
2019-12-12 11:39:56 +00:00
|
|
|
struct client_file *cf;
|
|
|
|
|
2019-06-07 20:09:17 +00:00
|
|
|
if (~c->flags & CLIENT_EXIT)
|
|
|
|
return;
|
|
|
|
if (c->flags & CLIENT_EXITED)
|
2010-07-24 20:11:59 +00:00
|
|
|
return;
|
|
|
|
|
2019-12-12 11:39:56 +00:00
|
|
|
RB_FOREACH(cf, client_files, &c->files) {
|
|
|
|
if (EVBUFFER_LENGTH(cf->buffer) != 0)
|
|
|
|
return;
|
|
|
|
}
|
2010-07-24 20:11:59 +00:00
|
|
|
|
2018-03-08 08:09:10 +00:00
|
|
|
if (c->flags & CLIENT_ATTACHED)
|
|
|
|
notify_client("client-detached", c);
|
2015-10-27 13:23:24 +00:00
|
|
|
proc_send(c->peer, MSG_EXIT, -1, &c->retval, sizeof c->retval);
|
2019-06-07 20:09:17 +00:00
|
|
|
c->flags |= CLIENT_EXITED;
|
2010-07-24 20:11:59 +00:00
|
|
|
}
|
|
|
|
|
2017-04-18 20:37:49 +00:00
|
|
|
/* Redraw timer callback. */
|
|
|
|
static void
|
|
|
|
server_client_redraw_timer(__unused int fd, __unused short events,
|
2019-12-03 10:47:22 +00:00
|
|
|
__unused void *data)
|
2017-04-18 20:37:49 +00:00
|
|
|
{
|
|
|
|
log_debug("redraw timer fired");
|
|
|
|
}
|
|
|
|
|
2009-10-22 19:41:51 +00:00
|
|
|
/* Check for client redraws. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2009-10-22 19:41:51 +00:00
|
|
|
server_client_check_redraw(struct client *c)
|
|
|
|
{
|
|
|
|
struct session *s = c->session;
|
2015-05-06 07:52:06 +00:00
|
|
|
struct tty *tty = &c->tty;
|
2009-10-22 19:41:51 +00:00
|
|
|
struct window_pane *wp;
|
2018-08-19 16:45:03 +00:00
|
|
|
int needed, flags;
|
2017-04-18 20:37:49 +00:00
|
|
|
struct timeval tv = { .tv_usec = 1000 };
|
|
|
|
static struct event ev;
|
|
|
|
size_t left;
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2013-03-21 18:47:01 +00:00
|
|
|
if (c->flags & (CLIENT_CONTROL|CLIENT_SUSPENDED))
|
2012-09-03 09:32:38 +00:00
|
|
|
return;
|
2018-08-19 20:13:07 +00:00
|
|
|
if (c->flags & CLIENT_ALLREDRAWFLAGS) {
|
2019-05-08 18:07:12 +00:00
|
|
|
log_debug("%s: redraw%s%s%s%s", c->name,
|
2018-08-19 20:13:07 +00:00
|
|
|
(c->flags & CLIENT_REDRAWWINDOW) ? " window" : "",
|
|
|
|
(c->flags & CLIENT_REDRAWSTATUS) ? " status" : "",
|
2019-05-08 18:07:12 +00:00
|
|
|
(c->flags & CLIENT_REDRAWBORDERS) ? " borders" : "",
|
|
|
|
(c->flags & CLIENT_REDRAWOVERLAY) ? " overlay" : "");
|
2018-08-19 20:13:07 +00:00
|
|
|
}
|
2012-09-03 09:32:38 +00:00
|
|
|
|
2017-04-18 20:37:49 +00:00
|
|
|
/*
|
|
|
|
* If there is outstanding data, defer the redraw until it has been
|
|
|
|
* consumed. We can just add a timer to get out of the event loop and
|
|
|
|
* end up back here.
|
|
|
|
*/
|
|
|
|
needed = 0;
|
2018-08-19 16:45:03 +00:00
|
|
|
if (c->flags & CLIENT_ALLREDRAWFLAGS)
|
2017-04-18 20:37:49 +00:00
|
|
|
needed = 1;
|
|
|
|
else {
|
|
|
|
TAILQ_FOREACH(wp, &c->session->curw->window->panes, entry) {
|
|
|
|
if (wp->flags & PANE_REDRAW) {
|
|
|
|
needed = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-07-14 08:04:23 +00:00
|
|
|
if (needed && (left = EVBUFFER_LENGTH(tty->out)) != 0) {
|
|
|
|
log_debug("%s: redraw deferred (%zu left)", c->name, left);
|
|
|
|
if (!evtimer_initialized(&ev))
|
2017-04-18 20:37:49 +00:00
|
|
|
evtimer_set(&ev, server_client_redraw_timer, NULL);
|
2017-07-14 08:04:23 +00:00
|
|
|
if (!evtimer_pending(&ev, NULL)) {
|
|
|
|
log_debug("redraw timer started");
|
2017-04-18 20:37:49 +00:00
|
|
|
evtimer_add(&ev, &tv);
|
|
|
|
}
|
2017-07-14 08:04:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We may have got here for a single pane redraw, but force a
|
|
|
|
* full redraw next time in case other panes have been updated.
|
|
|
|
*/
|
2018-08-19 16:45:03 +00:00
|
|
|
c->flags |= CLIENT_ALLREDRAWFLAGS;
|
2017-07-14 08:04:23 +00:00
|
|
|
return;
|
|
|
|
} else if (needed)
|
2017-04-18 20:37:49 +00:00
|
|
|
log_debug("%s: redraw needed", c->name);
|
|
|
|
|
2017-04-19 06:52:27 +00:00
|
|
|
flags = tty->flags & (TTY_BLOCK|TTY_FREEZE|TTY_NOCURSOR);
|
|
|
|
tty->flags = (tty->flags & ~(TTY_BLOCK|TTY_FREEZE)) | TTY_NOCURSOR;
|
2015-05-06 07:52:06 +00:00
|
|
|
|
2018-08-19 16:45:03 +00:00
|
|
|
if (~c->flags & CLIENT_REDRAWWINDOW) {
|
|
|
|
/*
|
|
|
|
* If not redrawing the entire window, check whether each pane
|
|
|
|
* needs to be redrawn.
|
|
|
|
*/
|
2009-10-22 19:41:51 +00:00
|
|
|
TAILQ_FOREACH(wp, &c->session->curw->window->panes, entry) {
|
2015-05-06 07:52:06 +00:00
|
|
|
if (wp->flags & PANE_REDRAW) {
|
|
|
|
tty_update_mode(tty, tty->mode, NULL);
|
2009-10-22 19:41:51 +00:00
|
|
|
screen_redraw_pane(c, wp);
|
2015-05-06 07:52:06 +00:00
|
|
|
}
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-19 16:45:03 +00:00
|
|
|
if (c->flags & CLIENT_ALLREDRAWFLAGS) {
|
|
|
|
if (options_get_number(s->options, "set-titles"))
|
|
|
|
server_client_set_title(c);
|
|
|
|
screen_redraw_screen(c);
|
|
|
|
}
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-05-06 07:52:06 +00:00
|
|
|
tty->flags = (tty->flags & ~(TTY_FREEZE|TTY_NOCURSOR)) | flags;
|
|
|
|
tty_update_mode(tty, tty->mode, NULL);
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2018-08-19 16:45:03 +00:00
|
|
|
c->flags &= ~(CLIENT_ALLREDRAWFLAGS|CLIENT_STATUSFORCE);
|
2017-05-09 13:04:36 +00:00
|
|
|
|
|
|
|
if (needed) {
|
|
|
|
/*
|
|
|
|
* We would have deferred the redraw unless the output buffer
|
|
|
|
* was empty, so we can record how many bytes the redraw
|
|
|
|
* generated.
|
|
|
|
*/
|
|
|
|
c->redraw = EVBUFFER_LENGTH(tty->out);
|
|
|
|
log_debug("%s: redraw added %zu bytes", c->name, c->redraw);
|
|
|
|
}
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set client title. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2009-10-22 19:41:51 +00:00
|
|
|
server_client_set_title(struct client *c)
|
|
|
|
{
|
2015-02-06 17:17:12 +00:00
|
|
|
struct session *s = c->session;
|
|
|
|
const char *template;
|
|
|
|
char *title;
|
|
|
|
struct format_tree *ft;
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-10-27 15:58:42 +00:00
|
|
|
template = options_get_string(s->options, "set-titles-string");
|
2009-12-03 22:50:09 +00:00
|
|
|
|
2017-05-01 12:20:55 +00:00
|
|
|
ft = format_create(c, NULL, FORMAT_NONE, 0);
|
2015-02-06 17:17:12 +00:00
|
|
|
format_defaults(ft, c, NULL, NULL, NULL);
|
|
|
|
|
2019-03-14 23:14:27 +00:00
|
|
|
title = format_expand_time(ft, template);
|
2009-10-22 19:41:51 +00:00
|
|
|
if (c->title == NULL || strcmp(title, c->title) != 0) {
|
2012-07-10 11:53:01 +00:00
|
|
|
free(c->title);
|
2009-10-22 19:41:51 +00:00
|
|
|
c->title = xstrdup(title);
|
|
|
|
tty_set_title(&c->tty, c->title);
|
|
|
|
}
|
2012-07-10 11:53:01 +00:00
|
|
|
free(title);
|
2015-02-06 17:17:12 +00:00
|
|
|
|
|
|
|
format_free(ft);
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Dispatch message from client. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2015-10-27 13:23:24 +00:00
|
|
|
server_client_dispatch(struct imsg *imsg, void *arg)
|
2009-10-22 19:41:51 +00:00
|
|
|
{
|
2019-12-12 11:39:56 +00:00
|
|
|
struct client *c = arg;
|
|
|
|
ssize_t datalen;
|
|
|
|
struct session *s;
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
if (c->flags & CLIENT_DEAD)
|
|
|
|
return;
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
if (imsg == NULL) {
|
|
|
|
server_client_lost(c);
|
|
|
|
return;
|
|
|
|
}
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
|
2010-07-24 20:11:59 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
switch (imsg->hdr.type) {
|
|
|
|
case MSG_IDENTIFY_FLAGS:
|
|
|
|
case MSG_IDENTIFY_TERM:
|
|
|
|
case MSG_IDENTIFY_TTYNAME:
|
|
|
|
case MSG_IDENTIFY_CWD:
|
|
|
|
case MSG_IDENTIFY_STDIN:
|
|
|
|
case MSG_IDENTIFY_ENVIRON:
|
|
|
|
case MSG_IDENTIFY_CLIENTPID:
|
|
|
|
case MSG_IDENTIFY_DONE:
|
|
|
|
server_client_dispatch_identify(c, imsg);
|
|
|
|
break;
|
|
|
|
case MSG_COMMAND:
|
|
|
|
server_client_dispatch_command(c, imsg);
|
|
|
|
break;
|
|
|
|
case MSG_RESIZE:
|
|
|
|
if (datalen != 0)
|
|
|
|
fatalx("bad MSG_RESIZE size");
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
if (c->flags & CLIENT_CONTROL)
|
2009-10-22 19:41:51 +00:00
|
|
|
break;
|
2019-09-19 09:02:30 +00:00
|
|
|
server_client_update_latest(c);
|
2019-05-08 18:07:12 +00:00
|
|
|
server_client_clear_overlay(c);
|
2017-05-31 10:29:15 +00:00
|
|
|
tty_resize(&c->tty);
|
|
|
|
recalculate_sizes();
|
|
|
|
server_redraw_client(c);
|
2015-12-08 01:10:31 +00:00
|
|
|
if (c->session != NULL)
|
2016-10-16 22:06:40 +00:00
|
|
|
notify_client("client-resized", c);
|
2015-10-27 13:23:24 +00:00
|
|
|
break;
|
|
|
|
case MSG_EXITING:
|
|
|
|
if (datalen != 0)
|
|
|
|
fatalx("bad MSG_EXITING size");
|
2009-11-03 20:29:47 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
c->session = NULL;
|
|
|
|
tty_close(&c->tty);
|
|
|
|
proc_send(c->peer, MSG_EXITED, -1, NULL, 0);
|
|
|
|
break;
|
|
|
|
case MSG_WAKEUP:
|
|
|
|
case MSG_UNLOCK:
|
|
|
|
if (datalen != 0)
|
|
|
|
fatalx("bad MSG_WAKEUP size");
|
2009-11-03 20:29:47 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
if (!(c->flags & CLIENT_SUSPENDED))
|
2009-10-22 19:41:51 +00:00
|
|
|
break;
|
2015-10-27 13:23:24 +00:00
|
|
|
c->flags &= ~CLIENT_SUSPENDED;
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
if (c->tty.fd == -1) /* exited in the meantime */
|
2009-10-22 19:41:51 +00:00
|
|
|
break;
|
2015-10-27 13:23:24 +00:00
|
|
|
s = c->session;
|
|
|
|
|
|
|
|
if (gettimeofday(&c->activity_time, NULL) != 0)
|
|
|
|
fatal("gettimeofday failed");
|
|
|
|
|
|
|
|
tty_start_tty(&c->tty);
|
|
|
|
server_redraw_client(c);
|
|
|
|
recalculate_sizes();
|
2016-04-28 06:51:56 +00:00
|
|
|
|
|
|
|
if (s != NULL)
|
|
|
|
session_update_activity(s, &c->activity_time);
|
2015-10-27 13:23:24 +00:00
|
|
|
break;
|
|
|
|
case MSG_SHELL:
|
|
|
|
if (datalen != 0)
|
|
|
|
fatalx("bad MSG_SHELL size");
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
server_client_dispatch_shell(c);
|
|
|
|
break;
|
2019-12-12 11:39:56 +00:00
|
|
|
case MSG_WRITE_READY:
|
|
|
|
server_client_dispatch_write_ready(c, imsg);
|
|
|
|
break;
|
|
|
|
case MSG_READ:
|
|
|
|
server_client_dispatch_read_data(c, imsg);
|
|
|
|
break;
|
|
|
|
case MSG_READ_DONE:
|
|
|
|
server_client_dispatch_read_done(c, imsg);
|
|
|
|
break;
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-16 17:55:14 +00:00
|
|
|
/* Callback when command is done. */
|
|
|
|
static enum cmd_retval
|
2016-10-16 19:04:05 +00:00
|
|
|
server_client_command_done(struct cmdq_item *item, __unused void *data)
|
2016-10-16 17:55:14 +00:00
|
|
|
{
|
2016-10-16 19:04:05 +00:00
|
|
|
struct client *c = item->client;
|
2016-10-16 17:55:14 +00:00
|
|
|
|
|
|
|
if (~c->flags & CLIENT_ATTACHED)
|
|
|
|
c->flags |= CLIENT_EXIT;
|
|
|
|
return (CMD_RETURN_NORMAL);
|
|
|
|
}
|
|
|
|
|
2009-10-22 19:41:51 +00:00
|
|
|
/* Handle command message. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2015-10-27 13:23:24 +00:00
|
|
|
server_client_dispatch_command(struct client *c, struct imsg *imsg)
|
2009-10-22 19:41:51 +00:00
|
|
|
{
|
2019-12-12 11:39:56 +00:00
|
|
|
struct msg_command data;
|
2013-10-10 12:13:56 +00:00
|
|
|
char *buf;
|
|
|
|
size_t len;
|
|
|
|
int argc;
|
|
|
|
char **argv, *cause;
|
2019-05-25 07:18:20 +00:00
|
|
|
struct cmd_parse_result *pr;
|
2013-10-10 12:13:56 +00:00
|
|
|
|
2017-12-19 15:00:39 +00:00
|
|
|
if (c->flags & CLIENT_EXIT)
|
|
|
|
return;
|
|
|
|
|
2013-10-10 12:13:56 +00:00
|
|
|
if (imsg->hdr.len - IMSG_HEADER_SIZE < sizeof data)
|
|
|
|
fatalx("bad MSG_COMMAND size");
|
|
|
|
memcpy(&data, imsg->data, sizeof data);
|
|
|
|
|
2014-09-01 21:50:18 +00:00
|
|
|
buf = (char *)imsg->data + sizeof data;
|
2013-10-10 12:13:56 +00:00
|
|
|
len = imsg->hdr.len - IMSG_HEADER_SIZE - sizeof data;
|
|
|
|
if (len > 0 && buf[len - 1] != '\0')
|
|
|
|
fatalx("bad MSG_COMMAND string");
|
|
|
|
|
|
|
|
argc = data.argc;
|
|
|
|
if (cmd_unpack_argv(buf, len, argc, &argv) != 0) {
|
2016-10-16 17:55:14 +00:00
|
|
|
cause = xstrdup("command too long");
|
2009-10-22 19:41:51 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (argc == 0) {
|
|
|
|
argc = 1;
|
|
|
|
argv = xcalloc(1, sizeof *argv);
|
|
|
|
*argv = xstrdup("new-session");
|
|
|
|
}
|
|
|
|
|
2019-05-25 07:18:20 +00:00
|
|
|
pr = cmd_parse_from_arguments(argc, argv, NULL);
|
|
|
|
switch (pr->status) {
|
|
|
|
case CMD_PARSE_EMPTY:
|
|
|
|
cause = xstrdup("empty command");
|
2009-10-22 19:41:51 +00:00
|
|
|
goto error;
|
2019-05-25 07:18:20 +00:00
|
|
|
case CMD_PARSE_ERROR:
|
|
|
|
cause = pr->error;
|
|
|
|
goto error;
|
|
|
|
case CMD_PARSE_SUCCESS:
|
|
|
|
break;
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
cmd_free_argv(argc, argv);
|
|
|
|
|
2019-05-25 07:18:20 +00:00
|
|
|
cmdq_append(c, cmdq_get_command(pr->cmdlist, NULL, NULL, 0));
|
2016-10-16 17:55:14 +00:00
|
|
|
cmdq_append(c, cmdq_get_callback(server_client_command_done, NULL));
|
2019-05-25 07:18:20 +00:00
|
|
|
|
|
|
|
cmd_list_free(pr->cmdlist);
|
2009-10-22 19:41:51 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
2019-05-25 07:18:20 +00:00
|
|
|
cmd_free_argv(argc, argv);
|
|
|
|
|
2019-05-20 11:46:06 +00:00
|
|
|
cmdq_append(c, cmdq_get_error(cause));
|
|
|
|
free(cause);
|
2016-10-16 17:55:14 +00:00
|
|
|
|
2010-07-24 20:11:59 +00:00
|
|
|
c->flags |= CLIENT_EXIT;
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle identify message. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2015-10-27 13:23:24 +00:00
|
|
|
server_client_dispatch_identify(struct client *c, struct imsg *imsg)
|
2009-10-22 19:41:51 +00:00
|
|
|
{
|
2015-10-31 08:13:58 +00:00
|
|
|
const char *data, *home;
|
2017-05-16 12:57:26 +00:00
|
|
|
size_t datalen;
|
2013-10-10 12:26:34 +00:00
|
|
|
int flags;
|
2017-04-05 10:49:46 +00:00
|
|
|
char *name;
|
2013-10-10 12:26:34 +00:00
|
|
|
|
|
|
|
if (c->flags & CLIENT_IDENTIFIED)
|
|
|
|
fatalx("out-of-order identify message");
|
|
|
|
|
|
|
|
data = imsg->data;
|
|
|
|
datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
|
|
|
|
|
|
|
|
switch (imsg->hdr.type) {
|
|
|
|
case MSG_IDENTIFY_FLAGS:
|
|
|
|
if (datalen != sizeof flags)
|
|
|
|
fatalx("bad MSG_IDENTIFY_FLAGS size");
|
|
|
|
memcpy(&flags, data, sizeof flags);
|
|
|
|
c->flags |= flags;
|
2015-10-22 11:00:51 +00:00
|
|
|
log_debug("client %p IDENTIFY_FLAGS %#x", c, flags);
|
2013-10-10 12:26:34 +00:00
|
|
|
break;
|
|
|
|
case MSG_IDENTIFY_TERM:
|
2013-10-10 12:27:38 +00:00
|
|
|
if (datalen == 0 || data[datalen - 1] != '\0')
|
2013-10-10 12:26:34 +00:00
|
|
|
fatalx("bad MSG_IDENTIFY_TERM string");
|
|
|
|
c->term = xstrdup(data);
|
2015-10-22 11:00:51 +00:00
|
|
|
log_debug("client %p IDENTIFY_TERM %s", c, data);
|
2013-10-10 12:26:34 +00:00
|
|
|
break;
|
|
|
|
case MSG_IDENTIFY_TTYNAME:
|
2013-10-10 12:27:38 +00:00
|
|
|
if (datalen == 0 || data[datalen - 1] != '\0')
|
2013-10-10 12:26:34 +00:00
|
|
|
fatalx("bad MSG_IDENTIFY_TTYNAME string");
|
|
|
|
c->ttyname = xstrdup(data);
|
2015-10-22 11:00:51 +00:00
|
|
|
log_debug("client %p IDENTIFY_TTYNAME %s", c, data);
|
2013-10-10 12:26:34 +00:00
|
|
|
break;
|
|
|
|
case MSG_IDENTIFY_CWD:
|
2015-10-18 20:42:42 +00:00
|
|
|
if (datalen == 0 || data[datalen - 1] != '\0')
|
|
|
|
fatalx("bad MSG_IDENTIFY_CWD string");
|
2015-10-31 08:13:58 +00:00
|
|
|
if (access(data, X_OK) == 0)
|
|
|
|
c->cwd = xstrdup(data);
|
|
|
|
else if ((home = find_home()) != NULL)
|
|
|
|
c->cwd = xstrdup(home);
|
|
|
|
else
|
|
|
|
c->cwd = xstrdup("/");
|
2015-10-22 11:00:51 +00:00
|
|
|
log_debug("client %p IDENTIFY_CWD %s", c, data);
|
2013-10-10 12:26:34 +00:00
|
|
|
break;
|
|
|
|
case MSG_IDENTIFY_STDIN:
|
|
|
|
if (datalen != 0)
|
|
|
|
fatalx("bad MSG_IDENTIFY_STDIN size");
|
|
|
|
c->fd = imsg->fd;
|
2015-10-22 11:00:51 +00:00
|
|
|
log_debug("client %p IDENTIFY_STDIN %d", c, imsg->fd);
|
2013-10-10 12:26:34 +00:00
|
|
|
break;
|
|
|
|
case MSG_IDENTIFY_ENVIRON:
|
2013-10-10 12:27:38 +00:00
|
|
|
if (datalen == 0 || data[datalen - 1] != '\0')
|
2013-10-10 12:26:34 +00:00
|
|
|
fatalx("bad MSG_IDENTIFY_ENVIRON string");
|
|
|
|
if (strchr(data, '=') != NULL)
|
2015-10-28 09:51:55 +00:00
|
|
|
environ_put(c->environ, data);
|
2015-10-22 11:00:51 +00:00
|
|
|
log_debug("client %p IDENTIFY_ENVIRON %s", c, data);
|
2013-10-10 12:26:34 +00:00
|
|
|
break;
|
2015-06-14 10:07:44 +00:00
|
|
|
case MSG_IDENTIFY_CLIENTPID:
|
|
|
|
if (datalen != sizeof c->pid)
|
|
|
|
fatalx("bad MSG_IDENTIFY_CLIENTPID size");
|
|
|
|
memcpy(&c->pid, data, sizeof c->pid);
|
2015-10-22 11:00:51 +00:00
|
|
|
log_debug("client %p IDENTIFY_CLIENTPID %ld", c, (long)c->pid);
|
2015-06-14 10:07:44 +00:00
|
|
|
break;
|
2013-10-10 12:26:34 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (imsg->hdr.type != MSG_IDENTIFY_DONE)
|
|
|
|
return;
|
|
|
|
c->flags |= CLIENT_IDENTIFIED;
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2017-04-05 10:49:46 +00:00
|
|
|
if (*c->ttyname != '\0')
|
|
|
|
name = xstrdup(c->ttyname);
|
|
|
|
else
|
|
|
|
xasprintf(&name, "client-%ld", (long)c->pid);
|
|
|
|
c->name = name;
|
|
|
|
log_debug("client %p name is %s", c, c->name);
|
|
|
|
|
2013-10-10 12:26:34 +00:00
|
|
|
if (c->flags & CLIENT_CONTROL) {
|
|
|
|
close(c->fd);
|
|
|
|
c->fd = -1;
|
2019-12-12 11:39:56 +00:00
|
|
|
|
|
|
|
control_start(c);
|
|
|
|
c->tty.fd = -1;
|
2019-06-20 06:51:36 +00:00
|
|
|
} else if (c->fd != -1) {
|
|
|
|
if (tty_init(&c->tty, c, c->fd, c->term) != 0) {
|
|
|
|
close(c->fd);
|
|
|
|
c->fd = -1;
|
|
|
|
} else {
|
|
|
|
if (c->flags & CLIENT_UTF8)
|
|
|
|
c->tty.flags |= TTY_UTF8;
|
|
|
|
if (c->flags & CLIENT_256COLOURS)
|
|
|
|
c->tty.term_flags |= TERM_256COLOURS;
|
|
|
|
tty_resize(&c->tty);
|
|
|
|
c->flags |= CLIENT_TERMINAL;
|
|
|
|
}
|
2012-09-27 10:02:56 +00:00
|
|
|
}
|
2009-10-22 19:41:51 +00:00
|
|
|
|
2019-06-20 06:51:36 +00:00
|
|
|
/*
|
|
|
|
* If this is the first client that has finished identifying, load
|
|
|
|
* configuration files.
|
|
|
|
*/
|
|
|
|
if ((~c->flags & CLIENT_EXIT) &&
|
|
|
|
!cfg_finished &&
|
|
|
|
c == TAILQ_FIRST(&clients) &&
|
|
|
|
TAILQ_NEXT(c, entry) == NULL)
|
|
|
|
start_cfg();
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle shell message. */
|
2016-10-10 21:29:23 +00:00
|
|
|
static void
|
2015-10-27 13:23:24 +00:00
|
|
|
server_client_dispatch_shell(struct client *c)
|
2009-10-22 19:41:51 +00:00
|
|
|
{
|
2013-10-10 12:13:56 +00:00
|
|
|
const char *shell;
|
2009-12-03 22:50:09 +00:00
|
|
|
|
2015-10-27 15:58:42 +00:00
|
|
|
shell = options_get_string(global_s_options, "default-shell");
|
2020-03-17 11:10:12 +00:00
|
|
|
if (!checkshell(shell))
|
2009-10-22 19:41:51 +00:00
|
|
|
shell = _PATH_BSHELL;
|
2017-07-12 09:07:52 +00:00
|
|
|
proc_send(c->peer, MSG_SHELL, -1, shell, strlen(shell) + 1);
|
2009-12-03 22:50:09 +00:00
|
|
|
|
2015-10-27 13:23:24 +00:00
|
|
|
proc_kill_peer(c->peer);
|
2009-10-22 19:41:51 +00:00
|
|
|
}
|
2015-11-14 09:41:06 +00:00
|
|
|
|
2019-12-12 11:39:56 +00:00
|
|
|
/* Handle write ready message. */
|
2015-11-14 09:41:06 +00:00
|
|
|
static void
|
2019-12-12 11:39:56 +00:00
|
|
|
server_client_dispatch_write_ready(struct client *c, struct imsg *imsg)
|
2015-11-14 09:41:06 +00:00
|
|
|
{
|
2019-12-12 11:39:56 +00:00
|
|
|
struct msg_write_ready *msg = imsg->data;
|
|
|
|
size_t msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
|
|
|
|
struct client_file find, *cf;
|
|
|
|
|
|
|
|
if (msglen != sizeof *msg)
|
|
|
|
fatalx("bad MSG_WRITE_READY size");
|
|
|
|
find.stream = msg->stream;
|
|
|
|
if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL)
|
|
|
|
return;
|
|
|
|
if (msg->error != 0) {
|
|
|
|
cf->error = msg->error;
|
|
|
|
file_fire_done(cf);
|
|
|
|
} else
|
|
|
|
file_push(cf);
|
2015-11-14 09:41:06 +00:00
|
|
|
}
|
|
|
|
|
2019-12-12 11:39:56 +00:00
|
|
|
/* Handle read data message. */
|
|
|
|
static void
|
|
|
|
server_client_dispatch_read_data(struct client *c, struct imsg *imsg)
|
2015-11-14 09:41:06 +00:00
|
|
|
{
|
2019-12-12 11:39:56 +00:00
|
|
|
struct msg_read_data *msg = imsg->data;
|
|
|
|
size_t msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
|
|
|
|
struct client_file find, *cf;
|
2019-12-16 15:48:50 +00:00
|
|
|
void *bdata = msg + 1;
|
|
|
|
size_t bsize = msglen - sizeof *msg;
|
2019-12-12 11:39:56 +00:00
|
|
|
|
2019-12-16 15:48:50 +00:00
|
|
|
if (msglen < sizeof *msg)
|
2019-12-12 11:39:56 +00:00
|
|
|
fatalx("bad MSG_READ_DATA size");
|
|
|
|
find.stream = msg->stream;
|
|
|
|
if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL)
|
|
|
|
return;
|
2015-11-14 09:41:06 +00:00
|
|
|
|
2019-12-12 11:39:56 +00:00
|
|
|
log_debug("%s: file %d read %zu bytes", c->name, cf->stream, bsize);
|
|
|
|
if (cf->error == 0) {
|
|
|
|
if (evbuffer_add(cf->buffer, bdata, bsize) != 0) {
|
|
|
|
cf->error = ENOMEM;
|
|
|
|
file_fire_done(cf);
|
|
|
|
} else
|
|
|
|
file_fire_read(cf);
|
2015-11-14 09:41:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-12 11:39:56 +00:00
|
|
|
/* Handle read done message. */
|
2015-11-14 09:41:06 +00:00
|
|
|
static void
|
2019-12-12 11:39:56 +00:00
|
|
|
server_client_dispatch_read_done(struct client *c, struct imsg *imsg)
|
2015-11-14 09:41:06 +00:00
|
|
|
{
|
2019-12-12 11:39:56 +00:00
|
|
|
struct msg_read_done *msg = imsg->data;
|
|
|
|
size_t msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
|
|
|
|
struct client_file find, *cf;
|
|
|
|
|
|
|
|
if (msglen != sizeof *msg)
|
|
|
|
fatalx("bad MSG_READ_DONE size");
|
|
|
|
find.stream = msg->stream;
|
|
|
|
if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL)
|
2015-11-14 09:41:06 +00:00
|
|
|
return;
|
|
|
|
|
2019-12-12 11:39:56 +00:00
|
|
|
log_debug("%s: file %d read done", c->name, cf->stream);
|
|
|
|
cf->error = msg->error;
|
|
|
|
file_fire_done(cf);
|
2015-11-14 09:41:06 +00:00
|
|
|
}
|
2017-02-09 12:09:33 +00:00
|
|
|
|
|
|
|
/* Add to client message log. */
|
|
|
|
void
|
|
|
|
server_client_add_message(struct client *c, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
struct message_entry *msg, *msg1;
|
|
|
|
char *s;
|
|
|
|
va_list ap;
|
|
|
|
u_int limit;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
xvasprintf(&s, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
2017-04-05 10:49:46 +00:00
|
|
|
log_debug("message %s (client %p)", s, c);
|
2017-02-09 12:09:33 +00:00
|
|
|
|
|
|
|
msg = xcalloc(1, sizeof *msg);
|
|
|
|
msg->msg_time = time(NULL);
|
|
|
|
msg->msg_num = c->message_next++;
|
|
|
|
msg->msg = s;
|
|
|
|
TAILQ_INSERT_TAIL(&c->message_log, msg, entry);
|
|
|
|
|
|
|
|
limit = options_get_number(global_options, "message-limit");
|
|
|
|
TAILQ_FOREACH_SAFE(msg, &c->message_log, entry, msg1) {
|
|
|
|
if (msg->msg_num + limit >= c->message_next)
|
|
|
|
break;
|
|
|
|
free(msg->msg);
|
|
|
|
TAILQ_REMOVE(&c->message_log, msg, entry);
|
|
|
|
free(msg);
|
|
|
|
}
|
|
|
|
}
|
2017-02-14 18:13:05 +00:00
|
|
|
|
|
|
|
/* Get client working directory. */
|
|
|
|
const char *
|
2018-05-24 09:42:49 +00:00
|
|
|
server_client_get_cwd(struct client *c, struct session *s)
|
2017-02-14 18:13:05 +00:00
|
|
|
{
|
2018-05-24 09:42:49 +00:00
|
|
|
const char *home;
|
2017-02-14 18:13:05 +00:00
|
|
|
|
2019-02-16 11:42:08 +00:00
|
|
|
if (!cfg_finished && cfg_client != NULL)
|
|
|
|
return (cfg_client->cwd);
|
2017-02-14 18:13:05 +00:00
|
|
|
if (c != NULL && c->session == NULL && c->cwd != NULL)
|
|
|
|
return (c->cwd);
|
2018-05-24 09:42:49 +00:00
|
|
|
if (s != NULL && s->cwd != NULL)
|
|
|
|
return (s->cwd);
|
2017-02-14 18:13:05 +00:00
|
|
|
if (c != NULL && (s = c->session) != NULL && s->cwd != NULL)
|
|
|
|
return (s->cwd);
|
2018-05-24 09:42:49 +00:00
|
|
|
if ((home = find_home()) != NULL)
|
|
|
|
return (home);
|
|
|
|
return ("/");
|
2017-02-14 18:13:05 +00:00
|
|
|
}
|