Move mode set/reset after sync so cursor doesn't flicker, from Avi

Halachmi.

.github/README.md

@@ -14,8 +14,17 @@ page](https://github.com/libevent/libevent/releases/latest).
 It also depends on [ncurses](https://www.gnu.org/software/ncurses/), available
 from [this page](https://invisible-mirror.net/archives/ncurses/).
 
+To build tmux, a C compiler (for example gcc or clang), make, pkg-config and a
+suitable yacc (yacc or bison) are needed.
+
 ## Installation
 
+### Binary packages
+
+Some platforms provide binary packages for tmux, although these are sometimes
+out of date. Examples are listed on
+[this page](https://github.com/tmux/tmux/wiki/Installing).
+
 ### From release tarball
 
 To build and install tmux from a release tarball, use:
@@ -28,6 +37,9 @@ sudo make install
 tmux can use the utempter library to update utmp(5), if it is installed - run
 configure with `--enable-utempter` to enable this.
 
+For more detailed instructions on building and installing tmux, see
+[this page](https://github.com/tmux/tmux/wiki/Installing).
+
 ### From version control
 
 To get and build the latest from version control - note that this requires

.github/lock.yml

@@ -1,4 +1,4 @@
-daysUntilLock: 180
+daysUntilLock: 30
 skipCreatedBefore: false
 exemptLabels: []
 lockLabel: false

.github/travis/before-install.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+	sudo apt-get update -qq
+	sudo apt-get -y install bison \
+				autotools-dev \
+				libncurses5-dev \
+				libevent-dev \
+				pkg-config \
+				libutempter-dev \
+				build-essential
+
+	if [ "$BUILD" = "musl" -o "$BUILD" = "musl-static" ]; then
+		sudo apt-get -y install musl-dev \
+					musl-tools
+	fi
+fi
+
+if [ "$TRAVIS_OS_NAME" = "freebsd" ]; then
+	sudo pkg install -y \
+		automake \
+		libevent \
+		pkgconf
+fi

.github/travis/build-all.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+BUILD=$PWD/build
+
+LIBEVENT=https://github.com/libevent/libevent/releases/download/release-2.1.11-stable/libevent-2.1.11-stab\
+le.tar.gz
+NCURSES=https://ftp.gnu.org/gnu/ncurses/ncurses-6.2.tar.gz
+
+wget -4q $LIBEVENT || exit 1
+tar -zxf libevent-*.tar.gz || exit 1
+(cd libevent-*/ &&
+	 ./configure --prefix=$BUILD \
+		     --enable-shared \
+		     --disable-libevent-regress \
+		     --disable-samples &&
+	 make && make install) || exit 1
+
+wget -4q $NCURSES || exit 1
+tar -zxf ncurses-*.tar.gz || exit 1
+(cd ncurses-*/ &&
+	CPPFLAGS=-P ./configure --prefix=$BUILD \
+				--with-shared \
+				--with-termlib \
+				--without-ada \
+				--without-cxx \
+				--without-manpages \
+				--without-progs \
+				--without-tests \
+				--without-tack \
+				--disable-database \
+				--enable-termcap \
+				--enable-pc-files \
+				--with-pkg-config-libdir=$BUILD/lib/pkgconfig &&
+	 make && make install) || exit 1
+
+sh autogen.sh || exit 1
+PKG_CONFIG_PATH=$BUILD/lib/pkgconfig ./configure --prefix=$BUILD "$@"
+make && make install || (cat config.log; exit 1)

.github/travis/build.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+sh autogen.sh || exit 1
+case "$BUILD" in
+	static)
+		./configure --enable-static || exit 1
+		exec make
+		;;
+	all)
+		sh $(dirname $0)/build-all.sh
+		exec make
+		;;
+	musl)
+		CC=musl-gcc sh $(dirname $0)/build-all.sh
+		exec make
+		;;
+	musl-static)
+		CC=musl-gcc sh $(dirname $0)/build-all.sh --enable-static
+		exec make
+		;;
+	*)
+		./configure || exit 1
+		exec make
+		;;
+esac

.gitignore

@@ -19,3 +19,5 @@ configure
 tmux.1.*
 *.dSYM
 cmd-parse.c
+fuzz/*-fuzzer
+.dirstamp

.travis.yml

@@ -1,16 +1,88 @@
 language: c
 
 os:
-    - linux
+  - linux
-    - osx
+  - freebsd
+  - osx
 
 compiler:
-    - gcc
+  - gcc
-    - clang
+  - clang
+
+arch:
+  - amd64
+  - arm64
+
+env:
+  - BUILD=
+  - BUILD=static
+  - BUILD=all
+  - BUILD=musl
+  - BUILD=musl-static
+
+jobs:
+  exclude:
+    # Static builds are broken on OS X (by Apple)
+    - os: osx
+      compiler: gcc
+      env: BUILD=static
+    - os: osx
+      compiler: clang
+      env: BUILD=static
+    # No musl on FreeBSD
+    - os: freebsd
+      compiler: gcc
+      env: BUILD=musl
+    - os: freebsd
+      compiler: clang
+      env: BUILD=musl
+    - os: freebsd
+      compiler: gcc
+      env: BUILD=musl-static
+    - os: freebsd
+      compiler: clang
+      env: BUILD=musl-static
+    # No musl on OS X
+    - os: osx
+      compiler: gcc
+      env: BUILD=musl
+    - os: osx
+      compiler: clang
+      env: BUILD=musl
+    - os: osx
+      compiler: gcc
+      env: BUILD=musl-static
+    - os: osx
+      compiler: clang
+      env: BUILD=musl-static
+    # arm64 doesn't link ncurses
+    - os: linux
+      compiler: gcc
+      arch: arm64
+      env: BUILD=all
+    - os: linux
+      compiler: clang
+      arch: arm64
+      env: BUILD=all
+    - os: linux
+      compiler: gcc
+      arch: arm64
+      env: BUILD=musl
+    - os: linux
+      compiler: clang
+      arch: arm64
+      env: BUILD=musl
+    - os: linux
+      compiler: gcc
+      arch: arm64
+      env: BUILD=musl-static
+    - os: linux
+      compiler: clang
+      arch: arm64
+      env: BUILD=musl-static
 
 before_install:
-    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo apt-get update -qq; fi
+  - sh .github/travis/before-install.sh
-    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo apt-get -y install bison autotools-dev libncurses5-dev libevent-dev pkg-config libutempter-dev build-essential; fi
 
 script:
-    - ./autogen.sh && ./configure && make
+  - sh .github/travis/build.sh

CHANGES

@@ -1,5 +1,382 @@
+CHANGES FROM 3.1c TO 3.2
+
+* Add a flag to disable keys to close a message.
+
+* Permit shortcut keys in buffer, client, tree modes to be configured with a
+  format (-K flag to choose-buffer, choose-client, choose-tree).
+
+* Add a current_file format for the config file being parsed.
+
+* When display-message used in config file, show the message after the config
+  file finishes.
+
+* Add client-detached notification in control mode.
+
+* Improve performance of format evaluation.
+
+* Make jump command support UTF-8 in copy mode.
+
+* Support X11 colour names and other colour formats for OSC 10 and 11.
+
+* Add "pipe" variants of "copy-pipe" commands which do not copy.
+
+* Include "focused" in client flags.
+
+* Send Unicode directional isolate characters around horizontal pane borders if
+  the terminal supports UTF-8 and an extension terminfo(5) capability "Bidi" is
+  present.
+
+* Add a -S flag to new-window to make it select the existing window if one
+  with the given name already exists rather than failing with an error.
+
+* Addd a format modifier to check if a window or session name exists (N/w or
+  N/s).
+
+* Add compat clock_gettime for older macOS.
+
+* Add a no-detached choice to detach-on-destroy which detaches only if there
+  are no other detached sessions to switch to.
+
+* Add rectangle-on and rectangle-off copy mode commands.
+
+* Change so that window_flags escapes # automatically. A new format
+  window_raw_flags contains the old unescaped version.
+
+* Add -N flag to never start server even if command would normally do so.
+
+* With incremental search, start empty and only repeat the previous search if
+  the user tries to search again with an empty prompt.
+
+* Add a value for remain-on-exit that only keeps the pane if the program
+  failed.
+
+* Add a -C flag to run-shell to use a tmux command rather than a shell command.
+
+* Do not list user options with show-hooks.
+
+* Remove current match indicator in copy mode which can't work anymore since we
+  only search the visible region.
+
+* Make synchronize-panes a pane option and add -U flag to set-option to unset
+  an option on all panes.
+
+* Make replacement of ##s consistent when drawing formats, whether followed by
+  [ or not. Add a flag (e) to the q: format modifier to double up #s
+
+* Add -N flag to display-panes to ignore keys.
+
+* Change how escaping is processed for formats so that ## and # can be used in
+  styles.
+
+* Add a 'w' format modifier for string width.
+
+* Add support for Haiku.
+
+* Expand menu and popup -x and -y as formats.
+
+* Add numeric comparisons for formats.
+
+* Fire focus events even when the pane is in a mode.
+
+* Add -O flag to display-menu to not automatically close when all mouse buttons
+  are released.
+
+* Allow fnmatch(3) wildcards in update-environment.
+
+* Disable nested job expansion so that the result of #() is not expanded again.
+
+* Use the setal capability as well as (tmux's) Setulc.
+
+* Add -q flag to unbind-key to hide errors.
+
+* Allow -N without a command to change or add a note to an existing key.
+
+* Add a -w flag to set- and load-buffer to send to clipboard using OSC 52.
+
+* Add -F to set-environment and source-file.
+
+* Allow colour to be spelt as color in various places.
+
+* Add n: modifier to get length of a format.
+
+* Respond to OSC colour requests if a colour is available.
+
+* Add a -d option to display-message to set delay.
+
+* Add a way for control mode clients to subscribe to a format and be notified
+  of changes rather than having to poll.
+    
+* Add some formats for search in copy mode (search_present, search_match).
+
+* Do not wait on shutdown for commands started with run -b.
+
+* Add -b flags to insert a window before (like the existing -a for after) to
+  break-pane, move-window, new-window.
+
+* Make paste -p the default for ].
+
+* Add support for pausing a pane when the output buffered for a control mode
+  client gets too far behind. The pause-after flag with a time is set on the
+  pane with refresh-client -f and a paused pane may be resumed with
+  refresh-client -A.
+
+* Allow strings in configuration files to span multiple lines - newlines and
+  any leading whitespace are removed, as well as any following comments that
+  couldn't be part of a format. This allows long formats or other strings to be
+  annotated and indented.
+
+* Instead of using a custom parse function to process {} in configuration
+  files, treat as a set of statements the same as outside {} and convert back
+  to a string as the last step. This means the rules are consistent inside and
+  outside {}, %if and friends work at the right time, and the final result
+  isn't littered with unnecessary newlines.
+
+* Add support for extended keys - both xterm(1)'s CSI 27 ~ sequence and the
+  libtickit CSI u sequence are accepted; only the latter is output. tmux will
+  only attempt to use these if the extended-keys option is on and it can detect
+  that the terminal outside supports them (or is told it does with the
+  "extkeys" terminal feature).
+
+* Add an option to set the pane border lines style from a choice of single
+  lines (ACS or UTF-8), double or heavy (UTF-8), simple (plain ASCII) or number
+  (the pane numbers). Lines that won't work on a non-UTF-8 terminal are
+  translated back into ACS when they are output.
+
+* Make focus events update the latest client (like a key press).
+
+* Store UTF-8 characters differently to reduce memory use.
+
+* Fix break-pane -n when only one pane in the window.
+
+* Instead of sending all data to control mode clients as fast as possible, add
+  a limit of how much data will be sent to the client and try to use it for
+  panes with some degree of fairness.
+
+* Add an active-pane client flag (set with attach-session -f, new-session -f
+  or refresh-client -f). This allows a client to have an independent active
+  pane for interactive use (the window client pane is still used for many
+  things however).
+
+* Add a mark to copy mode, this is set with the set-mark command (bound to X)
+  and appears with the entire line shown using copy-mode-mark-style and the
+  marked character in reverse. The jump-to-mark command (bound to M-x) swaps
+  the mark and the cursor positions.
+
+* Add a -D flag to make the tmux server run in the foreground and not as a
+  daemon.
+
+* Do not loop forever in copy mode when search finds an empty match.
+
+* Fix the next-matching-bracket logic when using vi(1) keys.
+
+* Add a customize mode where options may be browsed and changed, includes
+  adding a brief description of each option. Bound to C-b C by default.
+
+* Change message log (C-b ~) so there is one for the server rather than one per
+  client and it remains after detach, and make it useful by logging every
+  command.
+
+* Add M-+ and M-- to tree mode to expand and collapse all.
+
+* Change the existing client flags for control mode to apply for any client,
+  use the same mechanism for the read-only flag and add an ignore-size flag.
+
+  refresh-client -F has become -f (-F stays for backwards compatibility) and
+  attach-session and switch-client now have -f flags also. A new format
+  client_flags lists the flags and is shown by list-clients by default.
+
+  This separates the read-only flag from "ignore size" behaviour (new
+  ignore-size) flag - both behaviours are useful in different circumstances.
+
+  attach -r and switchc -r remain and set or toggle both flags together.
+
+* Store and restore cursor position when copy mode is resized.
+
+* Export TERM_PROGRAM and TERM_PROGRAM_VERSION like various other terminals.
+
+* Add formats for after hook command arguments: hook_arguments with all the
+  arguments together; hook_argument_0, hook_argument_1 and so on with
+  individual arguments; hook_flag_X if flag -X is present; hook_flag_X_0,
+  hook_flag_X_1 and so on if -X appears multiple times.
+
+* Try to search the entire history first for up to 200 ms so a search count can
+  be shown. If it takes too long, search the visible text only.
+
+* Use VIS_CSTYLE for paste buffers also (show \012 as \n).
+
+* Change default formats for tree mode, client mode and buffer mode to be more
+  compact and remove some clutter.
+
+* Add a key (e) in buffer mode to open the buffer in an editor. The buffer
+  contents is updated when the editor exits.
+
+* Add -e flag for new-session to set environment variables, like the same flag
+  for new-window.
+
+* Improve search match marking in copy mode. Two new options
+  copy-mode-match-style and copy-mode-current-match-style to set the style for
+  matches and for the current match respectively. Also a change so that if a
+  copy key is pressed with no selection, the current match (if any) is copied.
+
+* Sanitize session names like window names instead of forbidding invalid ones.
+
+* Check if the clear terminfo(5) capability starts with CSI and if so then
+  assume the terminal is VT100-like, rather than relying on the XT capability.
+
+* Improve command prompt tab completion and add menus both for strings and -t
+  and -s (when used without a trailing space). command-prompt has additional
+  flags for only completing a window (-W) and a target (-T), allowing C-b ' to
+  only show windows and C-b . only targets.
+
+* Change all the style options to string options so they can support formats.
+  Change pane-border-active-style to use this to change the border colour when
+  in a mode or with synchronize-panes on. This also implies a few minor changes
+  to existing behaviour:
+
+  - set-option -a with a style option automatically inserts a comma between the
+    old value and appended text.
+
+  - OSC 10 and 11 no longer set the window-style option, instead they store the
+    colour internally in the pane data and it is used as the default when the
+    option is evaluated.
+
+  - status-fg and -bg now override status-style instead of the option values
+    being changed.
+
+* Add extension terminfo(5) capabilities for margins and focus reporting.
+
+* Try $XDG_CONFIG_HOME/tmux/tmux.conf as well as ~/.config/tmux/tmux.conf for
+  configuration file (the search paths are in TMUX_CONF in Makefile.am).
+
+* Remove the DSR 1337 iTerm2 extension and replace by the extended device
+  attributes sequence (CSI > q) supported by more terminals.
+
+* Add a -s flag to copy-mode to specify a different pane for the source
+  content. This means it is possible to view two places in a pane's history at
+  the same time in different panes, or view the history while still using the
+  pane. Pressing r refreshes the content from the source pane.
+
+* Add an argument to list-commands to show only a single command.
+
+* Change copy mode to make copy of the pane history so it does not need to
+  freeze the pane.
+
+* Restore pane_current_path format from portable tmux on OpenBSD.
+
+* Wait until the initial command sequence is done before sending a device
+  attributes request and other bits that prompt a reply from the terminal. This
+  means that stray relies are not left on the terminal if the command has
+  attached and then immediately detached and tmux will not be around to receive
+  them.
+
+* Add a -f filter argument to the list commands like choose-tree.
+
+* Move specific hooks for panes to pane options and windows for window options
+  rather than all hooks being session options. These hooks are now window options:
+
+  window-layout-changed
+  window-linked
+  window-pane-changed
+  window-renamed
+  window-unlinked
+
+  And these now pane options:
+
+  pane-died
+  pane-exited
+  pane-focus-in
+  pane-focus-out
+  pane-mode-changed
+  pane-set-clipboard
+
+  Any existing configurations using these hooks on a session rather than
+  globally (that is, set-hook or set-option without -g) may need to be changed.
+
+* Show signal names when a process exits with remain-on-exit on platforms which
+  have a way to get them.
+
+* Start menu with top item selected if no mouse and use mode-style for the
+  selected item.
+
+* Add a copy-command option and change copy-pipe and friends to pipe to it if
+  used without arguments, allows all the default copy key bindings to be
+  changed to pipe with one option rather than needing to change each key
+  binding individually.
+
+* Tidy up the terminal detection and feature code and add named sets of
+  terminal features, each of which are defined in one place and map to a
+  builtin set of terminfo(5) capabilities. Features can be specified based on
+  TERM with a new terminal-features option or with the -T flag when running
+  tmux. tmux will also detect a few common terminals from the DA and DSR
+  responses.
+
+  This is intended to make it easier to configure tmux's use of terminfo(5)
+  even in the presence of outdated ncurses(3) or terminfo(5) databases or for
+  features which do not yet have a terminfo(5) entry. Instead of having to grok
+  terminfo(5) capability names and what they should be set to in the
+  terminal-overrides option, the user can hopefully just give tmux a feature
+  name and let it do the right thing.
+
+  The terminal-overrides option remains both for backwards compatibility and to
+  allow tweaks of individual capabilities.
+
+* Support mintty's application escape sequence (means tmux doesn't have to
+  delay to wait for Escape, so no need to reduce escape-time when using
+  mintty).
+
+* Change so main-pane-width and height can be given as a percentage.
+
+* Support for the iTerm2 synchronized updates feature (allows the terminal to
+  avoid unnecessary drawing while output is still in progress).
+
+* Make the mouse_word and mouse_line formats work in copy mode and enable the
+  default pane menu in copy mode.
+
+* Add a -T flag to resize-pane to trim lines below the cursor, moving lines out
+  of the history.
+
+* Add a way to mark environment variables as "hidden" so they can be used by
+  tmux (for example in formats) but are not set in the environment for new
+  panes. set-environment and show-environment have a new -h flag and there is a
+  new %hidden statement for the configuration file.
+
+* Change default position for display-menu -x and -y to centre rather than top
+  left.
+
+* Add support for per-client transient popups, similar to menus but which are
+  connected to an external command (like a pane). These are created with new
+  command display-popup.
+
+* Change double and triple click bindings so that only one is fired (previously
+  double click was fired on the way to triple click). Also add default double
+  and triple click bindings to copy the word or line under the cursor and
+  change the existing bindings in copy mode to do the same.
+
+* Add a default binding for button 2 to paste.
+
+* Add -d flag to run-shell to delay before running the command and allow it to
+  run without a command so it just delays.
+
+* Add C-g to cancel command prompt with vi keys as well as emacs, and q in
+  command mode.
+
+* When the server socket is given with -S, create it with umask 177 instead of
+  117 (because it may not be in a safe directory like the default directory in
+  /tmp).
+
+* Add a copy-mode -H flag to hide the position marker in the top right.
+
+* Add number operators for formats (+, -, *, / and m),
+
+CHANGED FROM 3.1b TO 3.1c
+
+* Do not write after the end of the array and overwrite the stack when
+  colon-separated SGR sequences contain empty arguments.
+
 CHANGES FROM 3.1a TO 3.1b
 
+* Fix build on systems without sys/queue.h.
+
 * Fix crash when allow-rename is on and an empty name is set.
 
 CHANGES FROM 3.1 TO 3.1a

Makefile.am

@@ -12,8 +12,8 @@ dist_EXTRA_tmux_SOURCES = compat/*.[ch]
 
 # Preprocessor flags.
 AM_CPPFLAGS += @XOPEN_DEFINES@ \
-	-DTMUX_VERSION="\"@VERSION@\"" \
+	-DTMUX_VERSION='"@VERSION@"' \
-	-DTMUX_CONF="\"$(sysconfdir)/tmux.conf:~/.tmux.conf:~/.config/tmux/tmux.conf\""
+	-DTMUX_CONF='"$(sysconfdir)/tmux.conf:~/.tmux.conf:$$XDG_CONFIG_HOME/tmux/tmux.conf:~/.config/tmux/tmux.conf"'
 
 # Additional object files.
 LDADD = $(LIBOBJS)
@@ -28,7 +28,7 @@ AM_CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
 AM_CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
 AM_CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
 AM_CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
-AM_CFLAGS += -Wno-unused-result
+AM_CFLAGS += -Wno-unused-result -Wno-format-y2k
 AM_CPPFLAGS += -DDEBUG
 endif
 AM_CPPFLAGS += -iquote.
@@ -58,6 +58,11 @@ if IS_NETBSD
 AM_CPPFLAGS += -D_OPENBSD_SOURCE
 endif
 
+# Set flags for Haiku.
+if IS_HAIKU
+AM_CPPFLAGS += -D_BSD_SOURCE
+endif
+
 # List of sources.
 dist_tmux_SOURCES = \
 	alerts.c \
@@ -136,6 +141,7 @@ dist_tmux_SOURCES = \
 	file.c \
 	format.c \
 	format-draw.c \
+	grid-reader.c \
 	grid-view.c \
 	grid.c \
 	input-keys.c \
@@ -154,6 +160,7 @@ dist_tmux_SOURCES = \
 	options-table.c \
 	options.c \
 	paste.c \
+	popup.c \
 	proc.c \
 	regsub.c \
 	resize.c \
@@ -170,6 +177,7 @@ dist_tmux_SOURCES = \
 	tmux.c \
 	tmux.h \
 	tty-acs.c \
+	tty-features.c \
 	tty-keys.c \
 	tty-term.c \
 	tty.c \
@@ -178,11 +186,11 @@ dist_tmux_SOURCES = \
 	window-client.c \
 	window-clock.c \
 	window-copy.c \
+	window-customize.c \
 	window-tree.c \
 	window.c \
 	xmalloc.c \
-	xmalloc.h \
+	xmalloc.h
-	xterm-keys.c
 nodist_tmux_SOURCES = osdep-@PLATFORM@.c
 
 # Add compat file for forkpty.
@@ -195,6 +203,12 @@ if HAVE_UTF8PROC
 nodist_tmux_SOURCES += compat/utf8proc.c
 endif
 
+if NEED_FUZZING
+check_PROGRAMS = fuzz/input-fuzzer
+fuzz_input_fuzzer_LDFLAGS = $(FUZZING_LIBS)
+fuzz_input_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
+endif
+
 # Install tmux.1 in the right format.
 install-exec-hook:
 	if test x@MANFORMAT@ = xmdoc; then \

README

@@ -16,6 +16,9 @@ It also depends on ncurses, available from:
 
 	https://invisible-mirror.net/archives/ncurses/
 
+To build tmux, a C compiler (for example gcc or clang), make, pkg-config and a
+suitable yacc (yacc or bison) are needed.
+
 * Installation
 
 To build and install tmux from a release tarball, use:

alerts.c

@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <event.h>
 #include <stdlib.h>
 
 #include "tmux.h"
@@ -200,7 +199,7 @@ alerts_check_bell(struct window *w)
 		 * not check WINLINK_BELL).
 		 */
 		s = wl->session;
-		if (s->curw != wl) {
+		if (s->curw != wl || s->attached == 0) {
 			wl->flags |= WINLINK_BELL;
 			server_status_session(s);
 		}
@@ -236,7 +235,7 @@ alerts_check_activity(struct window *w)
 		if (wl->flags & WINLINK_ACTIVITY)
 			continue;
 		s = wl->session;
-		if (s->curw != wl) {
+		if (s->curw != wl || s->attached == 0) {
 			wl->flags |= WINLINK_ACTIVITY;
 			server_status_session(s);
 		}
@@ -272,7 +271,7 @@ alerts_check_silence(struct window *w)
 		if (wl->flags & WINLINK_SILENCE)
 			continue;
 		s = wl->session;
-		if (s->curw != wl) {
+		if (s->curw != wl || s->attached == 0) {
 			wl->flags |= WINLINK_SILENCE;
 			server_status_session(s);
 		}
@@ -315,9 +314,12 @@ alerts_set_message(struct winlink *wl, const char *type, const char *option)
 			tty_putcode(&c->tty, TTYC_BEL);
 		if (visual == VISUAL_OFF)
 			continue;
-		if (c->session->curw == wl)
+		if (c->session->curw == wl) {
-			status_message_set(c, "%s in current window", type);
+			status_message_set(c, -1, 1, 0, "%s in current window",
-		else
+			    type);
-			status_message_set(c, "%s in window %d", type, wl->idx);
+		} else {
+			status_message_set(c, -1, 1, 0, "%s in window %d", type,
+			    wl->idx);
+		}
 	}
 }

arguments.c

@@ -55,11 +55,11 @@ args_cmp(struct args_entry *a1, struct args_entry *a2)
 
 /* Find a flag in the arguments tree. */
 static struct args_entry *
-args_find(struct args *args, u_char ch)
+args_find(struct args *args, u_char flag)
 {
 	struct args_entry	entry;
 
-	entry.flag = ch;
+	entry.flag = flag;
 	return (RB_FIND(args_tree, &args->tree, &entry));
 }
 
@@ -211,25 +211,35 @@ args_print(struct args *args)
 char *
 args_escape(const char *s)
 {
-	static const char	 quoted[] = " #\"';${}";
+	static const char	 dquoted[] = " #';${}";
+	static const char	 squoted[] = " \"";
 	char			*escaped, *result;
-	int			 flags;
+	int			 flags, quotes = 0;
+
+	if (*s == '\0') {
+		xasprintf(&result, "''");
+		return (result);
+	}
+	if (s[strcspn(s, dquoted)] != '\0')
+		quotes = '"';
+	else if (s[strcspn(s, squoted)] != '\0')
+		quotes = '\'';
 
-	if (*s == '\0')
-		return (xstrdup(s));
 	if (s[0] != ' ' &&
-	    (strchr(quoted, s[0]) != NULL || s[0] == '~') &&
+	    s[1] == '\0' &&
-	    s[1] == '\0') {
+	    (quotes != 0 || s[0] == '~')) {
 		xasprintf(&escaped, "\\%c", s[0]);
 		return (escaped);
 	}
 
 	flags = VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL;
-	if (s[strcspn(s, quoted)] != '\0')
+	if (quotes == '"')
 		flags |= VIS_DQ;
 	utf8_stravis(&escaped, s, flags);
 
-	if (flags & VIS_DQ) {
+	if (quotes == '\'')
+		xasprintf(&result, "'%s'", escaped);
+	else if (quotes == '"') {
 		if (*escaped == '~')
 			xasprintf(&result, "\"\\%s\"", escaped);
 		else
@@ -246,11 +256,11 @@ args_escape(const char *s)
 
 /* Return if an argument is present. */
 int
-args_has(struct args *args, u_char ch)
+args_has(struct args *args, u_char flag)
 {
 	struct args_entry	*entry;
 
-	entry = args_find(args, ch);
+	entry = args_find(args, flag);
 	if (entry == NULL)
 		return (0);
 	return (entry->count);
@@ -258,15 +268,15 @@ args_has(struct args *args, u_char ch)
 
 /* Set argument value in the arguments tree. */
 void
-args_set(struct args *args, u_char ch, const char *s)
+args_set(struct args *args, u_char flag, const char *s)
 {
 	struct args_entry	*entry;
 	struct args_value	*value;
 
-	entry = args_find(args, ch);
+	entry = args_find(args, flag);
 	if (entry == NULL) {
 		entry = xcalloc(1, sizeof *entry);
-		entry->flag = ch;
+		entry->flag = flag;
 		entry->count = 1;
 		TAILQ_INIT(&entry->values);
 		RB_INSERT(args_tree, &args->tree, entry);
@@ -282,22 +292,44 @@ args_set(struct args *args, u_char ch, const char *s)
 
 /* Get argument value. Will be NULL if it isn't present. */
 const char *
-args_get(struct args *args, u_char ch)
+args_get(struct args *args, u_char flag)
 {
 	struct args_entry	*entry;
 
-	if ((entry = args_find(args, ch)) == NULL)
+	if ((entry = args_find(args, flag)) == NULL)
+		return (NULL);
+	if (TAILQ_EMPTY(&entry->values))
 		return (NULL);
 	return (TAILQ_LAST(&entry->values, args_values)->value);
 }
 
+/* Get first argument. */
+u_char
+args_first(struct args *args, struct args_entry **entry)
+{
+	*entry = RB_MIN(args_tree, &args->tree);
+	if (*entry == NULL)
+		return (0);
+	return ((*entry)->flag);
+}
+
+/* Get next argument. */
+u_char
+args_next(struct args_entry **entry)
+{
+	*entry = RB_NEXT(args_tree, &args->tree, *entry);
+	if (*entry == NULL)
+		return (0);
+	return ((*entry)->flag);
+}
+
 /* Get first value in argument. */
 const char *
-args_first_value(struct args *args, u_char ch, struct args_value **value)
+args_first_value(struct args *args, u_char flag, struct args_value **value)
 {
 	struct args_entry	*entry;
 
-	if ((entry = args_find(args, ch)) == NULL)
+	if ((entry = args_find(args, flag)) == NULL)
 		return (NULL);
 
 	*value = TAILQ_FIRST(&entry->values);
@@ -320,15 +352,15 @@ args_next_value(struct args_value **value)
 
 /* Convert an argument value to a number. */
 long long
-args_strtonum(struct args *args, u_char ch, long long minval, long long maxval,
+args_strtonum(struct args *args, u_char flag, long long minval,
-    char **cause)
+    long long maxval, char **cause)
 {
 	const char		*errstr;
 	long long 	 	 ll;
 	struct args_entry	*entry;
 	struct args_value	*value;
 
-	if ((entry = args_find(args, ch)) == NULL) {
+	if ((entry = args_find(args, flag)) == NULL) {
 		*cause = xstrdup("missing");
 		return (0);
 	}
@@ -343,3 +375,60 @@ args_strtonum(struct args *args, u_char ch, long long minval, long long maxval,
 	*cause = NULL;
 	return (ll);
 }
+
+/* Convert an argument to a number which may be a percentage. */
+long long
+args_percentage(struct args *args, u_char flag, long long minval,
+    long long maxval, long long curval, char **cause)
+{
+	const char		*value;
+	struct args_entry	*entry;
+
+	if ((entry = args_find(args, flag)) == NULL) {
+		*cause = xstrdup("missing");
+		return (0);
+	}
+	value = TAILQ_LAST(&entry->values, args_values)->value;
+	return (args_string_percentage(value, minval, maxval, curval, cause));
+}
+
+/* Convert a string to a number which may be a percentage. */
+long long
+args_string_percentage(const char *value, long long minval, long long maxval,
+    long long curval, char **cause)
+{
+	const char	*errstr;
+	long long 	 ll;
+	size_t		 valuelen = strlen(value);
+	char		*copy;
+
+	if (value[valuelen - 1] == '%') {
+		copy = xstrdup(value);
+		copy[valuelen - 1] = '\0';
+
+		ll = strtonum(copy, 0, 100, &errstr);
+		free(copy);
+		if (errstr != NULL) {
+			*cause = xstrdup(errstr);
+			return (0);
+		}
+		ll = (curval * ll) / 100;
+		if (ll < minval) {
+			*cause = xstrdup("too small");
+			return (0);
+		}
+		if (ll > maxval) {
+			*cause = xstrdup("too large");
+			return (0);
+		}
+	} else {
+		ll = strtonum(value, minval, maxval, &errstr);
+		if (errstr != NULL) {
+			*cause = xstrdup(errstr);
+			return (0);
+		}
+	}
+
+	*cause = NULL;
+	return (ll);
+}

attributes.c

@@ -31,7 +31,8 @@ attributes_tostring(int attr)
 	if (attr == 0)
 		return ("none");
 
-	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s%s%s%s%s%s",
+	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
+	    (attr & GRID_ATTR_CHARSET) ? "acs," : "",
 	    (attr & GRID_ATTR_BRIGHT) ? "bright," : "",
 	    (attr & GRID_ATTR_DIM) ? "dim," : "",
 	    (attr & GRID_ATTR_UNDERSCORE) ? "underscore," : "",
@@ -62,6 +63,7 @@ attributes_fromstring(const char *str)
 		const char	*name;
 		int		 attr;
 	} table[] = {
+		{ "acs", GRID_ATTR_CHARSET },
 		{ "bright", GRID_ATTR_BRIGHT },
 		{ "bold", GRID_ATTR_BRIGHT },
 		{ "dim", GRID_ATTR_DIM },

cfg.c

@@ -27,12 +27,15 @@
 #include "tmux.h"
 
 struct client		 *cfg_client;
-static char		 *cfg_file;
 int			  cfg_finished;
 static char		**cfg_causes;
 static u_int		  cfg_ncauses;
 static struct cmdq_item	 *cfg_item;
 
+int                       cfg_quiet = 1;
+char                    **cfg_files;
+u_int                     cfg_nfiles;
+
 static enum cmd_retval
 cfg_client_done(__unused struct cmdq_item *item, __unused void *data)
 {
@@ -59,52 +62,11 @@ cfg_done(__unused struct cmdq_item *item, __unused void *data)
 	return (CMD_RETURN_NORMAL);
 }
 
-void
-set_cfg_file(const char *path)
-{
-	free(cfg_file);
-	cfg_file = xstrdup(path);
-}
-
-static char *
-expand_cfg_file(const char *path, const char *home)
-{
-	char			*expanded, *name;
-	const char		*end;
-	struct environ_entry	*value;
-
-	if (strncmp(path, "~/", 2) == 0) {
-		if (home == NULL)
-			return (NULL);
-		xasprintf(&expanded, "%s%s", home, path + 1);
-		return (expanded);
-	}
-
-	if (*path == '$') {
-		end = strchr(path, '/');
-		if (end == NULL)
-			name = xstrdup(path + 1);
-		else
-			name = xstrndup(path + 1, end - path - 1);
-		value = environ_find(global_environ, name);
-		free(name);
-		if (value == NULL)
-			return (NULL);
-		if (end == NULL)
-			end = "";
-		xasprintf(&expanded, "%s%s", value->value, end);
-		return (expanded);
-	}
-
-	return (xstrdup(path));
-}
-
 void
 start_cfg(void)
 {
-	const char	*home = find_home();
+	struct client	 *c;
-	struct client	*c;
+	u_int		  i;
-	char		*path, *copy, *next, *expanded;
 
 	/*
 	 * Configuration files are loaded without a client, so commands are run
@@ -122,21 +84,12 @@ start_cfg(void)
 		cmdq_append(c, cfg_item);
 	}
 
-	if (cfg_file == NULL) {
+	for (i = 0; i < cfg_nfiles; i++) {
-		path = copy = xstrdup(TMUX_CONF);
+		if (cfg_quiet)
-		while ((next = strsep(&path, ":")) != NULL) {
+			load_cfg(cfg_files[i], c, NULL, CMD_PARSE_QUIET, NULL);
-			expanded = expand_cfg_file(next, home);
+		else
-			if (expanded == NULL) {
+			load_cfg(cfg_files[i], c, NULL, 0, NULL);
-				log_debug("couldn't expand %s", next);
+	}
-				continue;
-			}
-			log_debug("expanded %s to %s", next, expanded);
-			load_cfg(expanded, c, NULL, CMD_PARSE_QUIET, NULL);
-			free(expanded);
-		}
-		free(copy);
-	} else
-		load_cfg(cfg_file, c, NULL, 0, NULL);
 
 	cmdq_append(NULL, cmdq_get_callback(cfg_done, NULL));
 }
@@ -149,6 +102,7 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item, int flags,
 	struct cmd_parse_input	 pi;
 	struct cmd_parse_result	*pr;
 	struct cmdq_item	*new_item0;
+	struct cmdq_state	*state;
 
 	if (new_item != NULL)
 		*new_item = NULL;
@@ -182,12 +136,19 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item, int flags,
 		return (0);
 	}
 
-	new_item0 = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+	if (item != NULL)
+		state = cmdq_copy_state(cmdq_get_state(item));
+	else
+		state = cmdq_new_state(NULL, NULL, 0);
+	cmdq_add_format(state, "current_file", "%s", pi.file);
+
+	new_item0 = cmdq_get_command(pr->cmdlist, state);
 	if (item != NULL)
 		new_item0 = cmdq_insert_after(item, new_item0);
 	else
 		new_item0 = cmdq_append(NULL, new_item0);
 	cmd_list_free(pr->cmdlist);
+	cmdq_free_state(state);
 
 	if (new_item != NULL)
 		*new_item = new_item0;
@@ -202,6 +163,7 @@ load_cfg_from_buffer(const void *buf, size_t len, const char *path,
 	struct cmd_parse_input	 pi;
 	struct cmd_parse_result	*pr;
 	struct cmdq_item	*new_item0;
+	struct cmdq_state	*state;
 
 	if (new_item != NULL)
 		*new_item = NULL;
@@ -228,12 +190,19 @@ load_cfg_from_buffer(const void *buf, size_t len, const char *path,
 		return (0);
 	}
 
-	new_item0 = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+	if (item != NULL)
+		state = cmdq_copy_state(cmdq_get_state(item));
+	else
+		state = cmdq_new_state(NULL, NULL, 0);
+	cmdq_add_format(state, "current_file", "%s", pi.file);
+
+	new_item0 = cmdq_get_command(pr->cmdlist, state);
 	if (item != NULL)
 		new_item0 = cmdq_insert_after(item, new_item0);
 	else
 		new_item0 = cmdq_append(NULL, new_item0);
 	cmd_list_free(pr->cmdlist);
+	cmdq_free_state(state);
 
 	if (new_item != NULL)
 		*new_item = new_item0;
@@ -283,7 +252,7 @@ cfg_show_causes(struct session *s)
 
 	wme = TAILQ_FIRST(&wp->modes);
 	if (wme == NULL || wme->mode != &window_view_mode)
-		window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
+		window_pane_set_mode(wp, NULL, &window_view_mode, NULL, NULL);
 	for (i = 0; i < cfg_ncauses; i++) {
 		window_copy_add(wp, "%s", cfg_causes[i]);
 		free(cfg_causes[i]);

client.c

@@ -18,12 +18,12 @@
 
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/uio.h>
 #include <sys/un.h>
 #include <sys/wait.h>
 #include <sys/file.h>
 
 #include <errno.h>
-#include <event.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
@@ -34,7 +34,8 @@
 
 static struct tmuxproc	*client_proc;
 static struct tmuxpeer	*client_peer;
-static int		 client_flags;
+static uint64_t		 client_flags;
+static int		 client_suspended;
 static enum {
 	CLIENT_EXIT_NONE,
 	CLIENT_EXIT_DETACHED,
@@ -44,11 +45,13 @@ static enum {
 	CLIENT_EXIT_LOST_SERVER,
 	CLIENT_EXIT_EXITED,
 	CLIENT_EXIT_SERVER_EXITED,
+	CLIENT_EXIT_MESSAGE_PROVIDED
 } client_exitreason = CLIENT_EXIT_NONE;
 static int		 client_exitflag;
 static int		 client_exitval;
 static enum msgtype	 client_exittype;
 static const char	*client_exitsession;
+static char		*client_exitmessage;
 static const char	*client_execshell;
 static const char	*client_execcmd;
 static int		 client_attached;
@@ -56,8 +59,10 @@ static struct client_files client_files = RB_INITIALIZER(&client_files);
 
 static __dead void	 client_exec(const char *,const char *);
 static int		 client_get_lock(char *);
-static int		 client_connect(struct event_base *, const char *, int);
+static int		 client_connect(struct event_base *, const char *,
-static void		 client_send_identify(const char *, const char *);
+			     uint64_t);
+static void		 client_send_identify(const char *, const char *,
+			     char **, u_int, const char *, int);
 static void		 client_signal(int);
 static void		 client_dispatch(struct imsg *, void *);
 static void		 client_dispatch_attached(struct imsg *);
@@ -97,7 +102,7 @@ client_get_lock(char *lockfile)
 
 /* Connect client to server. */
 static int
-client_connect(struct event_base *base, const char *path, int start_server)
+client_connect(struct event_base *base, const char *path, uint64_t flags)
 {
 	struct sockaddr_un	sa;
 	size_t			size;
@@ -122,7 +127,9 @@ retry:
 		log_debug("connect failed: %s", strerror(errno));
 		if (errno != ECONNREFUSED && errno != ENOENT)
 			goto failed;
-		if (!start_server)
+		if (flags & CLIENT_NOSTARTSERVER)
+			goto failed;
+		if (~flags & CLIENT_STARTSERVER)
 			goto failed;
 		close(fd);
 
@@ -154,7 +161,7 @@ retry:
 			close(lockfd);
 			return (-1);
 		}
-		fd = server_start(client_proc, base, lockfd, lockfile);
+		fd = server_start(client_proc, flags, base, lockfd, lockfile);
 	}
 
 	if (locked && lockfd >= 0) {
@@ -206,6 +213,8 @@ client_exit_message(void)
 		return ("exited");
 	case CLIENT_EXIT_SERVER_EXITED:
 		return ("server exited");
+	case CLIENT_EXIT_MESSAGE_PROVIDED:
+		return (client_exitmessage);
 	}
 	return ("unknown reason");
 }
@@ -214,51 +223,37 @@ client_exit_message(void)
 static void
 client_exit(void)
 {
-	struct client_file	*cf;
+	if (!file_write_left(&client_files))
-	size_t 			 left;
-	int			 waiting = 0;
-
-	RB_FOREACH (cf, client_files, &client_files) {
-		if (cf->event == NULL)
-			continue;
-		left = EVBUFFER_LENGTH(cf->event->output);
-		if (left != 0) {
-			waiting++;
-			log_debug("file %u %zu bytes left", cf->stream, left);
-		}
-	}
-	if (waiting == 0)
 		proc_exit(client_proc);
 }
 
 /* Client main loop. */
 int
-client_main(struct event_base *base, int argc, char **argv, int flags)
+client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
+    int feat)
 {
 	struct cmd_parse_result	*pr;
-	struct cmd		*cmd;
 	struct msg_command	*data;
-	int			 cmdflags, fd, i;
+	int			 fd, i;
-	const char		*ttynam, *cwd;
+	const char		*ttynam, *termname, *cwd;
 	pid_t			 ppid;
 	enum msgtype		 msg;
 	struct termios		 tio, saved_tio;
-	size_t			 size;
+	size_t			 size, linesize = 0;
+	ssize_t			 linelen;
+	char			*line = NULL, **caps = NULL, *cause;
+	u_int			 ncaps = 0;
 
 	/* Ignore SIGCHLD now or daemon() in the server will leave a zombie. */
 	signal(SIGCHLD, SIG_IGN);
 
-	/* Save the flags. */
-	client_flags = flags;
-
 	/* Set up the initial command. */
-	cmdflags = 0;
 	if (shell_command != NULL) {
 		msg = MSG_SHELL;
-		cmdflags = CMD_STARTSERVER;
+		flags |= CLIENT_STARTSERVER;
 	} else if (argc == 0) {
 		msg = MSG_COMMAND;
-		cmdflags = CMD_STARTSERVER;
+		flags |= CLIENT_STARTSERVER;
 	} else {
 		msg = MSG_COMMAND;
 
@@ -269,10 +264,8 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 		 */
 		pr = cmd_parse_from_arguments(argc, argv, NULL);
 		if (pr->status == CMD_PARSE_SUCCESS) {
-			TAILQ_FOREACH(cmd, &pr->cmdlist->list, qentry) {
+			if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))
-				if (cmd->entry->flags & CMD_STARTSERVER)
+				flags |= CLIENT_STARTSERVER;
-					cmdflags |= CMD_STARTSERVER;
-			}
 			cmd_list_free(pr->cmdlist);
 		} else
 			free(pr->error);
@@ -282,8 +275,12 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 	client_proc = proc_start("client");
 	proc_set_signals(client_proc, client_signal);
 
+	/* Save the flags. */
+	client_flags = flags;
+	log_debug("flags are %#llx", (unsigned long long)client_flags);
+
 	/* Initialize the client socket and start the server. */
-	fd = client_connect(base, socket_path, cmdflags & CMD_STARTSERVER);
+	fd = client_connect(base, socket_path, client_flags);
 	if (fd == -1) {
 		if (errno == ECONNREFUSED) {
 			fprintf(stderr, "no server running on %s\n",
@@ -301,6 +298,8 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 		cwd = "/";
 	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
 		ttynam = "";
+	if ((termname = getenv("TERM")) == NULL)
+		termname = "";
 
 	/*
 	 * Drop privileges for client. "proc exec" is needed for -c and for
@@ -316,6 +315,16 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 	    NULL) != 0)
 		fatal("pledge failed");
 
+	/* Load terminfo entry if any. */
+	if (isatty(STDIN_FILENO) &&
+	    *termname != '\0' &&
+	    tty_term_read_list(termname, STDIN_FILENO, &caps, &ncaps,
+	    &cause) != 0) {
+		fprintf(stderr, "%s\n", cause);
+		free(cause);
+		return (1);
+	}
+
 	/* Free stuff that is not used in the client. */
 	if (ptm_fd != -1)
 		close(ptm_fd);
@@ -346,7 +355,8 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 	}
 
 	/* Send identify messages. */
-	client_send_identify(ttynam, cwd);
+	client_send_identify(ttynam, termname, caps, ncaps, cwd, feat);
+	tty_term_free_list(caps, ncaps);
 
 	/* Send first command. */
 	if (msg == MSG_COMMAND) {
@@ -389,6 +399,11 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 		client_exec(client_execshell, client_execcmd);
 	}
 
+	/* Restore streams to blocking. */
+	setblocking(STDIN_FILENO, 1);
+	setblocking(STDOUT_FILENO, 1);
+	setblocking(STDERR_FILENO, 1);
+
 	/* Print the exit message, if any, and exit. */
 	if (client_attached) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
@@ -397,42 +412,65 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 		ppid = getppid();
 		if (client_exittype == MSG_DETACHKILL && ppid > 1)
 			kill(ppid, SIGHUP);
-	} else if (client_flags & CLIENT_CONTROLCONTROL) {
+	} else if (client_flags & CLIENT_CONTROL) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
 			printf("%%exit %s\n", client_exit_message());
 		else
 			printf("%%exit\n");
-		printf("\033\\");
+		fflush(stdout);
-		tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
+		if (client_flags & CLIENT_CONTROL_WAITEXIT) {
+			setvbuf(stdin, NULL, _IOLBF, 0);
+			for (;;) {
+				linelen = getline(&line, &linesize, stdin);
+				if (linelen <= 1)
+					break;
+			}
+			free(line);
+		}
+		if (client_flags & CLIENT_CONTROLCONTROL) {
+			printf("\033\\");
+			fflush(stdout);
+			tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
+		}
 	} else if (client_exitreason != CLIENT_EXIT_NONE)
 		fprintf(stderr, "%s\n", client_exit_message());
-	setblocking(STDIN_FILENO, 1);
 	return (client_exitval);
 }
 
 /* Send identify messages to server. */
 static void
-client_send_identify(const char *ttynam, const char *cwd)
+client_send_identify(const char *ttynam, const char *termname, char **caps,
+    u_int ncaps, const char *cwd, int feat)
 {
-	const char	 *s;
+	char	**ss;
-	char		**ss;
+	size_t	  sslen;
-	size_t		  sslen;
+	int	  fd, flags = client_flags;
-	int		  fd, flags = client_flags;
+	pid_t	  pid;
-	pid_t		  pid;
+	u_int	  i;
 
 	proc_send(client_peer, MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
+	proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &client_flags,
+	    sizeof client_flags);
 
-	if ((s = getenv("TERM")) == NULL)
+	proc_send(client_peer, MSG_IDENTIFY_TERM, -1, termname,
-		s = "";
+	    strlen(termname) + 1);
-	proc_send(client_peer, MSG_IDENTIFY_TERM, -1, s, strlen(s) + 1);
+	proc_send(client_peer, MSG_IDENTIFY_FEATURES, -1, &feat, sizeof feat);
 
 	proc_send(client_peer, MSG_IDENTIFY_TTYNAME, -1, ttynam,
 	    strlen(ttynam) + 1);
 	proc_send(client_peer, MSG_IDENTIFY_CWD, -1, cwd, strlen(cwd) + 1);
 
+	for (i = 0; i < ncaps; i++) {
+		proc_send(client_peer, MSG_IDENTIFY_TERMINFO, -1,
+		    caps[i], strlen(caps[i]) + 1);
+	}
+
 	if ((fd = dup(STDIN_FILENO)) == -1)
 		fatal("dup failed");
 	proc_send(client_peer, MSG_IDENTIFY_STDIN, fd, NULL, 0);
+	if ((fd = dup(STDOUT_FILENO)) == -1)
+		fatal("dup failed");
+	proc_send(client_peer, MSG_IDENTIFY_STDOUT, fd, NULL, 0);
 
 	pid = getpid();
 	proc_send(client_peer, MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);
@@ -447,257 +485,6 @@ client_send_identify(const char *ttynam, const char *cwd)
 	proc_send(client_peer, MSG_IDENTIFY_DONE, -1, NULL, 0);
 }
 
-/* File write error callback. */
-static void
-client_write_error_callback(__unused struct bufferevent *bev,
-    __unused short what, void *arg)
-{
-	struct client_file	*cf = arg;
-
-	log_debug("write error file %d", cf->stream);
-
-	bufferevent_free(cf->event);
-	cf->event = NULL;
-
-	close(cf->fd);
-	cf->fd = -1;
-
-	if (client_exitflag)
-		client_exit();
-}
-
-/* File write callback. */
-static void
-client_write_callback(__unused struct bufferevent *bev, void *arg)
-{
-	struct client_file	*cf = arg;
-
-	if (cf->closed && EVBUFFER_LENGTH(cf->event->output) == 0) {
-		bufferevent_free(cf->event);
-		close(cf->fd);
-		RB_REMOVE(client_files, &client_files, cf);
-		file_free(cf);
-	}
-
-	if (client_exitflag)
-		client_exit();
-}
-
-/* Open write file. */
-static void
-client_write_open(void *data, size_t datalen)
-{
-	struct msg_write_open	*msg = data;
-	const char		*path;
-	struct msg_write_ready	 reply;
-	struct client_file	 find, *cf;
-	const int		 flags = O_NONBLOCK|O_WRONLY|O_CREAT;
-	int			 error = 0;
-
-	if (datalen < sizeof *msg)
-		fatalx("bad MSG_WRITE_OPEN size");
-	if (datalen == sizeof *msg)
-		path = "-";
-	else
-		path = (const char *)(msg + 1);
-	log_debug("open write file %d %s", msg->stream, path);
-
-	find.stream = msg->stream;
-	if ((cf = RB_FIND(client_files, &client_files, &find)) == NULL) {
-		cf = file_create(NULL, msg->stream, NULL, NULL);
-		RB_INSERT(client_files, &client_files, cf);
-	} else {
-		error = EBADF;
-		goto reply;
-	}
-	if (cf->closed) {
-		error = EBADF;
-		goto reply;
-	}
-
-	cf->fd = -1;
-	if (msg->fd == -1)
-		cf->fd = open(path, msg->flags|flags, 0644);
-	else {
-		if (msg->fd != STDOUT_FILENO && msg->fd != STDERR_FILENO)
-			errno = EBADF;
-		else {
-			cf->fd = dup(msg->fd);
-			if (~client_flags & CLIENT_CONTROL)
-				close(msg->fd); /* can only be used once */
-		}
-	}
-	if (cf->fd == -1) {
-		error = errno;
-		goto reply;
-	}
-
-	cf->event = bufferevent_new(cf->fd, NULL, client_write_callback,
-	    client_write_error_callback, cf);
-	bufferevent_enable(cf->event, EV_WRITE);
-	goto reply;
-
-reply:
-	reply.stream = msg->stream;
-	reply.error = error;
-	proc_send(client_peer, MSG_WRITE_READY, -1, &reply, sizeof reply);
-}
-
-/* Write to client file. */
-static void
-client_write_data(void *data, size_t datalen)
-{
-	struct msg_write_data	*msg = data;
-	struct client_file	 find, *cf;
-	size_t			 size = datalen - sizeof *msg;
-
-	if (datalen < sizeof *msg)
-		fatalx("bad MSG_WRITE size");
-	find.stream = msg->stream;
-	if ((cf = RB_FIND(client_files, &client_files, &find)) == NULL)
-		fatalx("unknown stream number");
-	log_debug("write %zu to file %d", size, cf->stream);
-
-	if (cf->event != NULL)
-		bufferevent_write(cf->event, msg + 1, size);
-}
-
-/* Close client file. */
-static void
-client_write_close(void *data, size_t datalen)
-{
-	struct msg_write_close	*msg = data;
-	struct client_file	 find, *cf;
-
-	if (datalen != sizeof *msg)
-		fatalx("bad MSG_WRITE_CLOSE size");
-	find.stream = msg->stream;
-	if ((cf = RB_FIND(client_files, &client_files, &find)) == NULL)
-		fatalx("unknown stream number");
-	log_debug("close file %d", cf->stream);
-
-	if (cf->event == NULL || EVBUFFER_LENGTH(cf->event->output) == 0) {
-		if (cf->event != NULL)
-			bufferevent_free(cf->event);
-		if (cf->fd != -1)
-			close(cf->fd);
-		RB_REMOVE(client_files, &client_files, cf);
-		file_free(cf);
-	}
-}
-
-/* File read callback. */
-static void
-client_read_callback(__unused struct bufferevent *bev, void *arg)
-{
-	struct client_file	*cf = arg;
-	void			*bdata;
-	size_t			 bsize;
-	struct msg_read_data	*msg;
-	size_t			 msglen;
-
-	msg = xmalloc(sizeof *msg);
-	for (;;) {
-		bdata = EVBUFFER_DATA(cf->event->input);
-		bsize = EVBUFFER_LENGTH(cf->event->input);
-
-		if (bsize == 0)
-			break;
-		if (bsize > MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg)
-			bsize = MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg;
-		log_debug("read %zu from file %d", bsize, cf->stream);
-
-		msglen = (sizeof *msg) + bsize;
-		msg = xrealloc(msg, msglen);
-		msg->stream = cf->stream;
-		memcpy(msg + 1, bdata, bsize);
-		proc_send(client_peer, MSG_READ, -1, msg, msglen);
-
-		evbuffer_drain(cf->event->input, bsize);
-	}
-	free(msg);
-}
-
-/* File read error callback. */
-static void
-client_read_error_callback(__unused struct bufferevent *bev,
-    __unused short what, void *arg)
-{
-	struct client_file	*cf = arg;
-	struct msg_read_done	 msg;
-
-	log_debug("read error file %d", cf->stream);
-
-	msg.stream = cf->stream;
-	msg.error = 0;
-	proc_send(client_peer, MSG_READ_DONE, -1, &msg, sizeof msg);
-
-	bufferevent_free(cf->event);
-	close(cf->fd);
-	RB_REMOVE(client_files, &client_files, cf);
-	file_free(cf);
-}
-
-/* Open read file. */
-static void
-client_read_open(void *data, size_t datalen)
-{
-	struct msg_read_open	*msg = data;
-	const char		*path;
-	struct msg_read_done	 reply;
-	struct client_file	 find, *cf;
-	const int		 flags = O_NONBLOCK|O_RDONLY;
-	int			 error = 0;
-
-	if (datalen < sizeof *msg)
-		fatalx("bad MSG_READ_OPEN size");
-	if (datalen == sizeof *msg)
-		path = "-";
-	else
-		path = (const char *)(msg + 1);
-	log_debug("open read file %d %s", msg->stream, path);
-
-	find.stream = msg->stream;
-	if ((cf = RB_FIND(client_files, &client_files, &find)) == NULL) {
-		cf = file_create(NULL, msg->stream, NULL, NULL);
-		RB_INSERT(client_files, &client_files, cf);
-	} else {
-		error = EBADF;
-		goto reply;
-	}
-	if (cf->closed) {
-		error = EBADF;
-		goto reply;
-	}
-
-	cf->fd = -1;
-	if (msg->fd == -1)
-		cf->fd = open(path, flags);
-	else {
-		if (msg->fd != STDIN_FILENO)
-			errno = EBADF;
-		else {
-			cf->fd = dup(msg->fd);
-			if (~client_flags & CLIENT_CONTROL)
-				close(msg->fd); /* can only be used once */
-		}
-	}
-	if (cf->fd == -1) {
-		error = errno;
-		goto reply;
-	}
-
-	cf->event = bufferevent_new(cf->fd, client_read_callback, NULL,
-	    client_read_error_callback, cf);
-	bufferevent_enable(cf->event, EV_READ);
-	return;
-
-reply:
-	reply.stream = msg->stream;
-	reply.error = error;
-	proc_send(client_peer, MSG_READ_DONE, -1, &reply, sizeof reply);
-}
-
 /* Run command in shell; used for -c. */
 static __dead void
 client_exec(const char *shell, const char *shellcmd)
@@ -736,6 +523,7 @@ client_signal(int sig)
 	struct sigaction sigact;
 	int		 status;
 
+	log_debug("%s: %s", __func__, strsignal(sig));
 	if (sig == SIGCHLD)
 		waitpid(WAIT_ANY, &status, WNOHANG);
 	else if (!client_attached) {
@@ -749,7 +537,8 @@ client_signal(int sig)
 			proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 			break;
 		case SIGTERM:
-			client_exitreason = CLIENT_EXIT_TERMINATED;
+			if (!client_suspended)
+				client_exitreason = CLIENT_EXIT_TERMINATED;
 			client_exitval = 1;
 			proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 			break;
@@ -764,18 +553,31 @@ client_signal(int sig)
 			if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 				fatal("sigaction failed");
 			proc_send(client_peer, MSG_WAKEUP, -1, NULL, 0);
+			client_suspended = 0;
 			break;
 		}
 	}
 }
 
+/* Callback for file write error or close. */
+static void
+client_file_check_cb(__unused struct client *c, __unused const char *path,
+    __unused int error, __unused int closed, __unused struct evbuffer *buffer,
+    __unused void *data)
+{
+	if (client_exitflag)
+		client_exit();
+}
+
 /* Callback for client read events. */
 static void
 client_dispatch(struct imsg *imsg, __unused void *arg)
 {
 	if (imsg == NULL) {
-		client_exitreason = CLIENT_EXIT_LOST_SERVER;
+		if (!client_exitflag) {
-		client_exitval = 1;
+			client_exitreason = CLIENT_EXIT_LOST_SERVER;
+			client_exitval = 1;
+		}
 		proc_exit(client_proc);
 		return;
 	}
@@ -786,13 +588,38 @@ client_dispatch(struct imsg *imsg, __unused void *arg)
 		client_dispatch_wait(imsg);
 }
 
+/* Process an exit message. */
+static void
+client_dispatch_exit_message(char *data, size_t datalen)
+{
+	int	retval;
+
+	if (datalen < sizeof retval && datalen != 0)
+		fatalx("bad MSG_EXIT size");
+
+	if (datalen >= sizeof retval) {
+		memcpy(&retval, data, sizeof retval);
+		client_exitval = retval;
+	}
+
+	if (datalen > sizeof retval) {
+		datalen -= sizeof retval;
+		data += sizeof retval;
+
+		client_exitmessage = xmalloc(datalen);
+		memcpy(client_exitmessage, data, datalen);
+		client_exitmessage[datalen - 1] = '\0';
+
+		client_exitreason = CLIENT_EXIT_MESSAGE_PROVIDED;
+	}
+}
+
 /* Dispatch imsgs when in wait state (before MSG_READY). */
 static void
 client_dispatch_wait(struct imsg *imsg)
 {
 	char		*data;
 	ssize_t		 datalen;
-	int		 retval;
 	static int	 pledge_applied;
 
 	/*
@@ -815,12 +642,7 @@ client_dispatch_wait(struct imsg *imsg)
 	switch (imsg->hdr.type) {
 	case MSG_EXIT:
 	case MSG_SHUTDOWN:
-		if (datalen != sizeof retval && datalen != 0)
+		client_dispatch_exit_message(data, datalen);
-			fatalx("bad MSG_EXIT size");
-		if (datalen == sizeof retval) {
-			memcpy(&retval, data, sizeof retval);
-			client_exitval = retval;
-		}
 		client_exitflag = 1;
 		client_exit();
 		break;
@@ -841,6 +663,14 @@ client_dispatch_wait(struct imsg *imsg)
 		client_exitval = 1;
 		proc_exit(client_proc);
 		break;
+	case MSG_FLAGS:
+		if (datalen != sizeof client_flags)
+			fatalx("bad MSG_FLAGS string");
+
+		memcpy(&client_flags, data, sizeof client_flags);
+		log_debug("new flags are %#llx",
+		    (unsigned long long)client_flags);
+		break;
 	case MSG_SHELL:
 		if (datalen == 0 || data[datalen - 1] != '\0')
 			fatalx("bad MSG_SHELL string");
@@ -855,16 +685,20 @@ client_dispatch_wait(struct imsg *imsg)
 		proc_exit(client_proc);
 		break;
 	case MSG_READ_OPEN:
-		client_read_open(data, datalen);
+		file_read_open(&client_files, client_peer, imsg, 1,
+		    !(client_flags & CLIENT_CONTROL), client_file_check_cb,
+		    NULL);
 		break;
 	case MSG_WRITE_OPEN:
-		client_write_open(data, datalen);
+		file_write_open(&client_files, client_peer, imsg, 1,
+		    !(client_flags & CLIENT_CONTROL), client_file_check_cb,
+		    NULL);
 		break;
 	case MSG_WRITE:
-		client_write_data(data, datalen);
+		file_write_data(&client_files, imsg);
 		break;
 	case MSG_WRITE_CLOSE:
-		client_write_close(data, datalen);
+		file_write_close(&client_files, imsg);
 		break;
 	case MSG_OLDSTDERR:
 	case MSG_OLDSTDIN:
@@ -887,6 +721,14 @@ client_dispatch_attached(struct imsg *imsg)
 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 
 	switch (imsg->hdr.type) {
+	case MSG_FLAGS:
+		if (datalen != sizeof client_flags)
+			fatalx("bad MSG_FLAGS string");
+
+		memcpy(&client_flags, data, sizeof client_flags);
+		log_debug("new flags are %#llx",
+		    (unsigned long long)client_flags);
+		break;
 	case MSG_DETACH:
 	case MSG_DETACHKILL:
 		if (datalen == 0 || data[datalen - 1] != '\0')
@@ -911,11 +753,10 @@ client_dispatch_attached(struct imsg *imsg)
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
 	case MSG_EXIT:
-		if (datalen != 0 && datalen != sizeof (int))
+		client_dispatch_exit_message(data, datalen);
-			fatalx("bad MSG_EXIT size");
+		if (client_exitreason == CLIENT_EXIT_NONE)
-
+			client_exitreason = CLIENT_EXIT_EXITED;
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
-		client_exitreason = CLIENT_EXIT_EXITED;
 		break;
 	case MSG_EXITED:
 		if (datalen != 0)
@@ -941,6 +782,7 @@ client_dispatch_attached(struct imsg *imsg)
 		sigact.sa_handler = SIG_DFL;
 		if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 			fatal("sigaction failed");
+		client_suspended = 1;
 		kill(getpid(), SIGTSTP);
 		break;
 	case MSG_LOCK:

cmd-attach-session.c

@@ -37,8 +37,9 @@ const struct cmd_entry cmd_attach_session_entry = {
 	.name = "attach-session",
 	.alias = "attach",
 
-	.args = { "c:dErt:x", 0, 0 },
+	.args = { "c:dEf:rt:x", 0, 0 },
-	.usage = "[-dErx] [-c working-directory] " CMD_TARGET_SESSION_USAGE,
+	.usage = "[-dErx] [-c working-directory] [-f flags] "
+	         CMD_TARGET_SESSION_USAGE,
 
 	/* -t is special */
 
@@ -48,16 +49,17 @@ const struct cmd_entry cmd_attach_session_entry = {
 
 enum cmd_retval
 cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
-    int xflag, int rflag, const char *cflag, int Eflag)
+    int xflag, int rflag, const char *cflag, int Eflag, const char *fflag)
 {
-	struct cmd_find_state	*current = &item->shared->current;
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	 target;
 	enum cmd_find_type	 type;
 	int			 flags;
-	struct client		*c = item->client, *c_loop;
+	struct client		*c = cmdq_get_client(item), *c_loop;
 	struct session		*s;
 	struct winlink		*wl;
 	struct window_pane	*wp;
-	char			*cause;
+	char			*cwd, *cause;
 	enum msgtype		 msgtype;
 
 	if (RB_EMPTY(&sessions)) {
@@ -80,11 +82,11 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 		type = CMD_FIND_SESSION;
 		flags = CMD_FIND_PREFER_UNATTACHED;
 	}
-	if (cmd_find_target(&item->target, item, tflag, type, flags) != 0)
+	if (cmd_find_target(&target, item, tflag, type, flags) != 0)
 		return (CMD_RETURN_ERROR);
-	s = item->target.s;
+	s = target.s;
-	wl = item->target.wl;
+	wl = target.wl;
-	wp = item->target.wp;
+	wp = target.wp;
 
 	if (wl != NULL) {
 		if (wp != NULL)
@@ -97,9 +99,14 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 	}
 
 	if (cflag != NULL) {
+		cwd = format_single(item, cflag, c, s, wl, wp);
 		free((void *)s->cwd);
-		s->cwd = format_single(item, cflag, c, s, wl, wp);
+		s->cwd = cwd;
 	}
+	if (fflag)
+		server_client_set_flags(c, fflag);
+	if (rflag)
+		c->flags |= (CLIENT_READONLY|CLIENT_IGNORESIZE);
 
 	c->last_session = c->session;
 	if (c->session != NULL) {
@@ -118,7 +125,7 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 			environ_update(s->options, c->environ, s->environ);
 
 		c->session = s;
-		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+		if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
 			server_client_set_key_table(c, NULL);
 		tty_update_client_offset(c);
 		status_timer_start(c);
@@ -134,8 +141,6 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
-		if (rflag)
-			c->flags |= CLIENT_READONLY;
 
 		if (dflag || xflag) {
 			if (xflag)
@@ -177,9 +182,9 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 static enum cmd_retval
 cmd_attach_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args	*args = cmd_get_args(self);
 
 	return (cmd_attach_session(item, args_get(args, 't'),
 	    args_has(args, 'd'), args_has(args, 'x'), args_has(args, 'r'),
-	    args_get(args, 'c'), args_has(args, 'E')));
+	    args_get(args, 'c'), args_has(args, 'E'), args_get(args, 'f')));
 }

cmd-bind-key.c

@@ -33,9 +33,9 @@ const struct cmd_entry cmd_bind_key_entry = {
 	.name = "bind-key",
 	.alias = "bind",
 
-	.args = { "nrN:T:", 2, -1 },
+	.args = { "nrN:T:", 1, -1 },
 	.usage = "[-nr] [-T key-table] [-N note] key "
-	         "command [arguments]",
+	         "[command [arguments]]",
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_bind_key_exec
@@ -44,9 +44,9 @@ const struct cmd_entry cmd_bind_key_entry = {
 static enum cmd_retval
 cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		 *args = self->args;
+	struct args		 *args = cmd_get_args(self);
 	key_code		  key;
-	const char		 *tablename, *note;
+	const char		 *tablename, *note = args_get(args, 'N');
 	struct cmd_parse_result	 *pr;
 	char			**argv = args->argv;
 	int			  argc = args->argc, repeat;
@@ -65,22 +65,24 @@ cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 		tablename = "prefix";
 	repeat = args_has(args, 'r');
 
-	if (argc == 2)
+	if (argc != 1) {
-		pr = cmd_parse_from_string(argv[1], NULL);
+		if (argc == 2)
-	else
+			pr = cmd_parse_from_string(argv[1], NULL);
-		pr = cmd_parse_from_arguments(argc - 1, argv + 1, NULL);
+		else
-	switch (pr->status) {
+			pr = cmd_parse_from_arguments(argc - 1, argv + 1, NULL);
-	case CMD_PARSE_EMPTY:
+		switch (pr->status) {
-		cmdq_error(item, "empty command");
+		case CMD_PARSE_EMPTY:
-		return (CMD_RETURN_ERROR);
+			cmdq_error(item, "empty command");
-	case CMD_PARSE_ERROR:
+			return (CMD_RETURN_ERROR);
-		cmdq_error(item, "%s", pr->error);
+		case CMD_PARSE_ERROR:
-		free(pr->error);
+			cmdq_error(item, "%s", pr->error);
-		return (CMD_RETURN_ERROR);
+			free(pr->error);
-	case CMD_PARSE_SUCCESS:
+			return (CMD_RETURN_ERROR);
-		break;
+		case CMD_PARSE_SUCCESS:
-	}
+			break;
-	note = args_get(args, 'N');
+		}
-	key_bindings_add(tablename, key, note, repeat, pr->cmdlist);
+		key_bindings_add(tablename, key, note, repeat, pr->cmdlist);
+	} else
+		key_bindings_add(tablename, key, note, repeat, NULL);
 	return (CMD_RETURN_NORMAL);
 }

cmd-break-pane.c

@@ -34,8 +34,8 @@ const struct cmd_entry cmd_break_pane_entry = {
 	.name = "break-pane",
 	.alias = "breakp",
 
-	.args = { "dPF:n:s:t:", 0, 0 },
+	.args = { "abdPF:n:s:t:", 0, 0 },
-	.usage = "[-dP] [-F format] [-n window-name] [-s src-pane] "
+	.usage = "[-abdP] [-F format] [-n window-name] [-s src-pane] "
 		 "[-t dst-window]",
 
 	.source = { 's', CMD_FIND_PANE, 0 },
@@ -48,31 +48,52 @@ const struct cmd_entry cmd_break_pane_entry = {
 static enum cmd_retval
 cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = &item->shared->current;
+	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct winlink		*wl = item->source.wl;
+	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct session		*src_s = item->source.s;
+	struct client		*tc = cmdq_get_target_client(item);
-	struct session		*dst_s = item->target.s;
+	struct winlink		*wl = source->wl;
-	struct window_pane	*wp = item->source.wp;
+	struct session		*src_s = source->s;
+	struct session		*dst_s = target->s;
+	struct window_pane	*wp = source->wp;
 	struct window		*w = wl->window;
-	char			*name, *cause;
+	char			*name, *cause, *cp;
-	int			 idx = item->target.idx;
+	int			 idx = target->idx, before;
 	const char		*template;
-	char			*cp;
 
-	if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
+	before = args_has(args, 'b');
-		cmdq_error(item, "index %d already in use", idx);
+	if (args_has(args, 'a') || before) {
-		return (CMD_RETURN_ERROR);
+		if (target->wl != NULL)
-	}
+			idx = winlink_shuffle_up(dst_s, target->wl, before);
-
+		else
-	if (window_count_panes(w) == 1) {
+			idx = winlink_shuffle_up(dst_s, dst_s->curw, before);
-		cmdq_error(item, "can't break with only one pane");
+		if (idx == -1)
-		return (CMD_RETURN_ERROR);
+			return (CMD_RETURN_ERROR);
 	}
 	server_unzoom_window(w);
 
+	if (window_count_panes(w) == 1) {
+		if (server_link_window(src_s, wl, dst_s, idx, 0,
+		    !args_has(args, 'd'), &cause) != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+		if (args_has(args, 'n')) {
+			window_set_name(w, args_get(args, 'n'));
+			options_set_number(w->options, "automatic-rename", 0);
+		}
+		server_unlink_window(src_s, wl);
+		return (CMD_RETURN_NORMAL);
+	}
+	if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
+		cmdq_error(item, "index in use: %d", idx);
+		return (CMD_RETURN_ERROR);
+	}
+
 	TAILQ_REMOVE(&w->panes, wp, entry);
+	server_client_remove_pane(wp);
 	window_lost_pane(w, wp);
 	layout_close_pane(wp);
 
@@ -81,7 +102,7 @@ cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 	wp->flags |= PANE_STYLECHANGED;
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	w->active = wp;
-	w->latest = c;
+	w->latest = tc;
 
 	if (!args_has(args, 'n')) {
 		name = default_window_name(w);
@@ -98,7 +119,7 @@ cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 	if (idx == -1)
 		idx = -1 - options_get_number(dst_s->options, "base-index");
 	wl = session_attach(dst_s, w, idx, &cause); /* can't fail */
-	if (!args_has(self->args, 'd')) {
+	if (!args_has(args, 'd')) {
 		session_select(dst_s, wl->idx);
 		cmd_find_from_session(current, dst_s, 0);
 	}
@@ -113,7 +134,7 @@ cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = BREAK_PANE_TEMPLATE;
-		cp = format_single(item, template, c, dst_s, wl, wp);
+		cp = format_single(item, template, tc, dst_s, wl, wp);
 		cmdq_print(item, "%s", cp);
 		free(cp);
 	}

cmd-capture-pane.c

@@ -80,7 +80,7 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	size_t		 linelen;
 	u_int		 i;
 
-	pending = input_pending(wp);
+	pending = input_pending(wp->ictx);
 	if (pending == NULL)
 		return (xstrdup(""));
 
@@ -118,7 +118,7 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 
 	sx = screen_size_x(&wp->base);
 	if (args_has(args, 'a')) {
-		gd = wp->saved_grid;
+		gd = wp->base.saved_grid;
 		if (gd == NULL) {
 			if (!args_has(args, 'q')) {
 				cmdq_error(item, "no alternate screen");
@@ -192,14 +192,14 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 static enum cmd_retval
 cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client		*c = item->client;
+	struct client		*c = cmdq_get_client(item);
-	struct window_pane	*wp = item->target.wp;
+	struct window_pane	*wp = cmdq_get_target(item)->wp;
 	char			*buf, *cause;
 	const char		*bufname;
 	size_t			 len;
 
-	if (self->entry == &cmd_clear_history_entry) {
+	if (cmd_get_entry(self) == &cmd_clear_history_entry) {
 		window_pane_reset_mode_all(wp);
 		grid_clear_history(wp->base.grid);
 		return (CMD_RETURN_NORMAL);
@@ -214,15 +214,20 @@ cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_ERROR);
 
 	if (args_has(args, 'p')) {
-		if (!file_can_print(c)) {
+		if (len > 0 && buf[len - 1] == '\n')
-			cmdq_error(item, "can't write output to client");
+			len--;
-			free(buf);
+		if (c->flags & CLIENT_CONTROL)
-			return (CMD_RETURN_ERROR);
+			control_write(c, "%.*s", (int)len, buf);
-		}
+		else {
-		file_print_buffer(c, buf, len);
+			if (!file_can_print(c)) {
-		if (args_has(args, 'P') && len > 0)
+				cmdq_error(item, "can't write to client");
+				free(buf);
+				return (CMD_RETURN_ERROR);
+			}
+			file_print_buffer(c, buf, len);
 			file_print(c, "\n");
-		free(buf);
+			free(buf);
+		}
 	} else {
 		bufname = NULL;
 		if (args_has(args, 'b'))

cmd-choose-tree.c

@@ -30,9 +30,9 @@ const struct cmd_entry cmd_choose_tree_entry = {
 	.name = "choose-tree",
 	.alias = NULL,
 
-	.args = { "F:Gf:NO:rst:wZ", 0, 1 },
+	.args = { "F:f:GK:NO:rst:wZ", 0, 1 },
-	.usage = "[-GNrswZ] [-F format] [-f filter] [-O sort-order] "
+	.usage = "[-GNrswZ] [-F format] [-f filter] [-K key-format] "
-	         CMD_TARGET_PANE_USAGE " [template]",
+		 "[-O sort-order] " CMD_TARGET_PANE_USAGE " [template]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -44,9 +44,9 @@ const struct cmd_entry cmd_choose_client_entry = {
 	.name = "choose-client",
 	.alias = NULL,
 
-	.args = { "F:f:NO:rt:Z", 0, 1 },
+	.args = { "F:f:K:NO:rt:Z", 0, 1 },
-	.usage = "[-NrZ] [-F format] [-f filter] [-O sort-order] "
+	.usage = "[-NrZ] [-F format] [-f filter] [-K key-format] "
-	         CMD_TARGET_PANE_USAGE " [template]",
+		 "[-O sort-order] " CMD_TARGET_PANE_USAGE " [template]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -58,9 +58,22 @@ const struct cmd_entry cmd_choose_buffer_entry = {
 	.name = "choose-buffer",
 	.alias = NULL,
 
-	.args = { "F:f:NO:rt:Z", 0, 1 },
+	.args = { "F:f:K:NO:rt:Z", 0, 1 },
-	.usage = "[-NrZ] [-F format] [-f filter] [-O sort-order] "
+	.usage = "[-NrZ] [-F format] [-f filter] [-K key-format] "
-	         CMD_TARGET_PANE_USAGE " [template]",
+		 "[-O sort-order] " CMD_TARGET_PANE_USAGE " [template]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_choose_tree_exec
+};
+
+const struct cmd_entry cmd_customize_mode_entry = {
+	.name = "customize-mode",
+	.alias = NULL,
+
+	.args = { "F:f:Nt:Z", 0, 0 },
+	.usage = "[-NZ] [-F format] [-f filter] " CMD_TARGET_PANE_USAGE,
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -71,21 +84,24 @@ const struct cmd_entry cmd_choose_buffer_entry = {
 static enum cmd_retval
 cmd_choose_tree_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
-	struct window_pane		*wp = item->target.wp;
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct window_pane		*wp = target->wp;
 	const struct window_mode	*mode;
 
-	if (self->entry == &cmd_choose_buffer_entry) {
+	if (cmd_get_entry(self) == &cmd_choose_buffer_entry) {
 		if (paste_get_top(NULL) == NULL)
 			return (CMD_RETURN_NORMAL);
 		mode = &window_buffer_mode;
-	} else if (self->entry == &cmd_choose_client_entry) {
+	} else if (cmd_get_entry(self) == &cmd_choose_client_entry) {
 		if (server_client_how_many() == 0)
 			return (CMD_RETURN_NORMAL);
 		mode = &window_client_mode;
-	} else
+	} else if (cmd_get_entry(self) == &cmd_customize_mode_entry)
+		mode = &window_customize_mode;
+	else
 		mode = &window_tree_mode;
 
-	window_pane_set_mode(wp, mode, &item->target, args);
+	window_pane_set_mode(wp, NULL, mode, target, args);
 	return (CMD_RETURN_NORMAL);
 }

cmd-command-prompt.c

@@ -40,11 +40,11 @@ const struct cmd_entry cmd_command_prompt_entry = {
 	.name = "command-prompt",
 	.alias = NULL,
 
-	.args = { "1kiI:Np:t:", 0, 1 },
+	.args = { "1kiI:Np:Tt:W", 0, 1 },
-	.usage = "[-1kiN] [-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
+	.usage = "[-1kiNTW] [-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
 		 "[template]",
 
-	.flags = 0,
+	.flags = CMD_CLIENT_TFLAG,
 	.exec = cmd_command_prompt_exec
 };
 
@@ -64,17 +64,15 @@ struct cmd_command_prompt_cdata {
 static enum cmd_retval
 cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
+	struct client			*tc = cmdq_get_target_client(item);
+	struct cmd_find_state		*target = cmdq_get_target(item);
 	const char			*inputs, *prompts;
 	struct cmd_command_prompt_cdata	*cdata;
-	struct client			*c;
 	char				*prompt, *ptr, *input = NULL;
 	size_t				 n;
 
-	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+	if (tc->prompt_string != NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (c->prompt_string != NULL)
 		return (CMD_RETURN_NORMAL);
 
 	cdata = xcalloc(1, sizeof *cdata);
@@ -124,8 +122,13 @@ cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 		cdata->flags |= PROMPT_INCREMENTAL;
 	else if (args_has(args, 'k'))
 		cdata->flags |= PROMPT_KEY;
-	status_prompt_set(c, prompt, input, cmd_command_prompt_callback,
+	else if (args_has(args, 'W'))
-	    cmd_command_prompt_free, cdata, cdata->flags);
+		cdata->flags |= PROMPT_WINDOW;
+	else if (args_has(args, 'T'))
+		cdata->flags |= PROMPT_TARGET;
+	status_prompt_set(tc, target, prompt, input,
+	    cmd_command_prompt_callback, cmd_command_prompt_free, cdata,
+	    cdata->flags);
 	free(prompt);
 
 	return (CMD_RETURN_NORMAL);
@@ -136,10 +139,9 @@ cmd_command_prompt_callback(struct client *c, void *data, const char *s,
     int done)
 {
 	struct cmd_command_prompt_cdata	*cdata = data;
-	struct cmdq_item		*new_item;
+	char				*new_template, *prompt, *ptr, *error;
-	char				*new_template, *prompt, *ptr;
 	char				*input = NULL;
-	struct cmd_parse_result		*pr;
+	enum cmd_parse_status		 status;
 
 	if (s == NULL)
 		return (0);
@@ -166,21 +168,10 @@ cmd_command_prompt_callback(struct client *c, void *data, const char *s,
 		return (1);
 	}
 
-	pr = cmd_parse_from_string(new_template, NULL);
+	status = cmd_parse_and_append(new_template, NULL, c, NULL, &error);
-	switch (pr->status) {
+	if (status == CMD_PARSE_ERROR) {
-	case CMD_PARSE_EMPTY:
+		cmdq_append(c, cmdq_get_error(error));
-		new_item = NULL;
+		free(error);
-		break;
-	case CMD_PARSE_ERROR:
-		new_item = cmdq_get_error(pr->error);
-		free(pr->error);
-		cmdq_append(c, new_item);
-		break;
-	case CMD_PARSE_SUCCESS:
-		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
-		cmd_list_free(pr->cmdlist);
-		cmdq_append(c, new_item);
-		break;
 	}
 
 	if (!done)

cmd-confirm-before.c

@@ -42,7 +42,7 @@ const struct cmd_entry cmd_confirm_before_entry = {
 	.args = { "p:t:", 1, 1 },
 	.usage = "[-p prompt] " CMD_TARGET_CLIENT_USAGE " command",
 
-	.flags = 0,
+	.flags = CMD_CLIENT_TFLAG,
 	.exec = cmd_confirm_before_exec
 };
 
@@ -53,15 +53,13 @@ struct cmd_confirm_before_data {
 static enum cmd_retval
 cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
 	struct cmd_confirm_before_data	*cdata;
-	struct client			*c;
+	struct client			*tc = cmdq_get_target_client(item);
+	struct cmd_find_state		*target = cmdq_get_target(item);
 	char				*cmd, *copy, *new_prompt, *ptr;
 	const char			*prompt;
 
-	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
-
 	if ((prompt = args_get(args, 'p')) != NULL)
 		xasprintf(&new_prompt, "%s ", prompt);
 	else {
@@ -74,7 +72,7 @@ cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 	cdata = xmalloc(sizeof *cdata);
 	cdata->cmd = xstrdup(args->argv[0]);
 
-	status_prompt_set(c, new_prompt, NULL,
+	status_prompt_set(tc, target, new_prompt, NULL,
 	    cmd_confirm_before_callback, cmd_confirm_before_free, cdata,
 	    PROMPT_SINGLE);
 
@@ -87,8 +85,8 @@ cmd_confirm_before_callback(struct client *c, void *data, const char *s,
     __unused int done)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct cmdq_item		*new_item;
+	char				*error;
-	struct cmd_parse_result		*pr;
+	enum cmd_parse_status		 status;
 
 	if (c->flags & CLIENT_DEAD)
 		return (0);
@@ -98,21 +96,10 @@ cmd_confirm_before_callback(struct client *c, void *data, const char *s,
 	if (tolower((u_char)s[0]) != 'y' || s[1] != '\0')
 		return (0);
 
-	pr = cmd_parse_from_string(cdata->cmd, NULL);
+	status = cmd_parse_and_append(cdata->cmd, NULL, c, NULL, &error);
-	switch (pr->status) {
+	if (status == CMD_PARSE_ERROR) {
-	case CMD_PARSE_EMPTY:
+		cmdq_append(c, cmdq_get_error(error));
-		new_item = NULL;
+		free(error);
-		break;
-	case CMD_PARSE_ERROR:
-		new_item = cmdq_get_error(pr->error);
-		free(pr->error);
-		cmdq_append(c, new_item);
-		break;
-	case CMD_PARSE_SUCCESS:
-		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
-		cmd_list_free(pr->cmdlist);
-		cmdq_append(c, new_item);
-		break;
 	}
 
 	return (0);

cmd-copy-mode.c

@@ -30,9 +30,10 @@ const struct cmd_entry cmd_copy_mode_entry = {
 	.name = "copy-mode",
 	.alias = NULL,
 
-	.args = { "eHMt:uq", 0, 0 },
+	.args = { "eHMs:t:uq", 0, 0 },
-	.usage = "[-eHMuq] " CMD_TARGET_PANE_USAGE,
+	.usage = "[-eHMuq] [-s src-pane] " CMD_TARGET_PANE_USAGE,
 
+	.source =  { 's', CMD_FIND_PANE, 0 },
 	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = CMD_AFTERHOOK,
@@ -55,11 +56,13 @@ const struct cmd_entry cmd_clock_mode_entry = {
 static enum cmd_retval
 cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct cmdq_shared	*shared = item->shared;
+	struct key_event	*event = cmdq_get_event(item);
-	struct client		*c = item->client;
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*c = cmdq_get_client(item);
 	struct session		*s;
-	struct window_pane	*wp = item->target.wp;
+	struct window_pane	*wp = target->wp, *swp;
 
 	if (args_has(args, 'q')) {
 		window_pane_reset_mode_all(wp);
@@ -67,22 +70,26 @@ cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	if (args_has(args, 'M')) {
-		if ((wp = cmd_mouse_pane(&shared->mouse, &s, NULL)) == NULL)
+		if ((wp = cmd_mouse_pane(&event->m, &s, NULL)) == NULL)
 			return (CMD_RETURN_NORMAL);
 		if (c == NULL || c->session != s)
 			return (CMD_RETURN_NORMAL);
 	}
 
-	if (self->entry == &cmd_clock_mode_entry) {
+	if (cmd_get_entry(self) == &cmd_clock_mode_entry) {
-		window_pane_set_mode(wp, &window_clock_mode, NULL, NULL);
+		window_pane_set_mode(wp, NULL, &window_clock_mode, NULL, NULL);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (!window_pane_set_mode(wp, &window_copy_mode, NULL, args)) {
+	if (args_has(args, 's'))
+		swp = source->wp;
+	else
+		swp = wp;
+	if (!window_pane_set_mode(wp, swp, &window_copy_mode, NULL, args)) {
 		if (args_has(args, 'M'))
-			window_copy_start_drag(c, &shared->mouse);
+			window_copy_start_drag(c, &event->m);
 	}
-	if (args_has(self->args, 'u'))
+	if (args_has(args, 'u'))
 		window_copy_pageup(wp, 0);
 
 	return (CMD_RETURN_NORMAL);

cmd-detach-client.c

@@ -39,7 +39,7 @@ const struct cmd_entry cmd_detach_client_entry = {
 
 	.source = { 's', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
-	.flags = CMD_READONLY,
+	.flags = CMD_READONLY|CMD_CLIENT_TFLAG,
 	.exec = cmd_detach_client_exec
 };
 
@@ -50,24 +50,22 @@ const struct cmd_entry cmd_suspend_client_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_CLIENT_USAGE,
 
-	.flags = 0,
+	.flags = CMD_CLIENT_TFLAG,
 	.exec = cmd_detach_client_exec
 };
 
 static enum cmd_retval
 cmd_detach_client_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client	*c, *cloop;
+	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct session	*s;
+	struct client		*tc = cmdq_get_target_client(item), *loop;
-	enum msgtype	 msgtype;
+	struct session		*s;
-	const char	*cmd = args_get(args, 'E');
+	enum msgtype		 msgtype;
+	const char		*cmd = args_get(args, 'E');
 
-	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+	if (cmd_get_entry(self) == &cmd_suspend_client_entry) {
-		return (CMD_RETURN_ERROR);
+		server_client_suspend(tc);
-
-	if (self->entry == &cmd_suspend_client_entry) {
-		server_client_suspend(c);
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -77,35 +75,35 @@ cmd_detach_client_exec(struct cmd *self, struct cmdq_item *item)
 		msgtype = MSG_DETACH;
 
 	if (args_has(args, 's')) {
-		s = item->source.s;
+		s = source->s;
 		if (s == NULL)
 			return (CMD_RETURN_NORMAL);
-		TAILQ_FOREACH(cloop, &clients, entry) {
+		TAILQ_FOREACH(loop, &clients, entry) {
-			if (cloop->session == s) {
+			if (loop->session == s) {
 				if (cmd != NULL)
-					server_client_exec(cloop, cmd);
+					server_client_exec(loop, cmd);
 				else
-					server_client_detach(cloop, msgtype);
+					server_client_detach(loop, msgtype);
 			}
 		}
 		return (CMD_RETURN_STOP);
 	}
 
 	if (args_has(args, 'a')) {
-		TAILQ_FOREACH(cloop, &clients, entry) {
+		TAILQ_FOREACH(loop, &clients, entry) {
-			if (cloop->session != NULL && cloop != c) {
+			if (loop->session != NULL && loop != tc) {
 				if (cmd != NULL)
-					server_client_exec(cloop, cmd);
+					server_client_exec(loop, cmd);
 				else
-					server_client_detach(cloop, msgtype);
+					server_client_detach(loop, msgtype);
 			}
 		}
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (cmd != NULL)
-		server_client_exec(c, cmd);
+		server_client_exec(tc, cmd);
 	else
-		server_client_detach(c, msgtype);
+		server_client_detach(tc, msgtype);
 	return (CMD_RETURN_STOP);
 }

cmd-display-menu.c

@@ -29,55 +29,255 @@
 
 static enum cmd_retval	cmd_display_menu_exec(struct cmd *,
 			    struct cmdq_item *);
+static enum cmd_retval	cmd_display_popup_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_display_menu_entry = {
 	.name = "display-menu",
 	.alias = "menu",
 
-	.args = { "c:t:T:x:y:", 1, -1 },
+	.args = { "c:t:OT:x:y:", 1, -1 },
-	.usage = "[-c target-client] " CMD_TARGET_PANE_USAGE " [-T title] "
+	.usage = "[-O] [-c target-client] " CMD_TARGET_PANE_USAGE " [-T title] "
 		 "[-x position] [-y position] name key command ...",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = CMD_AFTERHOOK,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG,
 	.exec = cmd_display_menu_exec
 };
 
+const struct cmd_entry cmd_display_popup_entry = {
+	.name = "display-popup",
+	.alias = "popup",
+
+	.args = { "Cc:d:Eh:t:w:x:y:", 0, -1 },
+	.usage = "[-CE] [-c target-client] [-d start-directory] [-h height] "
+	         CMD_TARGET_PANE_USAGE " [-w width] "
+	         "[-x position] [-y position] [command]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG,
+	.exec = cmd_display_popup_exec
+};
+
+static int
+cmd_display_menu_get_position(struct client *tc, struct cmdq_item *item,
+    struct args *args, u_int *px, u_int *py, u_int w, u_int h)
+{
+	struct tty		*tty = &tc->tty;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct key_event	*event = cmdq_get_event(item);
+	struct session		*s = tc->session;
+	struct winlink		*wl = target->wl;
+	struct window_pane	*wp = target->wp;
+	struct style_ranges	*ranges = NULL;
+	struct style_range	*sr = NULL;
+	const char		*xp, *yp;
+	char			*p;
+	int			 top;
+	u_int			 line, ox, oy, sx, sy, lines, position;
+	long			 n;
+	struct format_tree	*ft;
+
+	/*
+	 * Work out the position from the -x and -y arguments. This is the
+	 * bottom-left position.
+	 */
+
+	/* If the popup is too big, stop now. */
+	if (w > tty->sx || h > tty->sy)
+		return (0);
+
+	/* Create format with mouse position if any. */
+	ft = format_create_from_target(item);
+	if (event->m.valid) {
+		format_add(ft, "popup_mouse_x", "%u", event->m.x);
+		format_add(ft, "popup_mouse_y", "%u", event->m.y);
+	}
+
+	/*
+	 * If there are any status lines, add this window position and the
+	 * status line position.
+	 */
+	top = status_at_line(tc);
+	if (top != -1) {
+		lines = status_line_size(tc);
+		if (top == 0)
+			top = lines;
+		else
+			top = 0;
+		position = options_get_number(s->options, "status-position");
+
+		for (line = 0; line < lines; line++) {
+			ranges = &tc->status.entries[line].ranges;
+			TAILQ_FOREACH(sr, ranges, entry) {
+				if (sr->type != STYLE_RANGE_WINDOW)
+					continue;
+				if (sr->argument == (u_int)wl->idx)
+					break;
+			}
+			if (sr != NULL)
+				break;
+		}
+		if (line == lines)
+			ranges = &tc->status.entries[0].ranges;
+
+		if (sr != NULL) {
+			format_add(ft, "popup_window_status_line_x", "%u",
+			    sr->start);
+			if (position == 0) {
+				format_add(ft, "popup_window_status_line_y",
+				    "%u", line + 1 + h);
+			} else {
+				format_add(ft, "popup_window_status_line_y",
+				    "%u", tty->sy - lines + line);
+			}
+		}
+
+		if (position == 0)
+			format_add(ft, "popup_status_line_y", "%u", lines + h);
+		else {
+			format_add(ft, "popup_status_line_y", "%u",
+			    tty->sy - lines);
+		}
+	} else
+		top = 0;
+
+	/* Popup width and height. */
+	format_add(ft, "popup_width", "%u", w);
+	format_add(ft, "popup_height", "%u", h);
+
+	/* Position so popup is in the centre. */
+	n = (long)(tty->sx - 1) / 2 - w / 2;
+	if (n < 0)
+		format_add(ft, "popup_centre_x", "%u", 0);
+	else
+		format_add(ft, "popup_centre_x", "%ld", n);
+	n = (tty->sy - 1) / 2 + h / 2;
+	if (n >= tty->sy)
+		format_add(ft, "popup_centre_y", "%u", tty->sy - h);
+	else
+		format_add(ft, "popup_centre_y", "%ld", n);
+
+	/* Position of popup relative to mouse. */
+	if (event->m.valid) {
+		n = (long)event->m.x - w / 2;
+		if (n < 0)
+			format_add(ft, "popup_mouse_centre_x", "%u", 0);
+		else
+			format_add(ft, "popup_mouse_centre_x", "%ld", n);
+		n = event->m.y - h / 2;
+		if (n + h >= tty->sy) {
+			format_add(ft, "popup_mouse_centre_y", "%u",
+			    tty->sy - h);
+		} else
+			format_add(ft, "popup_mouse_centre_y", "%ld", n);
+		n = (long)event->m.y + h;
+		if (n + h >= tty->sy)
+			format_add(ft, "popup_mouse_top", "%u", tty->sy - h);
+		else
+			format_add(ft, "popup_mouse_top", "%ld", n);
+		n = event->m.y - h;
+		if (n < 0)
+			format_add(ft, "popup_mouse_bottom", "%u", 0);
+		else
+			format_add(ft, "popup_mouse_bottom", "%ld", n);
+	}
+
+	/* Position in pane. */
+	tty_window_offset(&tc->tty, &ox, &oy, &sx, &sy);
+	n = top + wp->yoff - oy + h;
+	if (n >= tty->sy)
+		format_add(ft, "popup_pane_top", "%u", tty->sy - h);
+	else
+		format_add(ft, "popup_pane_top", "%ld", n);
+	format_add(ft, "popup_pane_bottom", "%u", top + wp->yoff + wp->sy - oy);
+	format_add(ft, "popup_pane_left", "%u", wp->xoff - ox);
+	n = (long)wp->xoff + wp->sx - ox - w;
+	if (n < 0)
+		format_add(ft, "popup_pane_right", "%u", 0);
+	else
+		format_add(ft, "popup_pane_right", "%ld", n);
+
+	/* Expand horizontal position. */
+	xp = args_get(args, 'x');
+	if (xp == NULL || strcmp(xp, "C") == 0)
+		xp = "#{popup_centre_x}";
+	else if (strcmp(xp, "R") == 0)
+		xp = "#{popup_right}";
+	else if (strcmp(xp, "P") == 0)
+		xp = "#{popup_pane_left}";
+	else if (strcmp(xp, "M") == 0)
+		xp = "#{popup_mouse_centre_x}";
+	else if (strcmp(xp, "W") == 0)
+		xp = "#{popup_window_status_line_x}";
+	p = format_expand(ft, xp);
+	n = strtol(p, NULL, 10);
+	if (n + w >= tty->sx)
+		n = tty->sx - w;
+	else if (n < 0)
+		n = 0;
+	*px = n;
+	log_debug("%s: -x: %s = %s = %u", __func__, xp, p, *px);
+	free(p);
+
+	/* Expand vertical position  */
+	yp = args_get(args, 'y');
+	if (yp == NULL || strcmp(yp, "C") == 0)
+		yp = "#{popup_centre_y}";
+	else if (strcmp(yp, "P") == 0)
+		yp = "#{popup_pane_bottom}";
+	else if (strcmp(yp, "M") == 0)
+		yp = "#{popup_mouse_top}";
+	else if (strcmp(yp, "S") == 0)
+		yp = "#{popup_status_line_y}";
+	else if (strcmp(yp, "W") == 0)
+		yp = "#{popup_window_status_line_y}";
+	p = format_expand(ft, yp);
+	n = strtol(p, NULL, 10);
+	if (n < h)
+		n = 0;
+	else
+		n -= h;
+	if (n + h >= tty->sy)
+		n = tty->sy - h;
+	else if (n < 0)
+		n = 0;
+	*py = n;
+	log_debug("%s: -y: %s = %s = %u", __func__, yp, p, *py);
+	free(p);
+
+	return (1);
+}
+
 static enum cmd_retval
 cmd_display_menu_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client		*c;
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = item->target.s;
+	struct key_event	*event = cmdq_get_event(item);
-	struct winlink		*wl = item->target.wl;
+	struct client		*tc = cmdq_get_target_client(item);
-	struct window_pane	*wp = item->target.wp;
-	struct cmd_find_state	*fs = &item->target;
 	struct menu		*menu = NULL;
-	struct style_range	*sr;
 	struct menu_item	 menu_item;
-	const char		*xp, *yp, *key;
+	const char		*key;
 	char			*title, *name;
-	int			 at, flags, i;
+	int			 flags = 0, i;
-	u_int			 px, py, ox, oy, sx, sy;
+	u_int			 px, py;
 
-	if ((c = cmd_find_client(item, args_get(args, 'c'), 0)) == NULL)
+	if (tc->overlay_draw != NULL)
-		return (CMD_RETURN_ERROR);
-	if (c->overlay_draw != NULL)
 		return (CMD_RETURN_NORMAL);
-	at = status_at_line(c);
 
 	if (args_has(args, 'T'))
-		title = format_single(NULL, args_get(args, 'T'), c, s, wl, wp);
+		title = format_single_from_target(item, args_get(args, 'T'));
 	else
 		title = xstrdup("");
-
 	menu = menu_create(title);
 
 	for (i = 0; i != args->argc; /* nothing */) {
 		name = args->argv[i++];
 		if (*name == '\0') {
-			menu_add_item(menu, NULL, item, c, fs);
+			menu_add_item(menu, NULL, item, tc, target);
 			continue;
 		}
 
@@ -93,7 +293,7 @@ cmd_display_menu_exec(struct cmd *self, struct cmdq_item *item)
 		menu_item.key = key_string_lookup_string(key);
 		menu_item.command = args->argv[i++];
 
-		menu_add_item(menu, &menu_item, item, c, fs);
+		menu_add_item(menu, &menu_item, item, tc, target);
 	}
 	free(title);
 	if (menu == NULL) {
@@ -104,75 +304,94 @@ cmd_display_menu_exec(struct cmd *self, struct cmdq_item *item)
 		menu_free(menu);
 		return (CMD_RETURN_NORMAL);
 	}
-
+	if (!cmd_display_menu_get_position(tc, item, args, &px, &py,
-	xp = args_get(args, 'x');
+	    menu->width + 4, menu->count + 2)) {
-	if (xp == NULL)
+		menu_free(menu);
-		px = 0;
+		return (CMD_RETURN_NORMAL);
-	else if (strcmp(xp, "R") == 0)
-		px = c->tty.sx - 1;
-	else if (strcmp(xp, "P") == 0) {
-		tty_window_offset(&c->tty, &ox, &oy, &sx, &sy);
-		if (wp->xoff >= ox)
-			px = wp->xoff - ox;
-		else
-			px = 0;
-	} else if (strcmp(xp, "M") == 0 && item->shared->mouse.valid) {
-		if (item->shared->mouse.x > (menu->width + 4) / 2)
-			px = item->shared->mouse.x - (menu->width + 4) / 2;
-		else
-			px = 0;
 	}
-	else if (strcmp(xp, "W") == 0) {
-		if (at == -1)
-			px = 0;
-		else {
-			TAILQ_FOREACH(sr, &c->status.entries[0].ranges, entry) {
-				if (sr->type != STYLE_RANGE_WINDOW)
-					continue;
-				if (sr->argument == (u_int)wl->idx)
-					break;
-			}
-			if (sr != NULL)
-				px = sr->start;
-			else
-				px = 0;
-		}
-	} else
-		px = strtoul(xp, NULL, 10);
-	if (px + menu->width + 4 >= c->tty.sx)
-		px = c->tty.sx - menu->width - 4;
 
-	yp = args_get(args, 'y');
+	if (args_has(args, 'O'))
-	if (yp == NULL)
+		flags |= MENU_STAYOPEN;
-		py = 0;
+	if (!event->m.valid)
-	else if (strcmp(yp, "P") == 0) {
-		tty_window_offset(&c->tty, &ox, &oy, &sx, &sy);
-		if (wp->yoff + wp->sy >= oy)
-			py = wp->yoff + wp->sy - oy;
-		else
-			py = 0;
-	} else if (strcmp(yp, "M") == 0 && item->shared->mouse.valid)
-		py = item->shared->mouse.y + menu->count + 2;
-	else if (strcmp(yp, "S") == 0) {
-		if (at == -1)
-			py = c->tty.sy;
-		else if (at == 0)
-			py = status_line_size(c) + menu->count + 2;
-		else
-			py = at;
-	} else
-		py = strtoul(yp, NULL, 10);
-	if (py < menu->count + 2)
-		py = 0;
-	else
-		py -= menu->count + 2;
-	if (py + menu->count + 2 >= c->tty.sy)
-		py = c->tty.sy - menu->count - 2;
-
-	flags = 0;
-	if (!item->shared->mouse.valid)
 		flags |= MENU_NOMOUSE;
-	if (menu_display(menu, flags, item, px, py, c, fs, NULL, NULL) != 0)
+	if (menu_display(menu, flags, item, px, py, tc, target, NULL,
+	    NULL) != 0)
+		return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
+}
+
+static enum cmd_retval
+cmd_display_popup_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct session		*s = target->s;
+	struct client		*tc = cmdq_get_target_client(item);
+	struct tty		*tty = &tc->tty;
+	const char		*value, *shell[] = { NULL, NULL };
+	const char		*shellcmd = NULL;
+	char			*cwd, *cause, **argv = args->argv;
+	int			 flags = 0, argc = args->argc;
+	u_int			 px, py, w, h;
+
+	if (args_has(args, 'C')) {
+		server_client_clear_overlay(tc);
+		return (CMD_RETURN_NORMAL);
+	}
+	if (tc->overlay_draw != NULL)
+		return (CMD_RETURN_NORMAL);
+
+	h = tty->sy / 2;
+	if (args_has(args, 'h')) {
+		h = args_percentage(args, 'h', 1, tty->sy, tty->sy, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "height %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	w = tty->sx / 2;
+	if (args_has(args, 'w')) {
+		w = args_percentage(args, 'w', 1, tty->sx, tty->sx, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "width %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	if (w > tty->sx - 1)
+		w = tty->sx - 1;
+	if (h > tty->sy - 1)
+		h = tty->sy - 1;
+	if (!cmd_display_menu_get_position(tc, item, args, &px, &py, w, h))
+		return (CMD_RETURN_NORMAL);
+
+	value = args_get(args, 'd');
+	if (value != NULL)
+		cwd = format_single_from_target(item, value);
+	else
+		cwd = xstrdup(server_client_get_cwd(tc, s));
+	if (argc == 0)
+		shellcmd = options_get_string(s->options, "default-command");
+	else if (argc == 1)
+		shellcmd = argv[0];
+	if (argc <= 1 && (shellcmd == NULL || *shellcmd == '\0')) {
+		shellcmd = NULL;
+		shell[0] = options_get_string(s->options, "default-shell");
+		if (!checkshell(shell[0]))
+			shell[0] = _PATH_BSHELL;
+		argc = 1;
+		argv = (char**)shell;
+	}
+
+	if (args_has(args, 'E') > 1)
+		flags |= POPUP_CLOSEEXITZERO;
+	else if (args_has(args, 'E'))
+		flags |= POPUP_CLOSEEXIT;
+	if (popup_display(flags, item, px, py, w, h, shellcmd, argc, argv, cwd,
+	    tc, s, NULL, NULL) != 0)
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }

cmd-display-message.c

@@ -39,13 +39,13 @@ const struct cmd_entry cmd_display_message_entry = {
 	.name = "display-message",
 	.alias = "display",
 
-	.args = { "ac:Ipt:F:v", 0, 1 },
+	.args = { "acd:INpt:F:v", 0, 1 },
-	.usage = "[-aIpv] [-c target-client] [-F format] "
+	.usage = "[-aINpv] [-c target-client] [-d delay] [-F format] "
 		 CMD_TARGET_PANE_USAGE " [message]",
 
-	.target = { 't', CMD_FIND_PANE, 0 },
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
-	.flags = CMD_AFTERHOOK,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG|CMD_CLIENT_CANFAIL,
 	.exec = cmd_display_message_exec
 };
 
@@ -60,17 +60,21 @@ cmd_display_message_each(const char *key, const char *value, void *arg)
 static enum cmd_retval
 cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client		*c, *target_c;
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = item->target.s;
+	struct client		*tc = cmdq_get_target_client(item), *c;
-	struct winlink		*wl = item->target.wl;
+	struct session		*s = target->s;
-	struct window_pane	*wp = item->target.wp;
+	struct winlink		*wl = target->wl;
+	struct window_pane	*wp = target->wp;
 	const char		*template;
 	char			*msg, *cause;
+	int			 delay = -1;
 	struct format_tree	*ft;
 	int			 flags;
 
 	if (args_has(args, 'I')) {
+		if (wp == NULL)
+			return (CMD_RETURN_NORMAL);
 		if (window_pane_start_input(wp, item, &cause) != 0) {
 			cmdq_error(item, "%s", cause);
 			free(cause);
@@ -84,6 +88,15 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_ERROR);
 	}
 
+	if (args_has(args, 'd')) {
+		delay = args_strtonum(args, 'd', 0, UINT_MAX, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "delay %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
 	template = args_get(args, 'F');
 	if (args->argc != 0)
 		template = args->argv[0];
@@ -96,17 +109,18 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 	 * formats too, assuming it matches the session. If it doesn't, use the
 	 * best client for the session.
 	 */
-	c = cmd_find_client(item, args_get(args, 'c'), 1);
+	if (tc != NULL && tc->session == s)
-	if (c != NULL && c->session == s)
+		c = tc;
-		target_c = c;
+	else if (s != NULL)
+		c = cmd_find_best_client(s);
 	else
-		target_c = cmd_find_best_client(s);
+		c = NULL;
-	if (args_has(self->args, 'v'))
+	if (args_has(args, 'v'))
 		flags = FORMAT_VERBOSE;
 	else
 		flags = 0;
-	ft = format_create(item->client, item, FORMAT_NONE, flags);
+	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, flags);
-	format_defaults(ft, target_c, s, wl, wp);
+	format_defaults(ft, c, s, wl, wp);
 
 	if (args_has(args, 'a')) {
 		format_each(ft, cmd_display_message_each, item);
@@ -114,10 +128,14 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	msg = format_expand_time(ft, template);
-	if (args_has(self->args, 'p'))
+	if (cmdq_get_client(item) == NULL)
+		cmdq_error(item, "%s", msg);
+	else if (args_has(args, 'p'))
 		cmdq_print(item, "%s", msg);
-	else if (c != NULL)
+	else if (tc != NULL) {
-		status_message_set(c, "%s", msg);
+		status_message_set(tc, delay, 0, args_has(args, 'N'), "%s",
+		    msg);
+	}
 	free(msg);
 
 	format_free(ft);

cmd-display-panes.c

@@ -34,10 +34,10 @@ const struct cmd_entry cmd_display_panes_entry = {
 	.name = "display-panes",
 	.alias = "displayp",
 
-	.args = { "bd:t:", 0, 1 },
+	.args = { "bd:Nt:", 0, 1 },
-	.usage = "[-b] [-d duration] " CMD_TARGET_CLIENT_USAGE " [template]",
+	.usage = "[-bN] [-d duration] " CMD_TARGET_CLIENT_USAGE " [template]",
 
-	.flags = CMD_AFTERHOOK,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
 	.exec = cmd_display_panes_exec
 };
 
@@ -55,11 +55,11 @@ cmd_display_panes_draw_pane(struct screen_redraw_ctx *ctx,
 	struct session		*s = c->session;
 	struct options		*oo = s->options;
 	struct window		*w = wp->window;
-	struct grid_cell	 gc;
+	struct grid_cell	 fgc, bgc;
-	u_int			 idx, px, py, i, j, xoff, yoff, sx, sy;
+	u_int			 pane, idx, px, py, i, j, xoff, yoff, sx, sy;
 	int			 colour, active_colour;
-	char			 buf[16], *ptr;
+	char			 buf[16], lbuf[16], rbuf[16], *ptr;
-	size_t			 len;
+	size_t			 len, llen, rlen;
 
 	if (wp->xoff + wp->sx <= ctx->ox ||
 	    wp->xoff >= ctx->ox + ctx->sx ||
@@ -109,31 +109,50 @@ cmd_display_panes_draw_pane(struct screen_redraw_ctx *ctx,
 	px = sx / 2;
 	py = sy / 2;
 
-	if (window_pane_index(wp, &idx) != 0)
+	if (window_pane_index(wp, &pane) != 0)
 		fatalx("index not found");
-	len = xsnprintf(buf, sizeof buf, "%u", idx);
+	len = xsnprintf(buf, sizeof buf, "%u", pane);
 
 	if (sx < len)
 		return;
 	colour = options_get_number(oo, "display-panes-colour");
 	active_colour = options_get_number(oo, "display-panes-active-colour");
 
+	memcpy(&fgc, &grid_default_cell, sizeof fgc);
+	memcpy(&bgc, &grid_default_cell, sizeof bgc);
+	if (w->active == wp) {
+		fgc.fg = active_colour;
+		bgc.bg = active_colour;
+	} else {
+		fgc.fg = colour;
+		bgc.bg = colour;
+	}
+
+	rlen = xsnprintf(rbuf, sizeof rbuf, "%ux%u", wp->sx, wp->sy);
+	if (pane > 9 && pane < 35)
+		llen = xsnprintf(lbuf, sizeof lbuf, "%c", 'a' + (pane - 10));
+	else
+		llen = 0;
+
 	if (sx < len * 6 || sy < 5) {
-		tty_cursor(tty, xoff + px - len / 2, yoff + py);
+		tty_attributes(tty, &fgc, &grid_default_cell, NULL);
-		goto draw_text;
+		if (sx >= len + llen + 1) {
+			len += llen + 1;
+			tty_cursor(tty, xoff + px - len / 2, yoff + py);
+			tty_putn(tty, buf, len,  len);
+			tty_putn(tty, " ", 1, 1);
+			tty_putn(tty, lbuf, llen, llen);
+		} else {
+			tty_cursor(tty, xoff + px - len / 2, yoff + py);
+			tty_putn(tty, buf, len, len);
+		}
+		goto out;
 	}
 
 	px -= len * 3;
 	py -= 2;
 
-	memcpy(&gc, &grid_default_cell, sizeof gc);
+	tty_attributes(tty, &bgc, &grid_default_cell, NULL);
-	if (w->active == wp)
-		gc.bg = active_colour;
-	else
-		gc.bg = colour;
-	gc.flags |= GRID_FLAG_NOPALETTE;
-
-	tty_attributes(tty, &gc, wp);
 	for (ptr = buf; *ptr != '\0'; ptr++) {
 		if (*ptr < '0' || *ptr > '9')
 			continue;
@@ -149,22 +168,20 @@ cmd_display_panes_draw_pane(struct screen_redraw_ctx *ctx,
 		px += 6;
 	}
 
-	len = xsnprintf(buf, sizeof buf, "%ux%u", wp->sx, wp->sy);
+	if (sy <= 6)
-	if (sx < len || sy < 6)
+		goto out;
-		return;
+	tty_attributes(tty, &fgc, &grid_default_cell, NULL);
-	tty_cursor(tty, xoff + sx - len, yoff);
+	if (rlen != 0 && sx >= rlen) {
-
+		tty_cursor(tty, xoff + sx - rlen, yoff);
-draw_text:
+		tty_putn(tty, rbuf, rlen, rlen);
-	memcpy(&gc, &grid_default_cell, sizeof gc);
+	}
-	if (w->active == wp)
+	if (llen != 0) {
-		gc.fg = active_colour;
+		tty_cursor(tty, xoff + sx / 2 + len * 3 - llen - 1,
-	else
+		    yoff + py + 5);
-		gc.fg = colour;
+		tty_putn(tty, lbuf, llen, llen);
-	gc.flags |= GRID_FLAG_NOPALETTE;
+	}
-
-	tty_attributes(tty, &gc, wp);
-	tty_puts(tty, buf);
 
+out:
 	tty_cursor(tty, 0, 0);
 }
 
@@ -197,16 +214,25 @@ static int
 cmd_display_panes_key(struct client *c, struct key_event *event)
 {
 	struct cmd_display_panes_data	*cdata = c->overlay_data;
-	struct cmdq_item		*new_item;
+	char				*cmd, *expanded, *error;
-	char				*cmd, *expanded;
 	struct window			*w = c->session->curw->window;
 	struct window_pane		*wp;
-	struct cmd_parse_result		*pr;
+	enum cmd_parse_status		 status;
+	u_int				 index;
+	key_code			 key;
 
-	if (event->key < '0' || event->key > '9')
+	if (event->key >= '0' && event->key <= '9')
+		index = event->key - '0';
+	else if ((event->key & KEYC_MASK_MODIFIERS) == 0) {
+		key = (event->key & KEYC_MASK_KEY);
+		if (key >= 'a' && key <= 'z')
+			index = 10 + (key - 'a');
+		else
+			return (-1);
+	} else
 		return (-1);
 
-	wp = window_pane_at_index(w, event->key - '0');
+	wp = window_pane_at_index(w, index);
 	if (wp == NULL)
 		return (1);
 	window_unzoom(w);
@@ -214,21 +240,10 @@ cmd_display_panes_key(struct client *c, struct key_event *event)
 	xasprintf(&expanded, "%%%u", wp->id);
 	cmd = cmd_template_replace(cdata->command, expanded, 1);
 
-	pr = cmd_parse_from_string(cmd, NULL);
+	status = cmd_parse_and_append(cmd, NULL, c, NULL, &error);
-	switch (pr->status) {
+	if (status == CMD_PARSE_ERROR) {
-	case CMD_PARSE_EMPTY:
+		cmdq_append(c, cmdq_get_error(error));
-		new_item = NULL;
+		free(error);
-		break;
-	case CMD_PARSE_ERROR:
-		new_item = cmdq_get_error(pr->error);
-		free(pr->error);
-		cmdq_append(c, new_item);
-		break;
-	case CMD_PARSE_SUCCESS:
-		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
-		cmd_list_free(pr->cmdlist);
-		cmdq_append(c, new_item);
-		break;
 	}
 
 	free(cmd);
@@ -239,18 +254,14 @@ cmd_display_panes_key(struct client *c, struct key_event *event)
 static enum cmd_retval
 cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
-	struct client			*c;
+	struct client			*tc = cmdq_get_target_client(item);
-	struct session			*s;
+	struct session			*s = tc->session;
 	u_int		 		 delay;
 	char				*cause;
 	struct cmd_display_panes_data	*cdata;
 
-	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+	if (tc->overlay_draw != NULL)
-		return (CMD_RETURN_ERROR);
-	s = c->session;
-
-	if (c->overlay_draw != NULL)
 		return (CMD_RETURN_NORMAL);
 
 	if (args_has(args, 'd')) {
@@ -273,8 +284,15 @@ cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
 	else
 		cdata->item = item;
 
-	server_client_set_overlay(c, delay, cmd_display_panes_draw,
+	if (args_has(args, 'N')) {
-	    cmd_display_panes_key, cmd_display_panes_free, cdata);
+		server_client_set_overlay(tc, delay, NULL, NULL,
+		    cmd_display_panes_draw, NULL, cmd_display_panes_free,
+		    cdata);
+	} else {
+		server_client_set_overlay(tc, delay, NULL, NULL,
+		    cmd_display_panes_draw, cmd_display_panes_key,
+		    cmd_display_panes_free, cdata);
+	}
 
 	if (args_has(args, 'b'))
 		return (CMD_RETURN_NORMAL);

cmd-find-window.c

@@ -32,8 +32,8 @@ const struct cmd_entry cmd_find_window_entry = {
 	.name = "find-window",
 	.alias = "findw",
 
-	.args = { "CNrt:TZ", 1, 1 },
+	.args = { "CiNrt:TZ", 1, 1 },
-	.usage = "[-CNrTZ] " CMD_TARGET_PANE_USAGE " match-string",
+	.usage = "[-CiNrTZ] " CMD_TARGET_PANE_USAGE " match-string",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -44,9 +44,10 @@ const struct cmd_entry cmd_find_window_entry = {
 static enum cmd_retval
 cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args, *new_args;
+	struct args		*args = cmd_get_args(self), *new_args;
-	struct window_pane	*wp = item->target.wp;
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	const char		*s = args->argv[0];
+	struct window_pane	*wp = target->wp;
+	const char		*s = args->argv[0], *suffix = "";
 	char			*filter, *argv = { NULL };
 	int			 C, N, T;
 
@@ -54,69 +55,48 @@ cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
 	N = args_has(args, 'N');
 	T = args_has(args, 'T');
 
+	if (args_has(args, 'r') && args_has(args, 'i'))
+		suffix = "/ri";
+	else if (args_has(args, 'r'))
+		suffix = "/r";
+	else if (args_has(args, 'i'))
+		suffix = "/i";
+
 	if (!C && !N && !T)
 		C = N = T = 1;
 
-	if (!args_has(args, 'r')) {
+	if (C && N && T) {
-		if (C && N && T) {
+		xasprintf(&filter,
-			xasprintf(&filter,
+		    "#{||:"
-			    "#{||:"
+		    "#{C%s:%s},#{||:#{m%s:*%s*,#{window_name}},"
-			    "#{C:%s},#{||:#{m:*%s*,#{window_name}},"
+		    "#{m%s:*%s*,#{pane_title}}}}",
-			    "#{m:*%s*,#{pane_title}}}}",
+		    suffix, s, suffix, s, suffix, s);
-			    s, s, s);
+	} else if (C && N) {
-		} else if (C && N) {
+		xasprintf(&filter,
-			xasprintf(&filter,
+		    "#{||:#{C%s:%s},#{m%s:*%s*,#{window_name}}}",
-			    "#{||:#{C:%s},#{m:*%s*,#{window_name}}}",
+		    suffix, s, suffix, s);
-			    s, s);
+	} else if (C && T) {
-		} else if (C && T) {
+		xasprintf(&filter,
-			xasprintf(&filter,
+		    "#{||:#{C%s:%s},#{m%s:*%s*,#{pane_title}}}",
-			    "#{||:#{C:%s},#{m:*%s*,#{pane_title}}}",
+		    suffix, s, suffix, s);
-			    s, s);
+	} else if (N && T) {
-		} else if (N && T) {
+		xasprintf(&filter,
-			xasprintf(&filter,
+		    "#{||:#{m%s:*%s*,#{window_name}},"
-			    "#{||:#{m:*%s*,#{window_name}},"
+		    "#{m%s:*%s*,#{pane_title}}}",
-			    "#{m:*%s*,#{pane_title}}}",
+		    suffix, s, suffix, s);
-			    s, s);
+	} else if (C)
-		} else if (C)
+		xasprintf(&filter, "#{C%s:%s}", suffix, s);
-			xasprintf(&filter, "#{C:%s}", s);
+	else if (N)
-		else if (N)
+		xasprintf(&filter, "#{m%s:*%s*,#{window_name}}", suffix, s);
-			xasprintf(&filter, "#{m:*%s*,#{window_name}}", s);
+	else
-		else
+		xasprintf(&filter, "#{m%s:*%s*,#{pane_title}}", suffix, s);
-			xasprintf(&filter, "#{m:*%s*,#{pane_title}}", s);
-	} else {
-		if (C && N && T) {
-			xasprintf(&filter,
-			    "#{||:"
-			    "#{C/r:%s},#{||:#{m/r:%s,#{window_name}},"
-			    "#{m/r:%s,#{pane_title}}}}",
-			    s, s, s);
-		} else if (C && N) {
-			xasprintf(&filter,
-			    "#{||:#{C/r:%s},#{m/r:%s,#{window_name}}}",
-			    s, s);
-		} else if (C && T) {
-			xasprintf(&filter,
-			    "#{||:#{C/r:%s},#{m/r:%s,#{pane_title}}}",
-			    s, s);
-		} else if (N && T) {
-			xasprintf(&filter,
-			    "#{||:#{m/r:%s,#{window_name}},"
-			    "#{m/r:%s,#{pane_title}}}",
-			    s, s);
-		} else if (C)
-			xasprintf(&filter, "#{C/r:%s}", s);
-		else if (N)
-			xasprintf(&filter, "#{m/r:%s,#{window_name}}", s);
-		else
-			xasprintf(&filter, "#{m/r:%s,#{pane_title}}", s);
-	}
 
 	new_args = args_parse("", 1, &argv);
 	if (args_has(args, 'Z'))
 		args_set(new_args, 'Z', NULL);
 	args_set(new_args, 'f', filter);
 
-	window_pane_set_mode(wp, &window_tree_mode, &item->target, new_args);
+	window_pane_set_mode(wp, NULL, &window_tree_mode, target, new_args);
 
 	args_free(new_args);
 	free(filter);

cmd-find.c

@@ -587,22 +587,22 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)
 			return (-1);
 		return (0);
 	} else if (strcmp(pane, "{up-of}") == 0) {
-		fs->wp = window_pane_find_up(fs->w->active);
+		fs->wp = window_pane_find_up(fs->current->wp);
 		if (fs->wp == NULL)
 			return (-1);
 		return (0);
 	} else if (strcmp(pane, "{down-of}") == 0) {
-		fs->wp = window_pane_find_down(fs->w->active);
+		fs->wp = window_pane_find_down(fs->current->wp);
 		if (fs->wp == NULL)
 			return (-1);
 		return (0);
 	} else if (strcmp(pane, "{left-of}") == 0) {
-		fs->wp = window_pane_find_left(fs->w->active);
+		fs->wp = window_pane_find_left(fs->current->wp);
 		if (fs->wp == NULL)
 			return (-1);
 		return (0);
 	} else if (strcmp(pane, "{right-of}") == 0) {
-		fs->wp = window_pane_find_right(fs->w->active);
+		fs->wp = window_pane_find_right(fs->current->wp);
 		if (fs->wp == NULL)
 			return (-1);
 		return (0);
@@ -614,7 +614,7 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)
 			n = strtonum(pane + 1, 1, INT_MAX, NULL);
 		else
 			n = 1;
-		wp = fs->w->active;
+		wp = fs->current->wp;
 		if (pane[0] == '+')
 			fs->wp = window_pane_next_by_number(fs->w, wp, n);
 		else
@@ -866,7 +866,18 @@ cmd_find_from_client(struct cmd_find_state *fs, struct client *c, int flags)
 
 	/* If this is an attached client, all done. */
 	if (c->session != NULL) {
-		cmd_find_from_session(fs, c->session, flags);
+		cmd_find_clear_state(fs, flags);
+
+		fs->wp = server_client_get_pane(c);
+		if (fs->wp == NULL) {
+			cmd_find_from_session(fs, c->session, flags);
+			return (0);
+		}
+		fs->s = c->session;
+		fs->wl = fs->s->curw;
+		fs->w = fs->wl->window;
+
+		cmd_find_log_state(__func__, fs);
 		return (0);
 	}
 	cmd_find_clear_state(fs, flags);
@@ -960,10 +971,11 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 	if (server_check_marked() && (flags & CMD_FIND_DEFAULT_MARKED)) {
 		fs->current = &marked_pane;
 		log_debug("%s: current is marked pane", __func__);
-	} else if (cmd_find_valid_state(&item->shared->current)) {
+	} else if (cmd_find_valid_state(cmdq_get_current(item))) {
-		fs->current = &item->shared->current;
+		fs->current = cmdq_get_current(item);
 		log_debug("%s: current is from queue", __func__);
-	} else if (cmd_find_from_client(&current, item->client, flags) == 0) {
+	} else if (cmd_find_from_client(&current, cmdq_get_client(item),
+	    flags) == 0) {
 		fs->current = &current;
 		log_debug("%s: current is from client", __func__);
 	} else {
@@ -980,7 +992,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 
 	/* Mouse target is a plain = or {mouse}. */
 	if (strcmp(target, "=") == 0 || strcmp(target, "{mouse}") == 0) {
-		m = &item->shared->mouse;
+		m = &cmdq_get_event(item)->m;
 		switch (type) {
 		case CMD_FIND_PANE:
 			fs->wp = cmd_mouse_pane(m, &fs->s, &fs->wl);
@@ -1230,29 +1242,31 @@ no_pane:
 static struct client *
 cmd_find_current_client(struct cmdq_item *item, int quiet)
 {
-	struct client		*c;
+	struct client		*c = NULL, *found;
 	struct session		*s;
 	struct window_pane	*wp;
 	struct cmd_find_state	 fs;
 
-	if (item->client != NULL && item->client->session != NULL)
+	if (item != NULL)
-		return (item->client);
+		c = cmdq_get_client(item);
+	if (c != NULL && c->session != NULL)
+		return (c);
 
-	c = NULL;
+	found = NULL;
-	if ((wp = cmd_find_inside_pane(item->client)) != NULL) {
+	if (c != NULL && (wp = cmd_find_inside_pane(c)) != NULL) {
 		cmd_find_clear_state(&fs, CMD_FIND_QUIET);
 		fs.w = wp->window;
 		if (cmd_find_best_session_with_window(&fs) == 0)
-			c = cmd_find_best_client(fs.s);
+			found = cmd_find_best_client(fs.s);
 	} else {
 		s = cmd_find_best_session(NULL, 0, CMD_FIND_QUIET);
 		if (s != NULL)
-			c = cmd_find_best_client(s);
+			found = cmd_find_best_client(s);
 	}
-	if (c == NULL && !quiet)
+	if (found == NULL && item != NULL && !quiet)
 		cmdq_error(item, "no current client");
-	log_debug("%s: no target, return %p", __func__, c);
+	log_debug("%s: no target, return %p", __func__, found);
-	return (c);
+	return (found);
 }
 
 /* Find the target client or report an error and return NULL. */

cmd-if-shell.c

@@ -56,26 +56,23 @@ struct cmd_if_shell_data {
 
 	struct client		*client;
 	struct cmdq_item	*item;
-	struct mouse_event	 mouse;
 };
 
 static enum cmd_retval
 cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
-	struct mouse_event		*m = &item->shared->mouse;
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct cmdq_state		*state = cmdq_get_state(item);
 	struct cmd_if_shell_data	*cdata;
-	char				*shellcmd, *cmd;
+	char				*shellcmd, *cmd, *error;
-	struct cmdq_item		*new_item;
+	const char			*file;
-	struct cmd_find_state		*fs = &item->target;
+	struct client			*tc = cmdq_get_target_client(item);
-	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = target->s;
-	struct session			*s = fs->s;
-	struct winlink			*wl = fs->wl;
-	struct window_pane		*wp = fs->wp;
 	struct cmd_parse_input		 pi;
-	struct cmd_parse_result		*pr;
+	enum cmd_parse_status		 status;
 
-	shellcmd = format_single(item, args->argv[0], c, s, wl, wp);
+	shellcmd = format_single_from_target(item, args->argv[0]);
 	if (args_has(args, 'F')) {
 		if (*shellcmd != '0' && *shellcmd != '\0')
 			cmd = args->argv[1];
@@ -88,26 +85,16 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 			return (CMD_RETURN_NORMAL);
 
 		memset(&pi, 0, sizeof pi);
-		if (self->file != NULL)
+		cmd_get_source(self, &pi.file, &pi.line);
-			pi.file = self->file;
-		pi.line = self->line;
 		pi.item = item;
-		pi.c = c;
+		pi.c = tc;
-		cmd_find_copy_state(&pi.fs, fs);
+		cmd_find_copy_state(&pi.fs, target);
 
-		pr = cmd_parse_from_string(cmd, &pi);
+		status = cmd_parse_and_insert(cmd, &pi, item, state, &error);
-		switch (pr->status) {
+		if (status == CMD_PARSE_ERROR) {
-		case CMD_PARSE_EMPTY:
+			cmdq_error(item, "%s", error);
-			break;
+			free(error);
-		case CMD_PARSE_ERROR:
-			cmdq_error(item, "%s", pr->error);
-			free(pr->error);
 			return (CMD_RETURN_ERROR);
-		case CMD_PARSE_SUCCESS:
-			new_item = cmdq_get_command(pr->cmdlist, fs, m, 0);
-			cmdq_insert_after(item, new_item);
-			cmd_list_free(pr->cmdlist);
-			break;
 		}
 		return (CMD_RETURN_NORMAL);
 	}
@@ -119,12 +106,11 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 		cdata->cmd_else = xstrdup(args->argv[2]);
 	else
 		cdata->cmd_else = NULL;
-	memcpy(&cdata->mouse, m, sizeof cdata->mouse);
 
 	if (!args_has(args, 'b'))
-		cdata->client = item->client;
+		cdata->client = cmdq_get_client(item);
 	else
-		cdata->client = c;
+		cdata->client = tc;
 	if (cdata->client != NULL)
 		cdata->client->references++;
 
@@ -134,17 +120,18 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 		cdata->item = NULL;
 
 	memset(&cdata->input, 0, sizeof cdata->input);
-	if (self->file != NULL)
+	cmd_get_source(self, &file, &cdata->input.line);
-		cdata->input.file = xstrdup(self->file);
+	if (file != NULL)
-	cdata->input.line = self->line;
+		cdata->input.file = xstrdup(file);
-	cdata->input.item = cdata->item;
+	cdata->input.c = tc;
-	cdata->input.c = c;
 	if (cdata->input.c != NULL)
 		cdata->input.c->references++;
-	cmd_find_copy_state(&cdata->input.fs, fs);
+	cmd_find_copy_state(&cdata->input.fs, target);
 
-	if (job_run(shellcmd, s, server_client_get_cwd(item->client, s), NULL,
+	if (job_run(shellcmd, 0, NULL, s,
-	    cmd_if_shell_callback, cmd_if_shell_free, cdata, 0) == NULL) {
+	    server_client_get_cwd(cmdq_get_client(item), s), NULL,
+	    cmd_if_shell_callback, cmd_if_shell_free, cdata, 0, -1,
+	    -1) == NULL) {
 		cmdq_error(item, "failed to run command: %s", shellcmd);
 		free(shellcmd);
 		free(cdata);
@@ -162,8 +149,8 @@ cmd_if_shell_callback(struct job *job)
 {
 	struct cmd_if_shell_data	*cdata = job_get_data(job);
 	struct client			*c = cdata->client;
-	struct mouse_event		*m = &cdata->mouse;
 	struct cmdq_item		*new_item = NULL;
+	struct cmdq_state		*new_state = NULL;
 	char				*cmd;
 	int				 status;
 	struct cmd_parse_result		*pr;
@@ -186,7 +173,13 @@ cmd_if_shell_callback(struct job *job)
 		free(pr->error);
 		break;
 	case CMD_PARSE_SUCCESS:
-		new_item = cmdq_get_command(pr->cmdlist, NULL, m, 0);
+		if (cdata->item == NULL)
+			new_state = cmdq_new_state(NULL, NULL, 0);
+		else
+			new_state = cmdq_get_state(cdata->item);
+		new_item = cmdq_get_command(pr->cmdlist, new_state);
+		if (cdata->item == NULL)
+			cmdq_free_state(new_state);
 		cmd_list_free(pr->cmdlist);
 		break;
 	}

cmd-join-pane.c

@@ -49,8 +49,8 @@ const struct cmd_entry cmd_move_pane_entry = {
 	.name = "move-pane",
 	.alias = "movep",
 
-	.args = { "bdhvp:l:s:t:", 0, 0 },
+	.args = { "bdfhvp:l:s:t:", 0, 0 },
-	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
+	.usage = "[-bdfhv] [-l size] " CMD_SRCDST_PANE_USAGE,
 
 	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -62,42 +62,33 @@ const struct cmd_entry cmd_move_pane_entry = {
 static enum cmd_retval
 cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = &item->shared->current;
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct cmd_find_state	*source = cmdq_get_source(item);
 	struct session		*dst_s;
 	struct winlink		*src_wl, *dst_wl;
 	struct window		*src_w, *dst_w;
 	struct window_pane	*src_wp, *dst_wp;
-	char			*cause, *copy;
+	char			*cause = NULL;
-	const char		*errstr, *p;
+	int			 size, percentage, dst_idx;
-	size_t			 plen;
-	int			 size, percentage, dst_idx, not_same_window;
 	int			 flags;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
 
-	if (self->entry == &cmd_join_pane_entry)
+	dst_s = target->s;
-		not_same_window = 1;
+	dst_wl = target->wl;
-	else
+	dst_wp = target->wp;
-		not_same_window = 0;
-
-	dst_s = item->target.s;
-	dst_wl = item->target.wl;
-	dst_wp = item->target.wp;
 	dst_w = dst_wl->window;
 	dst_idx = dst_wl->idx;
 	server_unzoom_window(dst_w);
 
-	src_wl = item->source.wl;
+	src_wl = source->wl;
-	src_wp = item->source.wp;
+	src_wp = source->wp;
 	src_w = src_wl->window;
 	server_unzoom_window(src_w);
 
-	if (not_same_window && src_w == dst_w) {
+	if (src_wp == dst_wp) {
-		cmdq_error(item, "can't join a pane to its own window");
-		return (CMD_RETURN_ERROR);
-	}
-	if (!not_same_window && src_wp == dst_wp) {
 		cmdq_error(item, "source and target panes must be different");
 		return (CMD_RETURN_ERROR);
 	}
@@ -107,40 +98,27 @@ cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 		type = LAYOUT_LEFTRIGHT;
 
 	size = -1;
-	if ((p = args_get(args, 'l')) != NULL) {
+	if (args_has(args, 'l')) {
-		plen = strlen(p);
+		if (type == LAYOUT_TOPBOTTOM) {
-		if (p[plen - 1] == '%') {
+			size = args_percentage(args, 'l', 0, INT_MAX,
-			copy = xstrdup(p);
+			    dst_wp->sy, &cause);
-			copy[plen - 1] = '\0';
+		} else {
-			percentage = strtonum(copy, 0, INT_MAX, &errstr);
+			size = args_percentage(args, 'l', 0, INT_MAX,
-			free(copy);
+			    dst_wp->sx, &cause);
-			if (errstr != NULL) {
+		}
-				cmdq_error(item, "percentage %s", errstr);
+	} else if (args_has(args, 'p')) {
-				return (CMD_RETURN_ERROR);
+		percentage = args_strtonum(args, 'p', 0, 100, &cause);
-			}
+		if (cause == NULL) {
 			if (type == LAYOUT_TOPBOTTOM)
 				size = (dst_wp->sy * percentage) / 100;
 			else
 				size = (dst_wp->sx * percentage) / 100;
-		} else {
-			size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
-			if (cause != NULL) {
-				cmdq_error(item, "size %s", cause);
-				free(cause);
-				return (CMD_RETURN_ERROR);
-			}
 		}
-	} else if (args_has(args, 'p')) {
+	}
-		percentage = args_strtonum(args, 'p', 0, 100, &cause);
+	if (cause != NULL) {
-		if (cause != NULL) {
+		cmdq_error(item, "size %s", cause);
-			cmdq_error(item, "percentage %s", cause);
+		free(cause);
-			free(cause);
+		return (CMD_RETURN_ERROR);
-			return (CMD_RETURN_ERROR);
-		}
-		if (type == LAYOUT_TOPBOTTOM)
-			size = (dst_wp->sy * percentage) / 100;
-		else
-			size = (dst_wp->sx * percentage) / 100;
 	}
 
 	flags = 0;
@@ -157,14 +135,18 @@ cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 
 	layout_close_pane(src_wp);
 
+	server_client_remove_pane(src_wp);
 	window_lost_pane(src_w, src_wp);
 	TAILQ_REMOVE(&src_w->panes, src_wp, entry);
 
 	src_wp->window = dst_w;
 	options_set_parent(src_wp->options, dst_w->options);
 	src_wp->flags |= PANE_STYLECHANGED;
-	TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
+	if (flags & SPAWN_BEFORE)
-	layout_assign_pane(lc, src_wp);
+		TAILQ_INSERT_BEFORE(dst_wp, src_wp, entry);
+	else
+		TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
+	layout_assign_pane(lc, src_wp, 0);
 
 	recalculate_sizes();
 
@@ -180,7 +162,7 @@ cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 		server_status_session(dst_s);
 
 	if (window_count_panes(src_w) == 0)
-		server_kill_window(src_w);
+		server_kill_window(src_w, 1);
 	else
 		notify_window("window-layout-changed", src_w);
 	notify_window("window-layout-changed", dst_w);

cmd-kill-pane.c

@@ -44,14 +44,17 @@ const struct cmd_entry cmd_kill_pane_entry = {
 static enum cmd_retval
 cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink		*wl = item->target.wl;
+	struct args		*args = cmd_get_args(self);
-	struct window_pane	*loopwp, *tmpwp, *wp = item->target.wp;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	struct window_pane	*loopwp, *tmpwp, *wp = target->wp;
 
-	if (args_has(self->args, 'a')) {
+	if (args_has(args, 'a')) {
 		server_unzoom_window(wl->window);
 		TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
 			if (loopwp == wp)
 				continue;
+			server_client_remove_pane(loopwp);
 			layout_close_pane(loopwp);
 			window_remove_pane(wl->window, loopwp);
 		}

cmd-kill-server.c

@@ -54,7 +54,7 @@ const struct cmd_entry cmd_start_server_entry = {
 static enum cmd_retval
 cmd_kill_server_exec(struct cmd *self, __unused struct cmdq_item *item)
 {
-	if (self->entry == &cmd_kill_server_entry)
+	if (cmd_get_entry(self) == &cmd_kill_server_entry)
 		kill(getpid(), SIGTERM);
 
 	return (CMD_RETURN_NORMAL);

cmd-kill-session.c

@@ -45,11 +45,10 @@ const struct cmd_entry cmd_kill_session_entry = {
 static enum cmd_retval
 cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct session	*s, *sloop, *stmp;
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct winlink	*wl;
+	struct session		*s = target->s, *sloop, *stmp;
-
+	struct winlink		*wl;
-	s = item->target.s;
 
 	if (args_has(args, 'C')) {
 		RB_FOREACH(wl, winlinks, &s->windows) {

cmd-kill-window.c

@@ -55,27 +55,56 @@ const struct cmd_entry cmd_unlink_window_entry = {
 static enum cmd_retval
 cmd_kill_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct winlink		*wl = item->target.wl, *wl2, *wl3;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl, *loop;
 	struct window		*w = wl->window;
-	struct session		*s = item->target.s;
+	struct session		*s = target->s;
+	u_int			 found;
 
-	if (self->entry == &cmd_unlink_window_entry) {
+	if (cmd_get_entry(self) == &cmd_unlink_window_entry) {
-		if (!args_has(self->args, 'k') && !session_is_linked(s, w)) {
+		if (!args_has(args, 'k') && !session_is_linked(s, w)) {
 			cmdq_error(item, "window only linked to one session");
 			return (CMD_RETURN_ERROR);
 		}
 		server_unlink_window(s, wl);
-	} else {
+		recalculate_sizes();
-		if (args_has(args, 'a')) {
+		return (CMD_RETURN_NORMAL);
-			RB_FOREACH_SAFE(wl2, winlinks, &s->windows, wl3) {
-				if (wl != wl2)
-					server_kill_window(wl2->window);
-			}
-		} else
-			server_kill_window(wl->window);
 	}
 
-	recalculate_sizes();
+	if (args_has(args, 'a')) {
+		if (RB_PREV(winlinks, &s->windows, wl) == NULL &&
+		    RB_NEXT(winlinks, &s->windows, wl) == NULL)
+			return (CMD_RETURN_NORMAL);
+
+		/* Kill all windows except the current one. */
+		do {
+			found = 0;
+			RB_FOREACH(loop, winlinks, &s->windows) {
+				if (loop->window != wl->window) {
+					server_kill_window(loop->window, 0);
+					found++;
+					break;
+				}
+			}
+		} while (found != 0);
+
+		/*
+		 * If the current window appears in the session more than once,
+		 * kill it as well.
+		 */
+		found = 0;
+		RB_FOREACH(loop, winlinks, &s->windows) {
+			if (loop->window == wl->window)
+				found++;
+		}
+		if (found > 1)
+			server_kill_window(wl->window, 0);
+
+		server_renumber_all();
+		return (CMD_RETURN_NORMAL);
+	}
+
+	server_kill_window(wl->window, 1);
 	return (CMD_RETURN_NORMAL);
 }

cmd-list-buffers.c

@@ -36,8 +36,8 @@ const struct cmd_entry cmd_list_buffers_entry = {
 	.name = "list-buffers",
 	.alias = "lsb",
 
-	.args = { "F:", 0, 0 },
+	.args = { "F:f:", 0, 0 },
-	.usage = "[-F format]",
+	.usage = "[-F format] [-f filter]",
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_buffers_exec
@@ -46,23 +46,33 @@ const struct cmd_entry cmd_list_buffers_entry = {
 static enum cmd_retval
 cmd_list_buffers_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
 	struct paste_buffer	*pb;
 	struct format_tree	*ft;
-	char			*line;
+	const char		*template, *filter;
-	const char		*template;
+	char			*line, *expanded;
+	int			 flag;
 
 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_BUFFERS_TEMPLATE;
+	filter = args_get(args, 'f');
 
 	pb = NULL;
 	while ((pb = paste_walk(pb)) != NULL) {
-		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_defaults_paste_buffer(ft, pb);
 
-		line = format_expand(ft, template);
+		if (filter != NULL) {
-		cmdq_print(item, "%s", line);
+			expanded = format_expand(ft, filter);
-		free(line);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 	}

cmd-list-clients.c

@@ -28,10 +28,10 @@
  * List all clients.
  */
 
-#define LIST_CLIENTS_TEMPLATE					\
+#define LIST_CLIENTS_TEMPLATE						\
-	"#{client_name}: #{session_name} "			\
+	"#{client_name}: #{session_name} "				\
-	"[#{client_width}x#{client_height} #{client_termname}]"	\
+	"[#{client_width}x#{client_height} #{client_termname}] "	\
-	"#{?client_utf8, (utf8),} #{?client_readonly, (ro),}"
+	"#{?client_flags,(,}#{client_flags}#{?client_flags,),}"
 
 static enum cmd_retval	cmd_list_clients_exec(struct cmd *, struct cmdq_item *);
 
@@ -51,7 +51,8 @@ const struct cmd_entry cmd_list_clients_entry = {
 static enum cmd_retval
 cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args 		*args = self->args;
+	struct args 		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct client		*c;
 	struct session		*s;
 	struct format_tree	*ft;
@@ -60,7 +61,7 @@ cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
 	char			*line;
 
 	if (args_has(args, 't'))
-		s = item->target.s;
+		s = target->s;
 	else
 		s = NULL;
 
@@ -72,7 +73,7 @@ cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
 		if (c->session == NULL || (s != NULL && s != c->session))
 			continue;
 
-		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", idx);
 		format_defaults(ft, c, NULL, NULL, NULL);
 

cmd-list-keys.c

@@ -68,11 +68,12 @@ cmd_list_keys_get_width(const char *tablename, key_code only)
 	while (bd != NULL) {
 		if ((only != KEYC_UNKNOWN && bd->key != only) ||
 		    KEYC_IS_MOUSE(bd->key) ||
-		    bd->note == NULL) {
+		    bd->note == NULL ||
+		    *bd->note == '\0') {
 			bd = key_bindings_next(table, bd);
 			continue;
 		}
-		width = utf8_cstrwidth(key_string_lookup_key(bd->key));
+		width = utf8_cstrwidth(key_string_lookup_key(bd->key, 0));
 		if (width > keywidth)
 			keywidth = width;
 
@@ -85,7 +86,7 @@ static int
 cmd_list_keys_print_notes(struct cmdq_item *item, struct args *args,
     const char *tablename, u_int keywidth, key_code only, const char *prefix)
 {
-	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct client		*tc = cmdq_get_target_client(item);
 	struct key_table	*table;
 	struct key_binding	*bd;
 	const char		*key;
@@ -99,21 +100,23 @@ cmd_list_keys_print_notes(struct cmdq_item *item, struct args *args,
 	while (bd != NULL) {
 		if ((only != KEYC_UNKNOWN && bd->key != only) ||
 		    KEYC_IS_MOUSE(bd->key) ||
-		    (bd->note == NULL && !args_has(args, 'a'))) {
+		    ((bd->note == NULL || *bd->note == '\0') &&
+		    !args_has(args, 'a'))) {
 			bd = key_bindings_next(table, bd);
 			continue;
 		}
 		found = 1;
-		key = key_string_lookup_key(bd->key);
+		key = key_string_lookup_key(bd->key, 0);
 
-		if (bd->note == NULL)
+		if (bd->note == NULL || *bd->note == '\0')
 			note = cmd_list_print(bd->cmdlist, 1);
 		else
 			note = xstrdup(bd->note);
 		tmp = utf8_padcstr(key, keywidth + 1);
-		if (args_has(args, '1') && c != NULL)
+		if (args_has(args, '1') && tc != NULL) {
-			status_message_set(c, "%s%s%s", prefix, tmp, note);
+			status_message_set(tc, -1, 1, 0, "%s%s%s", prefix, tmp,
-		else
+			    note);
+		} else
 			cmdq_print(item, "%s%s%s", prefix, tmp, note);
 		free(tmp);
 		free(note);
@@ -133,7 +136,7 @@ cmd_list_keys_get_prefix(struct args *args, key_code *prefix)
 	*prefix = options_get_number(global_s_options, "prefix");
 	if (!args_has(args, 'P')) {
 		if (*prefix != KEYC_NONE)
-			xasprintf(&s, "%s ", key_string_lookup_key(*prefix));
+			xasprintf(&s, "%s ", key_string_lookup_key(*prefix, 0));
 		else
 			s = xstrdup("");
 	} else
@@ -144,7 +147,7 @@ cmd_list_keys_get_prefix(struct args *args, key_code *prefix)
 static enum cmd_retval
 cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
 	struct key_table	*table;
 	struct key_binding	*bd;
 	const char		*tablename, *r;
@@ -153,7 +156,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 	int			 repeat, width, tablewidth, keywidth, found = 0;
 	size_t			 tmpsize, tmpused, cplen;
 
-	if (self->entry == &cmd_list_commands_entry)
+	if (cmd_get_entry(self) == &cmd_list_commands_entry)
 		return (cmd_list_keys_commands(self, item));
 
 	if (args->argc != 0) {
@@ -162,6 +165,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "invalid key: %s", args->argv[0]);
 			return (CMD_RETURN_ERROR);
 		}
+		only &= KEYC_MASK_KEY;
 	}
 
 	tablename = args_get(args, 'T');
@@ -219,7 +223,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 				bd = key_bindings_next(table, bd);
 				continue;
 			}
-			key = args_escape(key_string_lookup_key(bd->key));
+			key = args_escape(key_string_lookup_key(bd->key, 0));
 
 			if (bd->flags & KEY_BINDING_REPEAT)
 				repeat = 1;
@@ -253,7 +257,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 				continue;
 			}
 			found = 1;
-			key = args_escape(key_string_lookup_key(bd->key));
+			key = args_escape(key_string_lookup_key(bd->key, 0));
 
 			if (!repeat)
 				r = "";
@@ -269,7 +273,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 				tmpsize *= 2;
 				tmp = xrealloc(tmp, tmpsize);
 			}
-			tmpused = strlcat(tmp, cp, tmpsize);
+			strlcat(tmp, cp, tmpsize);
 			tmpused = strlcat(tmp, " ", tmpsize);
 			free(cp);
 
@@ -279,7 +283,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 				tmpsize *= 2;
 				tmp = xrealloc(tmp, tmpsize);
 			}
-			tmpused = strlcat(tmp, cp, tmpsize);
+			strlcat(tmp, cp, tmpsize);
 			tmpused = strlcat(tmp, " ", tmpsize);
 			free(cp);
 
@@ -313,7 +317,7 @@ out:
 static enum cmd_retval
 cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		 *args = self->args;
+	struct args		 *args = cmd_get_args(self);
 	const struct cmd_entry	**entryp;
 	const struct cmd_entry	 *entry;
 	struct format_tree	 *ft;
@@ -329,7 +333,7 @@ cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
 		    "#{command_list_usage}";
 	}
 
-	ft = format_create(item->client, item, FORMAT_NONE, 0);
+	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 	format_defaults(ft, NULL, NULL, NULL, NULL);
 
 	for (entryp = cmd_table; *entryp != NULL; entryp++) {

cmd-list-panes.c

@@ -38,8 +38,8 @@ const struct cmd_entry cmd_list_panes_entry = {
 	.name = "list-panes",
 	.alias = "lsp",
 
-	.args = { "asF:t:", 0, 0 },
+	.args = { "asF:f:t:", 0, 0 },
-	.usage = "[-as] [-F format] " CMD_TARGET_WINDOW_USAGE,
+	.usage = "[-as] [-F format] [-f filter] " CMD_TARGET_WINDOW_USAGE,
 
 	.target = { 't', CMD_FIND_WINDOW, 0 },
 
@@ -50,9 +50,10 @@ const struct cmd_entry cmd_list_panes_entry = {
 static enum cmd_retval
 cmd_list_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct session	*s = item->target.s;
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct winlink	*wl = item->target.wl;
+	struct session		*s = target->s;
+	struct winlink		*wl = target->wl;
 
 	if (args_has(args, 'a'))
 		cmd_list_panes_server(self, item);
@@ -87,12 +88,13 @@ static void
 cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
     struct cmdq_item *item, int type)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
 	struct window_pane	*wp;
 	u_int			 n;
 	struct format_tree	*ft;
-	const char		*template;
+	const char		*template, *filter;
-	char			*line;
+	char			*line, *expanded;
+	int			 flag;
 
 	template = args_get(args, 'F');
 	if (template == NULL) {
@@ -120,16 +122,25 @@ cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
 			break;
 		}
 	}
+	filter = args_get(args, 'f');
 
 	n = 0;
 	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
 		format_defaults(ft, NULL, s, wl, wp);
 
-		line = format_expand(ft, template);
+		if (filter != NULL) {
-		cmdq_print(item, "%s", line);
+			expanded = format_expand(ft, filter);
-		free(line);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 		n++;

cmd-list-sessions.c

@@ -42,8 +42,8 @@ const struct cmd_entry cmd_list_sessions_entry = {
 	.name = "list-sessions",
 	.alias = "ls",
 
-	.args = { "F:", 0, 0 },
+	.args = { "F:f:", 0, 0 },
-	.usage = "[-F format]",
+	.usage = "[-F format] [-f filter]",
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_sessions_exec
@@ -52,25 +52,35 @@ const struct cmd_entry cmd_list_sessions_entry = {
 static enum cmd_retval
 cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
 	struct session		*s;
 	u_int		 	 n;
 	struct format_tree	*ft;
-	const char		*template;
+	const char		*template, *filter;
-	char			*line;
+	char			*line, *expanded;
+	int			 flag;
 
 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_SESSIONS_TEMPLATE;
+	filter = args_get(args, 'f');
 
 	n = 0;
 	RB_FOREACH(s, sessions, &sessions) {
-		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
 		format_defaults(ft, NULL, s, NULL, NULL);
 
-		line = format_expand(ft, template);
+		if (filter != NULL) {
-		cmdq_print(item, "%s", line);
+			expanded = format_expand(ft, filter);
-		free(line);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 		n++;

cmd-list-windows.c

@@ -28,14 +28,14 @@
  */
 
 #define LIST_WINDOWS_TEMPLATE					\
-	"#{window_index}: #{window_name}#{window_flags} "	\
+	"#{window_index}: #{window_name}#{window_raw_flags} "	\
 	"(#{window_panes} panes) "				\
 	"[#{window_width}x#{window_height}] "			\
 	"[layout #{window_layout}] #{window_id}"		\
 	"#{?window_active, (active),}";
 #define LIST_WINDOWS_WITH_SESSION_TEMPLATE			\
 	"#{session_name}:"					\
-	"#{window_index}: #{window_name}#{window_flags} "	\
+	"#{window_index}: #{window_name}#{window_raw_flags} "	\
 	"(#{window_panes} panes) "				\
 	"[#{window_width}x#{window_height}] "
 
@@ -49,8 +49,8 @@ const struct cmd_entry cmd_list_windows_entry = {
 	.name = "list-windows",
 	.alias = "lsw",
 
-	.args = { "F:at:", 0, 0 },
+	.args = { "F:f:at:", 0, 0 },
-	.usage = "[-a] [-F format] " CMD_TARGET_SESSION_USAGE,
+	.usage = "[-a] [-F format] [-f filter] " CMD_TARGET_SESSION_USAGE,
 
 	.target = { 't', CMD_FIND_SESSION, 0 },
 
@@ -61,12 +61,13 @@ const struct cmd_entry cmd_list_windows_entry = {
 static enum cmd_retval
 cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 
 	if (args_has(args, 'a'))
 		cmd_list_windows_server(self, item);
 	else
-		cmd_list_windows_session(self, item->target.s, item, 0);
+		cmd_list_windows_session(self, target->s, item, 0);
 
 	return (CMD_RETURN_NORMAL);
 }
@@ -84,12 +85,13 @@ static void
 cmd_list_windows_session(struct cmd *self, struct session *s,
     struct cmdq_item *item, int type)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
 	struct winlink		*wl;
 	u_int			 n;
 	struct format_tree	*ft;
-	const char		*template;
+	const char		*template, *filter;
-	char			*line;
+	char			*line, *expanded;
+	int			 flag;
 
 	template = args_get(args, 'F');
 	if (template == NULL) {
@@ -102,16 +104,25 @@ cmd_list_windows_session(struct cmd *self, struct session *s,
 			break;
 		}
 	}
+	filter = args_get(args, 'f');
 
 	n = 0;
 	RB_FOREACH(wl, winlinks, &s->windows) {
-		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
 		format_defaults(ft, NULL, s, wl, NULL);
 
-		line = format_expand(ft, template);
+		if (filter != NULL) {
-		cmdq_print(item, "%s", line);
+			expanded = format_expand(ft, filter);
-		free(line);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 		n++;

cmd-load-buffer.c

@@ -37,14 +37,15 @@ const struct cmd_entry cmd_load_buffer_entry = {
 	.name = "load-buffer",
 	.alias = "loadb",
 
-	.args = { "b:", 1, 1 },
+	.args = { "b:t:w", 1, 1 },
-	.usage = CMD_BUFFER_USAGE " path",
+	.usage = CMD_BUFFER_USAGE " " CMD_TARGET_CLIENT_USAGE " path",
 
-	.flags = CMD_AFTERHOOK,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG|CMD_CLIENT_CANFAIL,
 	.exec = cmd_load_buffer_exec
 };
 
 struct cmd_load_buffer_data {
+	struct client		*client;
 	struct cmdq_item	*item;
 	char			*name;
 };
@@ -54,6 +55,7 @@ cmd_load_buffer_done(__unused struct client *c, const char *path, int error,
     int closed, struct evbuffer *buffer, void *data)
 {
 	struct cmd_load_buffer_data	*cdata = data;
+	struct client			*tc = cdata->client;
 	struct cmdq_item		*item = cdata->item;
 	void				*bdata = EVBUFFER_DATA(buffer);
 	size_t				 bsize = EVBUFFER_LENGTH(buffer);
@@ -72,7 +74,12 @@ cmd_load_buffer_done(__unused struct client *c, const char *path, int error,
 			cmdq_error(item, "%s", cause);
 			free(cause);
 			free(copy);
-		}
+		} else if (tc != NULL &&
+		    tc->session != NULL &&
+		    (~tc->flags & CLIENT_DEAD))
+			tty_set_selection(&tc->tty, copy, bsize);
+		if (tc != NULL)
+			server_client_unref(tc);
 	}
 	cmdq_continue(item);
 
@@ -83,24 +90,23 @@ cmd_load_buffer_done(__unused struct client *c, const char *path, int error,
 static enum cmd_retval
 cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
+	struct client			*tc = cmdq_get_target_client(item);
 	struct cmd_load_buffer_data	*cdata;
-	struct client			*c = cmd_find_client(item, NULL, 1);
-	struct session			*s = item->target.s;
-	struct winlink			*wl = item->target.wl;
-	struct window_pane		*wp = item->target.wp;
 	const char			*bufname = args_get(args, 'b');
 	char				*path;
 
-	cdata = xmalloc(sizeof *cdata);
+	cdata = xcalloc(1, sizeof *cdata);
 	cdata->item = item;
 	if (bufname != NULL)
 		cdata->name = xstrdup(bufname);
-	else
+	if (args_has(args, 'w') && tc != NULL) {
-		cdata->name = NULL;
+		cdata->client = tc;
+		cdata->client->references++;
+	}
 
-	path = format_single(item, args->argv[0], c, s, wl, wp);
+	path = format_single_from_target(item, args->argv[0]);
-	file_read(item->client, path, cmd_load_buffer_done, cdata);
+	file_read(cmdq_get_client(item), path, cmd_load_buffer_done, cdata);
 	free(path);
 
 	return (CMD_RETURN_WAIT);

cmd-lock-server.c

@@ -57,25 +57,22 @@ const struct cmd_entry cmd_lock_client_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_CLIENT_USAGE,
 
-	.flags = CMD_AFTERHOOK,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
 	.exec = cmd_lock_server_exec
 };
 
 static enum cmd_retval
 cmd_lock_server_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct client	*c;
+	struct client		*tc = cmdq_get_target_client(item);
 
-	if (self->entry == &cmd_lock_server_entry)
+	if (cmd_get_entry(self) == &cmd_lock_server_entry)
 		server_lock();
-	else if (self->entry == &cmd_lock_session_entry)
+	else if (cmd_get_entry(self) == &cmd_lock_session_entry)
-		server_lock_session(item->target.s);
+		server_lock_session(target->s);
-	else {
+	else
-		if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		server_lock_client(tc);
-			return (CMD_RETURN_ERROR);
-		server_lock_client(c);
-	}
 	recalculate_sizes();
 
 	return (CMD_RETURN_NORMAL);

cmd-move-window.c

@@ -32,8 +32,8 @@ const struct cmd_entry cmd_move_window_entry = {
 	.name = "move-window",
 	.alias = "movew",
 
-	.args = { "adkrs:t:", 0, 0 },
+	.args = { "abdkrs:t:", 0, 0 },
-	.usage = "[-dkr] " CMD_SRCDST_WINDOW_USAGE,
+	.usage = "[-abdkr] " CMD_SRCDST_WINDOW_USAGE,
 
 	.source = { 's', CMD_FIND_WINDOW, 0 },
 	/* -t is special */
@@ -46,8 +46,8 @@ const struct cmd_entry cmd_link_window_entry = {
 	.name = "link-window",
 	.alias = "linkw",
 
-	.args = { "adks:t:", 0, 0 },
+	.args = { "abdks:t:", 0, 0 },
-	.usage = "[-dk] " CMD_SRCDST_WINDOW_USAGE,
+	.usage = "[-abdk] " CMD_SRCDST_WINDOW_USAGE,
 
 	.source = { 's', CMD_FIND_WINDOW, 0 },
 	/* -t is special */
@@ -59,49 +59,53 @@ const struct cmd_entry cmd_link_window_entry = {
 static enum cmd_retval
 cmd_move_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	const char	*tflag = args_get(args, 't');
+	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct session	*src;
+	struct cmd_find_state	 target;
-	struct session	*dst;
+	const char		*tflag = args_get(args, 't');
-	struct winlink	*wl;
+	struct session		*src = source->s;
-	char		*cause;
+	struct session		*dst;
-	int		 idx, kflag, dflag, sflag;
+	struct winlink		*wl = source->wl;
+	char			*cause;
+	int			 idx, kflag, dflag, sflag, before;
 
 	if (args_has(args, 'r')) {
-		if (cmd_find_target(&item->target, item, tflag,
+		if (cmd_find_target(&target, item, tflag, CMD_FIND_SESSION,
-		    CMD_FIND_SESSION, CMD_FIND_QUIET) != 0)
+		    CMD_FIND_QUIET) != 0)
 			return (CMD_RETURN_ERROR);
 
-		session_renumber_windows(item->target.s);
+		session_renumber_windows(target.s);
 		recalculate_sizes();
-		server_status_session(item->target.s);
+		server_status_session(target.s);
 
 		return (CMD_RETURN_NORMAL);
 	}
-	if (cmd_find_target(&item->target, item, tflag, CMD_FIND_WINDOW,
+	if (cmd_find_target(&target, item, tflag, CMD_FIND_WINDOW,
 	    CMD_FIND_WINDOW_INDEX) != 0)
 		return (CMD_RETURN_ERROR);
-	src = item->source.s;
+	dst = target.s;
-	dst = item->target.s;
+	idx = target.idx;
-	wl = item->source.wl;
-	idx = item->target.idx;
 
-	kflag = args_has(self->args, 'k');
+	kflag = args_has(args, 'k');
-	dflag = args_has(self->args, 'd');
+	dflag = args_has(args, 'd');
-	sflag = args_has(self->args, 's');
+	sflag = args_has(args, 's');
 
-	if (args_has(self->args, 'a')) {
+	before = args_has(args, 'b');
-		if ((idx = winlink_shuffle_up(dst, dst->curw)) == -1)
+	if (args_has(args, 'a') || before) {
+		if (target.wl != NULL)
+			idx = winlink_shuffle_up(dst, target.wl, before);
+		else
+			idx = winlink_shuffle_up(dst, dst->curw, before);
+		if (idx == -1)
 			return (CMD_RETURN_ERROR);
 	}
 
-	if (server_link_window(src, wl, dst, idx, kflag, !dflag,
+	if (server_link_window(src, wl, dst, idx, kflag, !dflag, &cause) != 0) {
-	    &cause) != 0) {
+		cmdq_error(item, "%s", cause);
-		cmdq_error(item, "can't link window: %s", cause);
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
-	if (self->entry == &cmd_move_window_entry)
+	if (cmd_get_entry(self) == &cmd_move_window_entry)
 		server_unlink_window(src, wl);
 
 	/*

cmd-new-session.c

@@ -39,10 +39,10 @@ const struct cmd_entry cmd_new_session_entry = {
 	.name = "new-session",
 	.alias = "new",
 
-	.args = { "Ac:dDEF:n:Ps:t:x:Xy:", 0, -1 },
+	.args = { "Ac:dDe:EF:f:n:Ps:t:x:Xy:", 0, -1 },
-	.usage = "[-AdDEPX] [-c start-directory] [-F format] [-n window-name] "
+	.usage = "[-AdDEPX] [-c start-directory] [-e environment] [-F format] "
-		 "[-s session-name] " CMD_TARGET_SESSION_USAGE " [-x width] "
+		 "[-f flags] [-n window-name] [-s session-name] "
-		 "[-y height] [command]",
+		 CMD_TARGET_SESSION_USAGE " [-x width] [-y height] [command]",
 
 	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
@@ -66,22 +66,26 @@ const struct cmd_entry cmd_has_session_entry = {
 static enum cmd_retval
 cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client		*c = item->client;
+	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct session		*s, *as, *groupwith;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*c = cmdq_get_client(item);
+	struct session		*s, *as, *groupwith = NULL;
 	struct environ		*env;
 	struct options		*oo;
 	struct termios		 tio, *tiop;
-	struct session_group	*sg;
+	struct session_group	*sg = NULL;
-	const char		*errstr, *template, *group, *prefix, *tmp;
+	const char		*errstr, *template, *group, *tmp, *add;
 	char			*cause, *cwd = NULL, *cp, *newname = NULL;
+	char			*name, *prefix = NULL;
 	int			 detached, already_attached, is_control = 0;
 	u_int			 sx, sy, dsx, dsy;
 	struct spawn_context	 sc;
 	enum cmd_retval		 retval;
 	struct cmd_find_state    fs;
+	struct args_value	*value;
 
-	if (self->entry == &cmd_has_session_entry) {
+	if (cmd_get_entry(self) == &cmd_has_session_entry) {
 		/*
 		 * cmd_find_target() will fail if the session cannot be found,
 		 * so always return success here.
@@ -96,21 +100,19 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 
 	tmp = args_get(args, 's');
 	if (tmp != NULL) {
-		newname = format_single(item, tmp, c, NULL, NULL, NULL);
+		name = format_single(item, tmp, c, NULL, NULL, NULL);
-		if (!session_check_name(newname)) {
+		newname = session_check_name(name);
-			cmdq_error(item, "bad session name: %s", newname);
+		free(name);
-			goto fail;
-		}
 	}
 	if (args_has(args, 'A')) {
 		if (newname != NULL)
 			as = session_find(newname);
 		else
-			as = item->target.s;
+			as = target->s;
 		if (as != NULL) {
 			retval = cmd_attach_session(item, as->name,
 			    args_has(args, 'D'), args_has(args, 'X'), 0, NULL,
-			    args_has(args, 'E'));
+			    args_has(args, 'E'), args_get(args, 'f'));
 			free(newname);
 			return (retval);
 		}
@@ -123,25 +125,17 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	/* Is this going to be part of a session group? */
 	group = args_get(args, 't');
 	if (group != NULL) {
-		groupwith = item->target.s;
+		groupwith = target->s;
-		if (groupwith == NULL) {
+		if (groupwith == NULL)
-			if (!session_check_name(group)) {
-				cmdq_error(item, "bad group name: %s", group);
-				goto fail;
-			}
 			sg = session_group_find(group);
-		} else
+		else
 			sg = session_group_contains(groupwith);
 		if (sg != NULL)
-			prefix = sg->name;
+			prefix = xstrdup(sg->name);
 		else if (groupwith != NULL)
-			prefix = groupwith->name;
+			prefix = xstrdup(groupwith->name);
 		else
-			prefix = group;
+			prefix = session_check_name(group);
-	} else {
-		groupwith = NULL;
-		sg = NULL;
-		prefix = NULL;
 	}
 
 	/* Set -d if no client. */
@@ -171,13 +165,16 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	 * the terminal as that calls tcsetattr() to prepare for tmux taking
 	 * over.
 	 */
-	if (!detached && !already_attached && c->tty.fd != -1) {
+	if (!detached &&
-		if (server_client_check_nested(item->client)) {
+	    !already_attached &&
+	    c->fd != -1 &&
+	    (~c->flags & CLIENT_CONTROL)) {
+		if (server_client_check_nested(cmdq_get_client(item))) {
 			cmdq_error(item, "sessions should be nested with care, "
 			    "unset $TMUX to force");
 			goto fail;
 		}
-		if (tcgetattr(c->tty.fd, &tio) != 0)
+		if (tcgetattr(c->fd, &tio) != 0)
 			fatal("tcgetattr failed");
 		tiop = &tio;
 	} else
@@ -207,7 +204,8 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 				goto fail;
 			}
 		}
-	}
+	} else
+		dsx = 80;
 	if (args_has(args, 'y')) {
 		tmp = args_get(args, 'y');
 		if (strcmp(tmp, "-") == 0) {
@@ -222,7 +220,8 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 				goto fail;
 			}
 		}
-	}
+	} else
+		dsy = 24;
 
 	/* Find new session size. */
 	if (!detached && !is_control) {
@@ -233,13 +232,14 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	} else {
 		tmp = options_get_string(global_s_options, "default-size");
 		if (sscanf(tmp, "%ux%u", &sx, &sy) != 2) {
-			sx = 80;
-			sy = 24;
-		}
-		if (args_has(args, 'x'))
 			sx = dsx;
-		if (args_has(args, 'y'))
 			sy = dsy;
+		} else {
+			if (args_has(args, 'x'))
+				sx = dsx;
+			if (args_has(args, 'y'))
+				sy = dsy;
+		}
 	}
 	if (sx == 0)
 		sx = 1;
@@ -258,13 +258,17 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	env = environ_create();
 	if (c != NULL && !args_has(args, 'E'))
 		environ_update(global_s_options, c->environ, env);
+	add = args_first_value(args, 'e', &value);
+	while (add != NULL) {
+		environ_put(env, add, 0);
+		add = args_next_value(&value);
+	}
 	s = session_create(prefix, newname, cwd, env, oo, tiop);
 
 	/* Spawn the initial window. */
 	memset(&sc, 0, sizeof sc);
 	sc.item = item;
 	sc.s = s;
-	sc.c = c;
 
 	sc.name = args_get(args, 'n');
 	sc.argc = args->argc;
@@ -305,13 +309,15 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	 * taking this session and needs to get MSG_READY and stay around.
 	 */
 	if (!detached) {
+		if (args_has(args, 'f'))
+			server_client_set_flags(c, args_get(args, 'f'));
 		if (!already_attached) {
 			if (~c->flags & CLIENT_CONTROL)
 				proc_send(c->peer, MSG_READY, -1, NULL, 0);
 		} else if (c->session != NULL)
 			c->last_session = c->session;
 		c->session = s;
-		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+		if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
 			server_client_set_key_table(c, NULL);
 		tty_update_client_offset(c);
 		status_timer_start(c);
@@ -339,20 +345,22 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 		free(cp);
 	}
 
-	if (!detached) {
+	if (!detached)
 		c->flags |= CLIENT_ATTACHED;
-		cmd_find_from_session(&item->shared->current, s, 0);
+	if (!args_has(args, 'd'))
-	}
+		cmd_find_from_session(current, s, 0);
 
 	cmd_find_from_session(&fs, s, 0);
 	cmdq_insert_hook(s, item, &fs, "after-new-session");
 
 	free(cwd);
 	free(newname);
+	free(prefix);
 	return (CMD_RETURN_NORMAL);
 
 fail:
 	free(cwd);
 	free(newname);
+	free(prefix);
 	return (CMD_RETURN_ERROR);
 }

cmd-new-window.c

@@ -38,8 +38,8 @@ const struct cmd_entry cmd_new_window_entry = {
 	.name = "new-window",
 	.alias = "neww",
 
-	.args = { "ac:de:F:kn:Pt:", 0, -1 },
+	.args = { "abc:de:F:kn:PSt:", 0, -1 },
-	.usage = "[-adkP] [-c start-directory] [-e environment] [-F format] "
+	.usage = "[-abdkPS] [-c start-directory] [-e environment] [-F format] "
 		 "[-n window-name] " CMD_TARGET_WINDOW_USAGE " [command]",
 
 	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },
@@ -51,28 +51,61 @@ const struct cmd_entry cmd_new_window_entry = {
 static enum cmd_retval
 cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = &item->shared->current;
+	struct client		*c = cmdq_get_client(item);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct spawn_context	 sc;
-	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct client		*tc = cmdq_get_target_client(item);
-	struct session		*s = item->target.s;
+	struct session		*s = target->s;
-	struct winlink		*wl = item->target.wl;
+	struct winlink		*wl = target->wl;
-	int			 idx = item->target.idx;
+	int			 idx = target->idx, before;
-	struct winlink		*new_wl;
+	struct winlink		*new_wl = NULL;
 	char			*cause = NULL, *cp;
-	const char		*template, *add;
+	const char		*template, *add, *name;
 	struct cmd_find_state	 fs;
 	struct args_value	*value;
 
-	if (args_has(args, 'a') && (idx = winlink_shuffle_up(s, wl)) == -1) {
+	/*
-		cmdq_error(item, "couldn't get a window index");
+	 * If -S and -n are given and -t is not and a single window with this
-		return (CMD_RETURN_ERROR);
+	 * name already exists, select it.
+	 */
+	name = args_get(args, 'n');
+	if (args_has(args, 'S') && name != NULL && target->idx == -1) {
+		RB_FOREACH(wl, winlinks, &s->windows) {
+			if (strcmp(wl->window->name, name) != 0)
+				continue;
+			if (new_wl == NULL) {
+				new_wl = wl;
+				continue;
+			}
+			cmdq_error(item, "multiple windows named %s", name);
+			return (CMD_RETURN_ERROR);
+		}
+		if (new_wl != NULL) {
+			if (args_has(args, 'd'))
+				return (CMD_RETURN_NORMAL);
+			if (session_set_current(s, new_wl) == 0)
+				server_redraw_session(s);
+			if (c != NULL && c->session != NULL)
+				s->curw->window->latest = c;
+			recalculate_sizes();
+			return (CMD_RETURN_NORMAL);
+		}
+	}
+
+
+	before = args_has(args, 'b');
+	if (args_has(args, 'a') || before) {
+		idx = winlink_shuffle_up(s, wl, before);
+		if (idx == -1)
+			idx = target->idx;
 	}
 
 	memset(&sc, 0, sizeof sc);
 	sc.item = item;
 	sc.s = s;
-	sc.c = c;
+	sc.tc = tc;
 
 	sc.name = args_get(args, 'n');
 	sc.argc = args->argc;
@@ -81,7 +114,7 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 
 	add = args_first_value(args, 'e', &value);
 	while (add != NULL) {
-		environ_put(sc.environ, add);
+		environ_put(sc.environ, add, 0);
 		add = args_next_value(&value);
 	}
 
@@ -108,8 +141,8 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = NEW_WINDOW_TEMPLATE;
-		cp = format_single(item, template, c, s, new_wl,
+		cp = format_single(item, template, tc, s, new_wl,
-		    new_wl->window->active);
+			new_wl->window->active);
 		cmdq_print(item, "%s", cp);
 		free(cp);
 	}

cmd-parse.y

@@ -26,6 +26,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <wchar.h>
 
 #include "tmux.h"
 
@@ -42,7 +43,6 @@ struct cmd_parse_scope {
 };
 
 struct cmd_parse_command {
-	char				 *name;
 	u_int				  line;
 
 	int				  argc;
@@ -77,6 +77,7 @@ static char	*cmd_parse_get_error(const char *, u_int, const char *);
 static void	 cmd_parse_free_command(struct cmd_parse_command *);
 static struct cmd_parse_commands *cmd_parse_new_commands(void);
 static void	 cmd_parse_free_commands(struct cmd_parse_commands *);
+static char	*cmd_parse_commands_to_string(struct cmd_parse_commands *);
 static void	 cmd_parse_print_commands(struct cmd_parse_input *, u_int,
 		     struct cmd_list *);
 
@@ -99,6 +100,7 @@ static void	 cmd_parse_print_commands(struct cmd_parse_input *, u_int,
 }
 
 %token ERROR
+%token HIDDEN
 %token IF
 %token ELSE
 %token ELIF
@@ -109,7 +111,8 @@ static void	 cmd_parse_print_commands(struct cmd_parse_input *, u_int,
 %type <arguments> arguments
 %type <flag> if_open if_elif
 %type <elif> elif elif1
-%type <commands> statements statement commands condition condition1
+%type <commands> argument_statements statements statement
+%type <commands> commands condition condition1
 %type <command> command
 
 %%
@@ -134,6 +137,11 @@ statements	: statement '\n'
 		}
 
 statement	: /* empty */
+		{
+			$$ = xmalloc (sizeof *$$);
+			TAILQ_INIT($$);
+		}
+		| hidden_assignment
 		{
 			$$ = xmalloc (sizeof *$$);
 			TAILQ_INIT($$);
@@ -204,10 +212,21 @@ assignment	: EQUALS
 
 			if ((~flags & CMD_PARSE_PARSEONLY) &&
 			    (ps->scope == NULL || ps->scope->flag))
-				environ_put(global_environ, $1);
+				environ_put(global_environ, $1, 0);
 			free($1);
 		}
 
+hidden_assignment : HIDDEN EQUALS
+		{
+			struct cmd_parse_state	*ps = &parse_state;
+			int			 flags = ps->input->flags;
+
+			if ((~flags & CMD_PARSE_PARSEONLY) &&
+			    (ps->scope == NULL || ps->scope->flag))
+				environ_put(global_environ, $2, ENVIRON_HIDDEN);
+			free($2);
+		}
+
 if_open		: IF expanded
 		{
 			struct cmd_parse_state	*ps = &parse_state;
@@ -341,7 +360,7 @@ commands	: command
 			struct cmd_parse_state	*ps = &parse_state;
 
 			$$ = cmd_parse_new_commands();
-			if ($1->name != NULL &&
+			if ($1->argc != 0 &&
 			    (ps->scope == NULL || ps->scope->flag))
 				TAILQ_INSERT_TAIL($$, $1, entry);
 			else
@@ -361,7 +380,7 @@ commands	: command
 		{
 			struct cmd_parse_state	*ps = &parse_state;
 
-			if ($3->name != NULL &&
+			if ($3->argc != 0 &&
 			    (ps->scope == NULL || ps->scope->flag)) {
 				$$ = $1;
 				TAILQ_INSERT_TAIL($$, $3, entry);
@@ -381,7 +400,6 @@ command		: assignment
 			struct cmd_parse_state	*ps = &parse_state;
 
 			$$ = xcalloc(1, sizeof *$$);
-			$$->name = NULL;
 			$$->line = ps->input->line;
 		}
 		| optional_assignment TOKEN
@@ -389,20 +407,21 @@ command		: assignment
 			struct cmd_parse_state	*ps = &parse_state;
 
 			$$ = xcalloc(1, sizeof *$$);
-			$$->name = $2;
 			$$->line = ps->input->line;
 
+			cmd_prepend_argv(&$$->argc, &$$->argv, $2);
+
 		}
 		| optional_assignment TOKEN arguments
 		{
 			struct cmd_parse_state	*ps = &parse_state;
 
 			$$ = xcalloc(1, sizeof *$$);
-			$$->name = $2;
 			$$->line = ps->input->line;
 
 			$$->argc = $3.argc;
 			$$->argv = $3.argv;
+			cmd_prepend_argv(&$$->argc, &$$->argv, $2);
 		}
 
 condition1	: if_open commands if_close
@@ -506,6 +525,22 @@ argument	: TOKEN
 		{
 			$$ = $1;
 		}
+		| '{' argument_statements
+		{
+			$$ = cmd_parse_commands_to_string($2);
+			cmd_parse_free_commands($2);
+		}
+
+argument_statements	: statement '}'
+			{
+				$$ = $1;
+			}
+			| statements statement '}'
+			{
+				$$ = $1;
+				TAILQ_CONCAT($$, $2, entry);
+				free($2);
+			}
 
 %%
 
@@ -540,7 +575,6 @@ cmd_parse_print_commands(struct cmd_parse_input *pi, u_int line,
 static void
 cmd_parse_free_command(struct cmd_parse_command *cmd)
 {
-	free(cmd->name);
 	cmd_free_argv(cmd->argc, cmd->argv);
 	free(cmd);
 }
@@ -567,6 +601,30 @@ cmd_parse_free_commands(struct cmd_parse_commands *cmds)
 	free(cmds);
 }
 
+static char *
+cmd_parse_commands_to_string(struct cmd_parse_commands *cmds)
+{
+	struct cmd_parse_command	 *cmd;
+	char				 *string = NULL, *s, *line;
+
+	TAILQ_FOREACH(cmd, cmds, entry) {
+		line = cmd_stringify_argv(cmd->argc, cmd->argv);
+		if (string == NULL)
+			s = line;
+		else {
+			xasprintf(&s, "%s ; %s", s, line);
+			free(line);
+		}
+
+		free(string);
+		string = s;
+	}
+	if (string == NULL)
+		string = xstrdup("");
+	log_debug("%s: %s", __func__, string);
+	return (string);
+}
+
 static struct cmd_parse_commands *
 cmd_parse_run_parser(char **cause)
 {
@@ -627,7 +685,7 @@ cmd_parse_build_commands(struct cmd_parse_commands *cmds,
 	int				 i;
 	struct cmd_list			*cmdlist = NULL, *result;
 	struct cmd			*add;
-	char				*alias, *cause, *s;
+	char				*name, *alias, *cause, *s;
 
 	/* Check for an empty list. */
 	if (TAILQ_EMPTY(cmds)) {
@@ -643,12 +701,14 @@ cmd_parse_build_commands(struct cmd_parse_commands *cmds,
 	 * command list.
 	 */
 	TAILQ_FOREACH_SAFE(cmd, cmds, entry, next) {
-		alias = cmd_get_alias(cmd->name);
+		name = cmd->argv[0];
+
+		alias = cmd_get_alias(name);
 		if (alias == NULL)
 			continue;
 
 		line = cmd->line;
-		log_debug("%s: %u %s = %s", __func__, line, cmd->name, alias);
+		log_debug("%s: %u %s = %s", __func__, line, name, alias);
 
 		pi->line = line;
 		cmds2 = cmd_parse_do_buffer(alias, strlen(alias), pi, &cause);
@@ -665,7 +725,7 @@ cmd_parse_build_commands(struct cmd_parse_commands *cmds,
 			cmd_parse_free_command(cmd);
 			continue;
 		}
-		for (i = 0; i < cmd->argc; i++)
+		for (i = 1; i < cmd->argc; i++)
 			cmd_append_argv(&cmd2->argc, &cmd2->argv, cmd->argv[i]);
 
 		after = cmd;
@@ -683,15 +743,18 @@ cmd_parse_build_commands(struct cmd_parse_commands *cmds,
 
 	/*
 	 * Parse each command into a command list. Create a new command list
-	 * for each line so they get a new group (so the queue knows which ones
+	 * for each line (unless the flag is set) so they get a new group (so
-	 * to remove if a command fails when executed).
+	 * the queue knows which ones to remove if a command fails when
+	 * executed).
 	 */
 	result = cmd_list_new();
 	TAILQ_FOREACH(cmd, cmds, entry) {
-		log_debug("%s: %u %s", __func__, cmd->line, cmd->name);
+		name = cmd->argv[0];
+		log_debug("%s: %u %s", __func__, cmd->line, name);
 		cmd_log_argv(cmd->argc, cmd->argv, __func__);
 
-		if (cmdlist == NULL || cmd->line != line) {
+		if (cmdlist == NULL ||
+		    ((~pi->flags & CMD_PARSE_ONEGROUP) && cmd->line != line)) {
 			if (cmdlist != NULL) {
 				cmd_parse_print_commands(pi, line, cmdlist);
 				cmd_list_move(result, cmdlist);
@@ -701,7 +764,6 @@ cmd_parse_build_commands(struct cmd_parse_commands *cmds,
 		}
 		line = cmd->line;
 
-		cmd_prepend_argv(&cmd->argc, &cmd->argv, cmd->name);
 		add = cmd_parse(cmd->argc, cmd->argv, pi->file, line, &cause);
 		if (add == NULL) {
 			cmd_list_free(result);
@@ -758,9 +820,74 @@ cmd_parse_from_file(FILE *f, struct cmd_parse_input *pi)
 struct cmd_parse_result *
 cmd_parse_from_string(const char *s, struct cmd_parse_input *pi)
 {
+	struct cmd_parse_input	input;
+
+	if (pi == NULL) {
+		memset(&input, 0, sizeof input);
+		pi = &input;
+	}
+
+	/*
+	 * When parsing a string, put commands in one group even if there are
+	 * multiple lines. This means { a \n b } is identical to "a ; b" when
+	 * given as an argument to another command.
+	 */
+	pi->flags |= CMD_PARSE_ONEGROUP;
 	return (cmd_parse_from_buffer(s, strlen(s), pi));
 }
 
+enum cmd_parse_status
+cmd_parse_and_insert(const char *s, struct cmd_parse_input *pi,
+    struct cmdq_item *after, struct cmdq_state *state, char **error)
+{
+	struct cmd_parse_result	*pr;
+	struct cmdq_item	*item;
+
+	pr = cmd_parse_from_string(s, pi);
+	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		break;
+	case CMD_PARSE_ERROR:
+		if (error != NULL)
+			*error = pr->error;
+		else
+			free(pr->error);
+		break;
+	case CMD_PARSE_SUCCESS:
+		item = cmdq_get_command(pr->cmdlist, state);
+		cmdq_insert_after(after, item);
+		cmd_list_free(pr->cmdlist);
+		break;
+	}
+	return (pr->status);
+}
+
+enum cmd_parse_status
+cmd_parse_and_append(const char *s, struct cmd_parse_input *pi,
+    struct client *c, struct cmdq_state *state, char **error)
+{
+	struct cmd_parse_result	*pr;
+	struct cmdq_item	*item;
+
+	pr = cmd_parse_from_string(s, pi);
+	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		break;
+	case CMD_PARSE_ERROR:
+		if (error != NULL)
+			*error = pr->error;
+		else
+			free(pr->error);
+		break;
+	case CMD_PARSE_SUCCESS:
+		item = cmdq_get_command(pr->cmdlist, state);
+		cmdq_append(c, item);
+		cmd_list_free(pr->cmdlist);
+		break;
+	}
+	return (pr->status);
+}
+
 struct cmd_parse_result *
 cmd_parse_from_buffer(const void *buf, size_t len, struct cmd_parse_input *pi)
 {
@@ -836,11 +963,10 @@ cmd_parse_from_arguments(int argc, char **argv, struct cmd_parse_input *pi)
 			    i);
 
 			cmd = xcalloc(1, sizeof *cmd);
-			cmd->name = xstrdup(new_argv[0]);
 			cmd->line = pi->line;
 
-			cmd->argc = new_argc - 1;
+			cmd->argc = new_argc;
-			cmd->argv = cmd_copy_argv(new_argc - 1, new_argv + 1);
+			cmd->argv = cmd_copy_argv(new_argc, new_argv);
 
 			TAILQ_INSERT_TAIL(cmds, cmd, entry);
 		}
@@ -856,11 +982,10 @@ cmd_parse_from_arguments(int argc, char **argv, struct cmd_parse_input *pi)
 			    last);
 
 			cmd = xcalloc(1, sizeof *cmd);
-			cmd->name = xstrdup(new_argv[0]);
 			cmd->line = pi->line;
 
-			cmd->argc = new_argc - 1;
+			cmd->argc = new_argc;
-			cmd->argv = cmd_copy_argv(new_argc - 1, new_argv + 1);
+			cmd->argv = cmd_copy_argv(new_argc, new_argv);
 
 			TAILQ_INSERT_TAIL(cmds, cmd, entry);
 		}
@@ -1038,11 +1163,11 @@ yylex(void)
 			return ('\n');
 		}
 
-		if (ch == ';') {
+		if (ch == ';' || ch == '{' || ch == '}') {
 			/*
-			 * A semicolon is itself.
+			 * A semicolon or { or } is itself.
 			 */
-			return (';');
+			return (ch);
 		}
 
 		if (ch == '#') {
@@ -1079,6 +1204,10 @@ yylex(void)
 			if (*cp == '\0')
 				return (TOKEN);
 			ps->condition = 1;
+			if (strcmp(yylval.token, "%hidden") == 0) {
+				free(yylval.token);
+				return (HIDDEN);
+			}
 			if (strcmp(yylval.token, "%if") == 0) {
 				free(yylval.token);
 				return (IF);
@@ -1163,10 +1292,9 @@ error:
 static int
 yylex_token_escape(char **buf, size_t *len)
 {
-	int			 ch, type, o2, o3;
+	int	 ch, type, o2, o3, mlen;
-	u_int			 size, i, tmp;
+	u_int	 size, i, tmp;
-	char			 s[9];
+	char	 s[9], m[MB_LEN_MAX];
-	struct utf8_data	 ud;
 
 	ch = yylex_getc();
 
@@ -1251,11 +1379,12 @@ unicode:
 		yyerror("invalid \\%c argument", type);
 		return (0);
 	}
-	if (utf8_split(tmp, &ud) != UTF8_DONE) {
+	mlen = wctomb(m, tmp);
+	if (mlen <= 0 || mlen > (int)sizeof m) {
 		yyerror("invalid \\%c argument", type);
 		return (0);
 	}
-	yylex_append(buf, len, ud.data, ud.size);
+	yylex_append(buf, len, m, mlen);
 	return (1);
 }
 
@@ -1303,7 +1432,7 @@ yylex_token_variable(char **buf, size_t *len)
 	name[namelen] = '\0';
 
 	envent = environ_find(global_environ, name);
-	if (envent != NULL) {
+	if (envent != NULL && envent->value != NULL) {
 		value = envent->value;
 		log_debug("%s: %s -> %s", __func__, name, value);
 		yylex_append(buf, len, value, strlen(value));
@@ -1353,119 +1482,6 @@ yylex_token_tilde(char **buf, size_t *len)
 	return (1);
 }
 
-static int
-yylex_token_brace(char **buf, size_t *len)
-{
-	struct cmd_parse_state	*ps = &parse_state;
-	int 			 ch, lines = 0, nesting = 1, escape = 0;
-	int			 quote = '\0', token = 0;
-
-	/*
-	 * Extract a string up to the matching unquoted '}', including newlines
-	 * and handling nested braces.
-	 *
-	 * To detect the final and intermediate braces which affect the nesting
-	 * depth, we scan the input as if it was a tmux config file, and ignore
-	 * braces which would be considered quoted, escaped, or in a comment.
-	 *
-	 * We update the token state after every character because '#' begins a
-	 * comment only when it begins a token. For simplicity, we treat an
-	 * unquoted directive format as comment.
-	 *
-	 * The result is verbatim copy of the input excluding the final brace.
-	 */
-
-	for (ch = yylex_getc1(); ch != EOF; ch = yylex_getc1()) {
-		yylex_append1(buf, len, ch);
-		if (ch == '\n')
-			lines++;
-
-		/*
-		 * If the previous character was a backslash (escape is set),
-		 * escape anything if unquoted or in double quotes, otherwise
-		 * escape only '\n' and '\\'.
-		 */
-		if (escape &&
-		    (quote == '\0' ||
-		    quote == '"' ||
-		    ch == '\n' ||
-		    ch == '\\')) {
-			escape = 0;
-			if (ch != '\n')
-				token = 1;
-			continue;
-		}
-
-		/*
-		 * The character is not escaped. If it is a backslash, set the
-		 * escape flag.
-		 */
-		if (ch == '\\') {
-			escape = 1;
-			continue;
-		}
-		escape = 0;
-
-		/* A newline always resets to unquoted. */
-		if (ch == '\n') {
-			quote = token = 0;
-			continue;
-		}
-
-		if (quote) {
-			/*
-			 * Inside quotes or comment. Check if this is the
-			 * closing quote.
-			 */
-			if (ch == quote && quote != '#')
-				quote = 0;
-			token = 1;  /* token continues regardless */
-		} else {
-			/* Not inside quotes or comment. */
-			switch (ch) {
-			case '"':
-			case '\'':
-			case '#':
-				/* Beginning of quote or maybe comment. */
-				if (ch != '#' || !token)
-					quote = ch;
-				token = 1;
-				break;
-			case ' ':
-			case '\t':
-			case ';':
-				/* Delimiter - token resets. */
-				token = 0;
-				break;
-			case '{':
-				nesting++;
-				token = 0; /* new commands set - token resets */
-				break;
-			case '}':
-				nesting--;
-				token = 1;  /* same as after quotes */
-				if (nesting == 0) {
-					(*len)--; /* remove closing } */
-					ps->input->line += lines;
-					return (1);
-				}
-				break;
-			default:
-				token = 1;
-				break;
-			}
-		}
-	}
-
-	/*
-	 * Update line count after error as reporting the opening line is more
-	 * useful than EOF.
-	 */
-	yyerror("unterminated brace string");
-	ps->input->line += lines;
-	return (0);
-}
-
 static char *
 yylex_token(int ch)
 {
@@ -1480,23 +1496,37 @@ yylex_token(int ch)
 	buf = xmalloc(1);
 
 	for (;;) {
-		/*
+		/* EOF or \n are always the end of the token. */
-		 * EOF or \n are always the end of the token. If inside quotes
+		if (ch == EOF || (state == NONE && ch == '\n'))
-		 * they are an error.
-		 */
-		if (ch == EOF || ch == '\n') {
-			if (state != NONE)
-				goto error;
 			break;
+
+		/* Whitespace or ; or } ends a token unless inside quotes. */
+		if ((ch == ' ' || ch == '\t' || ch == ';' || ch == '}') &&
+		    state == NONE)
+			break;
+
+		/*
+		 * Spaces and comments inside quotes after \n are removed but
+		 * the \n is left.
+		 */
+		if (ch == '\n' && state != NONE) {
+			yylex_append1(&buf, &len, '\n');
+			while ((ch = yylex_getc()) == ' ' || ch == '\t')
+				/* nothing */;
+			if (ch != '#')
+				continue;
+			ch = yylex_getc();
+			if (strchr(",#{}:", ch) != NULL) {
+				yylex_ungetc(ch);
+				ch = '#';
+			} else {
+				while ((ch = yylex_getc()) != '\n' && ch != EOF)
+					/* nothing */;
+			}
+			continue;
 		}
 
-		/* Whitespace or ; ends a token unless inside quotes. */
+		/* \ ~ and $ are expanded except in single quotes. */
-		if ((ch == ' ' || ch == '\t' || ch == ';') && state == NONE)
-			break;
-
-		/*
-		 * \ ~ and $ are expanded except in single quotes.
-		 */
 		if (ch == '\\' && state != SINGLE_QUOTES) {
 			if (!yylex_token_escape(&buf, &len))
 				goto error;
@@ -1512,17 +1542,10 @@ yylex_token(int ch)
 				goto error;
 			goto skip;
 		}
-		if (ch == '{' && state == NONE) {
-			if (!yylex_token_brace(&buf, &len))
-				goto error;
-			goto skip;
-		}
 		if (ch == '}' && state == NONE)
 			goto error;  /* unmatched (matched ones were handled) */
 
-		/*
+		/* ' and " starts or end quotes (and is consumed). */
-		 * ' and " starts or end quotes (and is consumed).
-		 */
 		if (ch == '\'') {
 			if (state == NONE) {
 				state = SINGLE_QUOTES;
@@ -1544,9 +1567,7 @@ yylex_token(int ch)
 			}
 		}
 
-		/*
+		/* Otherwise add the character to the buffer. */
-		 * Otherwise add the character to the buffer.
-		 */
 		yylex_append1(&buf, &len, ch);
 
 	skip:

cmd-paste-buffer.c

@@ -46,8 +46,9 @@ const struct cmd_entry cmd_paste_buffer_entry = {
 static enum cmd_retval
 cmd_paste_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct window_pane	*wp = item->target.wp;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct window_pane	*wp = target->wp;
 	struct paste_buffer	*pb;
 	const char		*sepstr, *bufname, *bufdata, *bufend, *line;
 	size_t			 seplen, bufsize;

cmd-pipe-pane.c

@@ -55,15 +55,17 @@ const struct cmd_entry cmd_pipe_pane_entry = {
 static enum cmd_retval
 cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args			*args = cmd_get_args(self);
-	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct window_pane	*wp = item->target.wp;
+	struct client			*tc = cmdq_get_target_client(item);
-	struct session		*s = item->target.s;
+	struct window_pane		*wp = target->wp;
-	struct winlink		*wl = item->target.wl;
+	struct session			*s = target->s;
-	char			*cmd;
+	struct winlink			*wl = target->wl;
-	int			 old_fd, pipe_fd[2], null_fd, in, out;
+	struct window_pane_offset	*wpo = &wp->pipe_offset;
-	struct format_tree	*ft;
+	char				*cmd;
-	sigset_t		 set, oldset;
+	int				 old_fd, pipe_fd[2], null_fd, in, out;
+	struct format_tree		*ft;
+	sigset_t			 set, oldset;
 
 	/* Destroy the old pipe. */
 	old_fd = wp->pipe_fd;
@@ -88,13 +90,13 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 	 *
 	 *	bind ^p pipep -o 'cat >>~/output'
 	 */
-	if (args_has(self->args, 'o') && old_fd != -1)
+	if (args_has(args, 'o') && old_fd != -1)
 		return (CMD_RETURN_NORMAL);
 
 	/* What do we want to do? Neither -I or -O is -O. */
-	if (args_has(self->args, 'I')) {
+	if (args_has(args, 'I')) {
 		in = 1;
-		out = args_has(self->args, 'O');
+		out = args_has(args, 'O');
 	} else {
 		in = 0;
 		out = 1;
@@ -107,8 +109,8 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	/* Expand the command. */
-	ft = format_create(item->client, item, FORMAT_NONE, 0);
+	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-	format_defaults(ft, c, s, wl, wp);
+	format_defaults(ft, tc, s, wl, wp);
 	cmd = format_expand_time(ft, args->argv[0]);
 	format_free(ft);
 
@@ -157,10 +159,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 		close(pipe_fd[1]);
 
 		wp->pipe_fd = pipe_fd[0];
-		if (wp->fd != -1)
+		memcpy(wpo, &wp->offset, sizeof *wpo);
-			wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
-		else
-			wp->pipe_off = 0;
 
 		setblocking(wp->pipe_fd, 0);
 		wp->pipe_event = bufferevent_new(wp->pipe_fd,

cmd-queue.c

@@ -25,8 +25,69 @@
 
 #include "tmux.h"
 
-/* Global command queue. */
+/* Command queue flags. */
-static struct cmdq_list global_queue = TAILQ_HEAD_INITIALIZER(global_queue);
+#define CMDQ_FIRED 0x1
+#define CMDQ_WAITING 0x2
+
+/* Command queue item type. */
+enum cmdq_type {
+	CMDQ_COMMAND,
+	CMDQ_CALLBACK,
+};
+
+/* Command queue item. */
+struct cmdq_item {
+	char			*name;
+	struct cmdq_list	*queue;
+	struct cmdq_item	*next;
+
+	struct client		*client;
+	struct client		*target_client;
+
+	enum cmdq_type		 type;
+	u_int			 group;
+
+	u_int			 number;
+	time_t			 time;
+
+	int			 flags;
+
+	struct cmdq_state	*state;
+	struct cmd_find_state	 source;
+	struct cmd_find_state	 target;
+
+	struct cmd_list		*cmdlist;
+	struct cmd		*cmd;
+
+	cmdq_cb			 cb;
+	void			*data;
+
+	TAILQ_ENTRY(cmdq_item)	 entry;
+};
+TAILQ_HEAD(cmdq_item_list, cmdq_item);
+
+/*
+ * Command queue state. This is the context for commands on the command queue.
+ * It holds information about how the commands were fired (the key and flags),
+ * any additional formats for the commands, and the current default target.
+ * Multiple commands can share the same state and a command may update the
+ * default target.
+ */
+struct cmdq_state {
+	int			 references;
+	int			 flags;
+
+	struct format_tree	*formats;
+
+	struct key_event	 event;
+	struct cmd_find_state	 current;
+};
+
+/* Command queue. */
+struct cmdq_list {
+	struct cmdq_item	*item;
+	struct cmdq_item_list	 list;
+};
 
 /* Get command queue name. */
 static const char *
@@ -47,9 +108,179 @@ cmdq_name(struct client *c)
 static struct cmdq_list *
 cmdq_get(struct client *c)
 {
-	if (c == NULL)
+	static struct cmdq_list *global_queue;
-		return (&global_queue);
+
-	return (&c->queue);
+	if (c == NULL) {
+		if (global_queue == NULL)
+			global_queue = cmdq_new();
+		return (global_queue);
+	}
+	return (c->queue);
+}
+
+/* Create a queue. */
+struct cmdq_list *
+cmdq_new(void)
+{
+	struct cmdq_list	*queue;
+
+	queue = xcalloc (1, sizeof *queue);
+	TAILQ_INIT (&queue->list);
+	return (queue);
+}
+
+/* Free a queue. */
+void
+cmdq_free(struct cmdq_list *queue)
+{
+	if (!TAILQ_EMPTY(&queue->list))
+		fatalx("queue not empty");
+	free(queue);
+}
+
+/* Get item name. */
+const char *
+cmdq_get_name(struct cmdq_item *item)
+{
+	return (item->name);
+}
+
+/* Get item client. */
+struct client *
+cmdq_get_client(struct cmdq_item *item)
+{
+	return (item->client);
+}
+
+/* Get item target client. */
+struct client *
+cmdq_get_target_client(struct cmdq_item *item)
+{
+	return (item->target_client);
+}
+
+/* Get item state. */
+struct cmdq_state *
+cmdq_get_state(struct cmdq_item *item)
+{
+	return (item->state);
+}
+
+/* Get item target. */
+struct cmd_find_state *
+cmdq_get_target(struct cmdq_item *item)
+{
+	return (&item->target);
+}
+
+/* Get item source. */
+struct cmd_find_state *
+cmdq_get_source(struct cmdq_item *item)
+{
+	return (&item->source);
+}
+
+/* Get state event. */
+struct key_event *
+cmdq_get_event(struct cmdq_item *item)
+{
+	return (&item->state->event);
+}
+
+/* Get state current target. */
+struct cmd_find_state *
+cmdq_get_current(struct cmdq_item *item)
+{
+	return (&item->state->current);
+}
+
+/* Get state flags. */
+int
+cmdq_get_flags(struct cmdq_item *item)
+{
+	return (item->state->flags);
+}
+
+/* Create a new state. */
+struct cmdq_state *
+cmdq_new_state(struct cmd_find_state *current, struct key_event *event,
+    int flags)
+{
+	struct cmdq_state	*state;
+
+	state = xcalloc(1, sizeof *state);
+	state->references = 1;
+	state->flags = flags;
+
+	if (event != NULL)
+		memcpy(&state->event, event, sizeof state->event);
+	else
+		state->event.key = KEYC_NONE;
+	if (current != NULL && cmd_find_valid_state(current))
+		cmd_find_copy_state(&state->current, current);
+	else
+		cmd_find_clear_state(&state->current, 0);
+
+	return (state);
+}
+
+/* Add a reference to a state. */
+struct cmdq_state *
+cmdq_link_state(struct cmdq_state *state)
+{
+	state->references++;
+	return (state);
+}
+
+/* Make a copy of a state. */
+struct cmdq_state *
+cmdq_copy_state(struct cmdq_state *state)
+{
+	return (cmdq_new_state(&state->current, &state->event, state->flags));
+}
+
+/* Free a state. */
+void
+cmdq_free_state(struct cmdq_state *state)
+{
+	if (--state->references != 0)
+		return;
+
+	if (state->formats != NULL)
+		format_free(state->formats);
+	free(state);
+}
+
+/* Add a format to command queue. */
+void
+cmdq_add_format(struct cmdq_state *state, const char *key, const char *fmt, ...)
+{
+	va_list	 ap;
+	char	*value;
+
+	va_start(ap, fmt);
+	xvasprintf(&value, fmt, ap);
+	va_end(ap);
+
+	if (state->formats == NULL)
+		state->formats = format_create(NULL, NULL, FORMAT_NONE, 0);
+	format_add(state->formats, key, "%s", value);
+
+	free(value);
+}
+
+/* Merge formats from item. */
+void
+cmdq_merge_formats(struct cmdq_item *item, struct format_tree *ft)
+{
+	const struct cmd_entry	*entry;
+
+	if (item->cmd != NULL) {
+		entry = cmd_get_entry(item->cmd);
+		format_add(ft, "command", "%s", entry->name);
+	}
+	if (item->state->formats != NULL)
+		format_merge(ft, item->state->formats);
 }
 
 /* Append an item. */
@@ -68,12 +299,12 @@ cmdq_append(struct client *c, struct cmdq_item *item)
 		item->client = c;
 
 		item->queue = queue;
-		TAILQ_INSERT_TAIL(queue, item, entry);
+		TAILQ_INSERT_TAIL(&queue->list, item, entry);
 		log_debug("%s %s: %s", __func__, cmdq_name(c), item->name);
 
 		item = next;
 	} while (item != NULL);
-	return (TAILQ_LAST(queue, cmdq_list));
+	return (TAILQ_LAST(&queue->list, cmdq_item_list));
 }
 
 /* Insert an item. */
@@ -94,7 +325,7 @@ cmdq_insert_after(struct cmdq_item *after, struct cmdq_item *item)
 		item->client = c;
 
 		item->queue = queue;
-		TAILQ_INSERT_AFTER(queue, after, item, entry);
+		TAILQ_INSERT_AFTER(&queue->list, after, item, entry);
 		log_debug("%s %s: %s after %s", __func__, cmdq_name(c),
 		    item->name, after->name);
 
@@ -107,17 +338,25 @@ cmdq_insert_after(struct cmdq_item *after, struct cmdq_item *item)
 /* Insert a hook. */
 void
 cmdq_insert_hook(struct session *s, struct cmdq_item *item,
-    struct cmd_find_state *fs, const char *fmt, ...)
+    struct cmd_find_state *current, const char *fmt, ...)
 {
+	struct cmdq_state		*state = item->state;
+	struct cmd			*cmd = item->cmd;
+	struct args			*args = cmd_get_args(cmd);
+	struct args_entry		*entryp;
+	struct args_value		*valuep;
 	struct options			*oo;
 	va_list				 ap;
-	char				*name;
+	char				*name, tmp[32], flag, *arguments;
+	int				 i;
+	const char			*value;
 	struct cmdq_item		*new_item;
+	struct cmdq_state		*new_state;
 	struct options_entry		*o;
 	struct options_array_item	*a;
 	struct cmd_list			*cmdlist;
 
-	if (item->flags & CMDQ_NOHOOKS)
+	if (item->state->flags & CMDQ_STATE_NOHOOKS)
 		return;
 	if (s == NULL)
 		oo = global_s_options;
@@ -135,24 +374,58 @@ cmdq_insert_hook(struct session *s, struct cmdq_item *item,
 	}
 	log_debug("running hook %s (parent %p)", name, item);
 
+	/*
+	 * The hooks get a new state because they should not update the current
+	 * target or formats for any subsequent commands.
+	 */
+	new_state = cmdq_new_state(current, &state->event, CMDQ_STATE_NOHOOKS);
+	cmdq_add_format(new_state, "hook", "%s", name);
+
+	arguments = args_print(args);
+	cmdq_add_format(new_state, "hook_arguments", "%s", arguments);
+	free(arguments);
+
+	for (i = 0; i < args->argc; i++) {
+		xsnprintf(tmp, sizeof tmp, "hook_argument_%d", i);
+		cmdq_add_format(new_state, tmp, "%s", args->argv[i]);
+	}
+	flag = args_first(args, &entryp);
+	while (flag != 0) {
+		value = args_get(args, flag);
+		if (value == NULL) {
+			xsnprintf(tmp, sizeof tmp, "hook_flag_%c", flag);
+			cmdq_add_format(new_state, tmp, "1");
+		} else {
+			xsnprintf(tmp, sizeof tmp, "hook_flag_%c", flag);
+			cmdq_add_format(new_state, tmp, "%s", value);
+		}
+
+		i = 0;
+		value = args_first_value(args, flag, &valuep);
+		while (value != NULL) {
+			xsnprintf(tmp, sizeof tmp, "hook_flag_%c_%d", flag, i);
+			cmdq_add_format(new_state, tmp, "%s", value);
+			i++;
+			value = args_next_value(&valuep);
+		}
+
+		flag = args_next(&entryp);
+	}
+
 	a = options_array_first(o);
 	while (a != NULL) {
 		cmdlist = options_array_item_value(a)->cmdlist;
-		if (cmdlist == NULL) {
+		if (cmdlist != NULL) {
-			a = options_array_next(a);
+			new_item = cmdq_get_command(cmdlist, new_state);
-			continue;
+			if (item != NULL)
+				item = cmdq_insert_after(item, new_item);
+			else
+				item = cmdq_append(NULL, new_item);
 		}
-
-		new_item = cmdq_get_command(cmdlist, fs, NULL, CMDQ_NOHOOKS);
-		cmdq_format(new_item, "hook", "%s", name);
-		if (item != NULL)
-			item = cmdq_insert_after(item, new_item);
-		else
-			item = cmdq_append(NULL, new_item);
-
 		a = options_array_next(a);
 	}
 
+	cmdq_free_state(new_state);
 	free(name);
 }
 
@@ -167,19 +440,13 @@ cmdq_continue(struct cmdq_item *item)
 static void
 cmdq_remove(struct cmdq_item *item)
 {
-	if (item->shared != NULL && --item->shared->references == 0) {
-		if (item->shared->formats != NULL)
-			format_free(item->shared->formats);
-		free(item->shared);
-	}
-
 	if (item->client != NULL)
 		server_client_unref(item->client);
-
 	if (item->cmdlist != NULL)
 		cmd_list_free(item->cmdlist);
+	cmdq_free_state(item->state);
 
-	TAILQ_REMOVE(item->queue, item, entry);
+	TAILQ_REMOVE(&item->queue->list, item, entry);
 
 	free(item->name);
 	free(item);
@@ -204,48 +471,46 @@ cmdq_remove_group(struct cmdq_item *item)
 
 /* Get a command for the command queue. */
 struct cmdq_item *
-cmdq_get_command(struct cmd_list *cmdlist, struct cmd_find_state *current,
+cmdq_get_command(struct cmd_list *cmdlist, struct cmdq_state *state)
-    struct mouse_event *m, int flags)
 {
 	struct cmdq_item	*item, *first = NULL, *last = NULL;
 	struct cmd		*cmd;
-	struct cmdq_shared	*shared = NULL;
+	const struct cmd_entry	*entry;
-	u_int			 group = 0;
+	int			 created = 0;
 
-	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+	if (state == NULL) {
-		if (cmd->group != group) {
+		state = cmdq_new_state(NULL, NULL, 0);
-			shared = xcalloc(1, sizeof *shared);
+		created = 1;
-			if (current != NULL)
+	}
-				cmd_find_copy_state(&shared->current, current);
+
-			else
+	cmd = cmd_list_first(cmdlist);
-				cmd_find_clear_state(&shared->current, 0);
+	while (cmd != NULL) {
-			if (m != NULL)
+		entry = cmd_get_entry(cmd);
-				memcpy(&shared->mouse, m, sizeof shared->mouse);
-			group = cmd->group;
-		}
 
 		item = xcalloc(1, sizeof *item);
-		xasprintf(&item->name, "[%s/%p]", cmd->entry->name, item);
+		xasprintf(&item->name, "[%s/%p]", entry->name, item);
 		item->type = CMDQ_COMMAND;
 
-		item->group = cmd->group;
+		item->group = cmd_get_group(cmd);
-		item->flags = flags;
+		item->state = cmdq_link_state(state);
 
-		item->shared = shared;
 		item->cmdlist = cmdlist;
 		item->cmd = cmd;
 
-		log_debug("%s: %s group %u", __func__, item->name, item->group);
-
-		shared->references++;
 		cmdlist->references++;
+		log_debug("%s: %s group %u", __func__, item->name, item->group);
 
 		if (first == NULL)
 			first = item;
 		if (last != NULL)
 			last->next = item;
 		last = item;
+
+		cmd = cmd_list_next(cmd);
 	}
+
+	if (created)
+		cmdq_free_state(state);
 	return (first);
 }
 
@@ -257,11 +522,11 @@ cmdq_find_flag(struct cmdq_item *item, struct cmd_find_state *fs,
 	const char	*value;
 
 	if (flag->flag == 0) {
-		cmd_find_clear_state(fs, 0);
+		cmd_find_from_client(fs, item->target_client, 0);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	value = args_get(item->cmd->args, flag->flag);
+	value = args_get(cmd_get_args(item->cmd), flag->flag);
 	if (cmd_find_target(fs, item, value, flag->type, flag->flags) != 0) {
 		cmd_find_clear_state(fs, 0);
 		return (CMD_RETURN_ERROR);
@@ -269,31 +534,75 @@ cmdq_find_flag(struct cmdq_item *item, struct cmd_find_state *fs,
 	return (CMD_RETURN_NORMAL);
 }
 
+/* Add message with command. */
+static void
+cmdq_add_message(struct cmdq_item *item)
+{
+	struct client		*c = item->client;
+	struct cmdq_state	*state = item->state;
+	const char		*name, *key;
+	char			*tmp;
+
+	tmp = cmd_print(item->cmd);
+	if (c != NULL) {
+		name = c->name;
+		if (c->session != NULL && state->event.key != KEYC_NONE) {
+			key = key_string_lookup_key(state->event.key, 0);
+			server_add_message("%s key %s: %s", name, key, tmp);
+		} else
+			server_add_message("%s command: %s", name, tmp);
+	} else
+		server_add_message("command: %s", tmp);
+	free(tmp);
+}
+
 /* Fire command on command queue. */
 static enum cmd_retval
 cmdq_fire_command(struct cmdq_item *item)
 {
-	struct client		*c = item->client;
+	const char		*name = cmdq_name(item->client);
-	const char		*name = cmdq_name(c);
+	struct cmdq_state	*state = item->state;
-	struct cmdq_shared	*shared = item->shared;
 	struct cmd		*cmd = item->cmd;
-	const struct cmd_entry	*entry = cmd->entry;
+	struct args		*args = cmd_get_args(cmd);
+	const struct cmd_entry	*entry = cmd_get_entry(cmd);
+	struct client		*tc, *saved = item->client;
 	enum cmd_retval		 retval;
 	struct cmd_find_state	*fsp, fs;
-	int			 flags;
+	int			 flags, quiet = 0;
 	char			*tmp;
 
+	if (cfg_finished)
+		cmdq_add_message(item);
 	if (log_get_level() > 1) {
 		tmp = cmd_print(cmd);
 		log_debug("%s %s: (%u) %s", __func__, name, item->group, tmp);
 		free(tmp);
 	}
 
-	flags = !!(shared->flags & CMDQ_SHARED_CONTROL);
+	flags = !!(state->flags & CMDQ_STATE_CONTROL);
 	cmdq_guard(item, "begin", flags);
 
 	if (item->client == NULL)
 		item->client = cmd_find_client(item, NULL, 1);
+
+	if (entry->flags & CMD_CLIENT_CANFAIL)
+		quiet = 1;
+	if (entry->flags & CMD_CLIENT_CFLAG) {
+		tc = cmd_find_client(item, args_get(args, 'c'), quiet);
+		if (tc == NULL && !quiet) {
+			retval = CMD_RETURN_ERROR;
+			goto out;
+		}
+	} else if (entry->flags & CMD_CLIENT_TFLAG) {
+		tc = cmd_find_client(item, args_get(args, 't'), quiet);
+		if (tc == NULL && !quiet) {
+			retval = CMD_RETURN_ERROR;
+			goto out;
+		}
+	} else
+		tc = cmd_find_client(item, NULL, 1);
+	item->target_client = tc;
+
 	retval = cmdq_find_flag(item, &item->source, &entry->source);
 	if (retval == CMD_RETURN_ERROR)
 		goto out;
@@ -308,8 +617,8 @@ cmdq_fire_command(struct cmdq_item *item)
 	if (entry->flags & CMD_AFTERHOOK) {
 		if (cmd_find_valid_state(&item->target))
 			fsp = &item->target;
-		else if (cmd_find_valid_state(&item->shared->current))
+		else if (cmd_find_valid_state(&item->state->current))
-			fsp = &item->shared->current;
+			fsp = &item->state->current;
 		else if (cmd_find_from_client(&fs, item->client, 0) == 0)
 			fsp = &fs;
 		else
@@ -318,7 +627,7 @@ cmdq_fire_command(struct cmdq_item *item)
 	}
 
 out:
-	item->client = c;
+	item->client = saved;
 	if (retval == CMD_RETURN_ERROR)
 		cmdq_guard(item, "error", flags);
 	else
@@ -337,7 +646,7 @@ cmdq_get_callback1(const char *name, cmdq_cb cb, void *data)
 	item->type = CMDQ_CALLBACK;
 
 	item->group = 0;
-	item->flags = 0;
+	item->state = cmdq_new_state(NULL, NULL, 0);
 
 	item->cb = cb;
 	item->data = data;
@@ -371,25 +680,6 @@ cmdq_fire_callback(struct cmdq_item *item)
 	return (item->cb(item, item->data));
 }
 
-/* Add a format to command queue. */
-void
-cmdq_format(struct cmdq_item *item, const char *key, const char *fmt, ...)
-{
-	struct cmdq_shared	*shared = item->shared;
-	va_list			 ap;
-	char			*value;
-
-	va_start(ap, fmt);
-	xvasprintf(&value, fmt, ap);
-	va_end(ap);
-
-	if (shared->formats == NULL)
-		shared->formats = format_create(NULL, NULL, FORMAT_NONE, 0);
-	format_add(shared->formats, key, "%s", value);
-
-	free(value);
-}
-
 /* Process next item on command queue. */
 u_int
 cmdq_next(struct client *c)
@@ -401,18 +691,18 @@ cmdq_next(struct client *c)
 	u_int			 items = 0;
 	static u_int		 number;
 
-	if (TAILQ_EMPTY(queue)) {
+	if (TAILQ_EMPTY(&queue->list)) {
 		log_debug("%s %s: empty", __func__, name);
 		return (0);
 	}
-	if (TAILQ_FIRST(queue)->flags & CMDQ_WAITING) {
+	if (TAILQ_FIRST(&queue->list)->flags & CMDQ_WAITING) {
 		log_debug("%s %s: waiting", __func__, name);
 		return (0);
 	}
 
 	log_debug("%s %s: enter", __func__, name);
 	for (;;) {
-		item = TAILQ_FIRST(queue);
+		item = queue->item = TAILQ_FIRST(&queue->list);
 		if (item == NULL)
 			break;
 		log_debug("%s %s: %s (%d), flags %x", __func__, name,
@@ -462,6 +752,7 @@ cmdq_next(struct client *c)
 		}
 		cmdq_remove(item);
 	}
+	queue->item = NULL;
 
 	log_debug("%s %s: exit (empty)", __func__, name);
 	return (items);
@@ -471,6 +762,19 @@ waiting:
 	return (items);
 }
 
+/* Get running item if any. */
+struct cmdq_item *
+cmdq_running(struct client *c)
+{
+	struct cmdq_list	*queue = cmdq_get(c);
+
+	if (queue->item == NULL)
+        return (NULL);
+    if (queue->item->flags & CMDQ_WAITING)
+        return (NULL);
+    return (queue->item);
+}
+
 /* Print a guard line. */
 void
 cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
@@ -480,7 +784,7 @@ cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
 	u_int		 number = item->number;
 
 	if (c != NULL && (c->flags & CLIENT_CONTROL))
-		file_print(c, "%%%s %ld %u %d\n", guard, t, number, flags);
+		control_write(c, "%%%s %ld %u %d", guard, t, number, flags);
 }
 
 /* Show message from command. */
@@ -507,12 +811,17 @@ cmdq_print(struct cmdq_item *item, const char *fmt, ...)
 			msg = utf8_sanitize(tmp);
 			free(tmp);
 		}
-		file_print(c, "%s\n", msg);
+		if (c->flags & CLIENT_CONTROL)
+			control_write(c, "%s", msg);
+		else
+			file_print(c, "%s\n", msg);
 	} else {
-		wp = c->session->curw->window->active;
+		wp = server_client_get_pane(c);
 		wme = TAILQ_FIRST(&wp->modes);
-		if (wme == NULL || wme->mode != &window_view_mode)
+		if (wme == NULL || wme->mode != &window_view_mode) {
-			window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
+			window_pane_set_mode(wp, NULL, &window_view_mode, NULL,
+			    NULL);
+		}
 		window_copy_add(wp, "%s", msg);
 	}
 
@@ -526,8 +835,9 @@ cmdq_error(struct cmdq_item *item, const char *fmt, ...)
 	struct client	*c = item->client;
 	struct cmd	*cmd = item->cmd;
 	va_list		 ap;
-	char		*msg;
+	char		*msg, *tmp;
-	char		*tmp;
+	const char	*file;
+	u_int		 line;
 
 	va_start(ap, fmt);
 	xvasprintf(&msg, fmt, ap);
@@ -535,22 +845,24 @@ cmdq_error(struct cmdq_item *item, const char *fmt, ...)
 
 	log_debug("%s: %s", __func__, msg);
 
-	if (c == NULL)
+	if (c == NULL) {
-		cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
+		cmd_get_source(cmd, &file, &line);
-	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
+		cfg_add_cause("%s:%u: %s", file, line, msg);
+	} else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
+		server_add_message("%s message: %s", c->name, msg);
 		if (~c->flags & CLIENT_UTF8) {
 			tmp = msg;
 			msg = utf8_sanitize(tmp);
 			free(tmp);
 		}
 		if (c->flags & CLIENT_CONTROL)
-			file_print(c, "%s\n", msg);
+			control_write(c, "%s", msg);
 		else
 			file_error(c, "%s\n", msg);
 		c->retval = 1;
 	} else {
 		*msg = toupper((u_char) *msg);
-		status_message_set(c, "%s", msg);
+		status_message_set(c, -1, 1, 0, "%s", msg);
 	}
 
 	free(msg);

cmd-refresh-client.c

@@ -34,28 +34,92 @@ const struct cmd_entry cmd_refresh_client_entry = {
 	.name = "refresh-client",
 	.alias = "refresh",
 
-	.args = { "cC:DF:lLRSt:U", 0, 1 },
+	.args = { "A:B:cC:Df:F:lLRSt:U", 0, 1 },
-	.usage = "[-cDlLRSU] [-C XxY] [-F flags] " CMD_TARGET_CLIENT_USAGE
+	.usage = "[-cDlLRSU] [-A pane:state] [-B name:what:format] "
-		" [adjustment]",
+		 "[-C XxY] [-f flags] " CMD_TARGET_CLIENT_USAGE " [adjustment]",
 
-	.flags = CMD_AFTERHOOK,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
 	.exec = cmd_refresh_client_exec
 };
 
+static void
+cmd_refresh_client_update_subscription(struct client *tc, const char *value)
+{
+	char			*copy, *split, *name, *what;
+	enum control_sub_type	 subtype;
+	int			 subid = -1;
+
+	copy = name = xstrdup(value);
+	if ((split = strchr(copy, ':')) == NULL) {
+		control_remove_sub(tc, copy);
+		goto out;
+	}
+	*split++ = '\0';
+
+	what = split;
+	if ((split = strchr(what, ':')) == NULL)
+		goto out;
+	*split++ = '\0';
+
+	if (strcmp(what, "%*") == 0)
+		subtype = CONTROL_SUB_ALL_PANES;
+	else if (sscanf(what, "%%%d", &subid) == 1 && subid >= 0)
+		subtype = CONTROL_SUB_PANE;
+	else if (strcmp(what, "@*") == 0)
+		subtype = CONTROL_SUB_ALL_WINDOWS;
+	else if (sscanf(what, "@%d", &subid) == 1 && subid >= 0)
+		subtype = CONTROL_SUB_WINDOW;
+	else
+		subtype = CONTROL_SUB_SESSION;
+	control_add_sub(tc, name, subtype, subid, split);
+
+out:
+	free(copy);
+}
+
+static void
+cmd_refresh_client_update_offset(struct client *tc, const char *value)
+{
+	struct window_pane	*wp;
+	char			*copy, *split;
+	u_int			 pane;
+
+	if (*value != '%')
+		return;
+	copy = xstrdup(value);
+	if ((split = strchr(copy, ':')) == NULL)
+		goto out;
+	*split++ = '\0';
+
+	if (sscanf(copy, "%%%u", &pane) != 1)
+		goto out;
+	wp = window_pane_find_by_id(pane);
+	if (wp == NULL)
+		goto out;
+
+	if (strcmp(split, "on") == 0)
+		control_set_pane_on(tc, wp);
+	else if (strcmp(split, "off") == 0)
+		control_set_pane_off(tc, wp);
+	else if (strcmp(split, "continue") == 0)
+		control_continue_pane(tc, wp);
+	else if (strcmp(split, "pause") == 0)
+		control_pause_pane(tc, wp);
+
+out:
+	free(copy);
+}
+
 static enum cmd_retval
 cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client	*c;
+	struct client		*tc = cmdq_get_target_client(item);
-	struct tty	*tty;
+	struct tty		*tty = &tc->tty;
-	struct window	*w;
+	struct window		*w;
-	const char	*size, *errstr;
+	const char		*size, *errstr, *value;
-	char		*copy, *next, *s;
+	u_int			 x, y, adjust;
-	u_int		 x, y, adjust;
+	struct args_value	*av;
-
-	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
-	tty = &c->tty;
 
 	if (args_has(args, 'c') ||
 	    args_has(args, 'L') ||
@@ -74,88 +138,99 @@ cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 		}
 
 		if (args_has(args, 'c'))
-		    c->pan_window = NULL;
+			tc->pan_window = NULL;
 		else {
-			w = c->session->curw->window;
+			w = tc->session->curw->window;
-			if (c->pan_window != w) {
+			if (tc->pan_window != w) {
-				c->pan_window = w;
+				tc->pan_window = w;
-				c->pan_ox = tty->oox;
+				tc->pan_ox = tty->oox;
-				c->pan_oy = tty->ooy;
+				tc->pan_oy = tty->ooy;
 			}
 			if (args_has(args, 'L')) {
-				if (c->pan_ox > adjust)
+				if (tc->pan_ox > adjust)
-					c->pan_ox -= adjust;
+					tc->pan_ox -= adjust;
 				else
-					c->pan_ox = 0;
+					tc->pan_ox = 0;
 			} else if (args_has(args, 'R')) {
-				c->pan_ox += adjust;
+				tc->pan_ox += adjust;
-				if (c->pan_ox > w->sx - tty->osx)
+				if (tc->pan_ox > w->sx - tty->osx)
-					c->pan_ox = w->sx - tty->osx;
+					tc->pan_ox = w->sx - tty->osx;
 			} else if (args_has(args, 'U')) {
-				if (c->pan_oy > adjust)
+				if (tc->pan_oy > adjust)
-					c->pan_oy -= adjust;
+					tc->pan_oy -= adjust;
 				else
-					c->pan_oy = 0;
+					tc->pan_oy = 0;
 			} else if (args_has(args, 'D')) {
-				c->pan_oy += adjust;
+				tc->pan_oy += adjust;
-				if (c->pan_oy > w->sy - tty->osy)
+				if (tc->pan_oy > w->sy - tty->osy)
-					c->pan_oy = w->sy - tty->osy;
+					tc->pan_oy = w->sy - tty->osy;
 			}
 		}
-		tty_update_client_offset(c);
+		tty_update_client_offset(tc);
-		server_redraw_client(c);
+		server_redraw_client(tc);
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (args_has(args, 'l')) {
-		if (c->session != NULL)
+		tty_putcode_ptr2(&tc->tty, TTYC_MS, "", "?");
-			tty_putcode_ptr2(&c->tty, TTYC_MS, "", "?");
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(args, 'C') || args_has(args, 'F')) {
+	if (args_has(args, 'F')) /* -F is an alias for -f */
-		if (args_has(args, 'C')) {
+		server_client_set_flags(tc, args_get(args, 'F'));
-			if (!(c->flags & CLIENT_CONTROL)) {
+	if (args_has(args, 'f'))
-				cmdq_error(item, "not a control client");
+		server_client_set_flags(tc, args_get(args, 'f'));
-				return (CMD_RETURN_ERROR);
+
-			}
+	if (args_has(args, 'A')) {
-			size = args_get(args, 'C');
+		if (~tc->flags & CLIENT_CONTROL)
-			if (sscanf(size, "%u,%u", &x, &y) != 2 &&
+			goto not_control_client;
-			    sscanf(size, "%ux%u", &x, &y) != 2) {
+		value = args_first_value(args, 'A', &av);
-				cmdq_error(item, "bad size argument");
+		while (value != NULL) {
-				return (CMD_RETURN_ERROR);
+			cmd_refresh_client_update_offset(tc, value);
-			}
+			value = args_next_value(&av);
-			if (x < WINDOW_MINIMUM || x > WINDOW_MAXIMUM ||
-			    y < WINDOW_MINIMUM || y > WINDOW_MAXIMUM) {
-				cmdq_error(item, "size too small or too big");
-				return (CMD_RETURN_ERROR);
-			}
-			tty_set_size(&c->tty, x, y, 0, 0);
-			c->flags |= CLIENT_SIZECHANGED;
-			recalculate_sizes();
 		}
-		if (args_has(args, 'F')) {
+		return (CMD_RETURN_NORMAL);
-			if (!(c->flags & CLIENT_CONTROL)) {
+	}
-				cmdq_error(item, "not a control client");
+	if (args_has(args, 'B')) {
-				return (CMD_RETURN_ERROR);
+		if (~tc->flags & CLIENT_CONTROL)
-			}
+			goto not_control_client;
-			s = copy = xstrdup(args_get(args, 'F'));
+		value = args_first_value(args, 'B', &av);
-			while ((next = strsep(&s, ",")) != NULL) {
+		while (value != NULL) {
-				/* Unknown flags are ignored. */
+			cmd_refresh_client_update_subscription(tc, value);
-				if (strcmp(next, "no-output") == 0)
+			value = args_next_value(&av);
-					c->flags |= CLIENT_CONTROL_NOOUTPUT;
-			}
-			free(copy);
 		}
 		return (CMD_RETURN_NORMAL);
 	}
+	if (args_has(args, 'C')) {
+		if (~tc->flags & CLIENT_CONTROL)
+			goto not_control_client;
+		size = args_get(args, 'C');
+		if (sscanf(size, "%u,%u", &x, &y) != 2 &&
+		    sscanf(size, "%ux%u", &x, &y) != 2) {
+			cmdq_error(item, "bad size argument");
+			return (CMD_RETURN_ERROR);
+		}
+		if (x < WINDOW_MINIMUM || x > WINDOW_MAXIMUM ||
+		    y < WINDOW_MINIMUM || y > WINDOW_MAXIMUM) {
+			cmdq_error(item, "size too small or too big");
+			return (CMD_RETURN_ERROR);
+		}
+		tty_set_size(&tc->tty, x, y, 0, 0);
+		tc->flags |= CLIENT_SIZECHANGED;
+		recalculate_sizes_now(1);
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (args_has(args, 'S')) {
-		c->flags |= CLIENT_STATUSFORCE;
+		tc->flags |= CLIENT_STATUSFORCE;
-		server_status_client(c);
+		server_status_client(tc);
 	} else {
-		c->flags |= CLIENT_STATUSFORCE;
+		tc->flags |= CLIENT_STATUSFORCE;
-		server_redraw_client(c);
+		server_redraw_client(tc);
 	}
 	return (CMD_RETURN_NORMAL);
+
+not_control_client:
+	cmdq_error(item, "not a control client");
+	return (CMD_RETURN_ERROR);
 }

cmd-rename-session.c

@@ -46,22 +46,18 @@ const struct cmd_entry cmd_rename_session_entry = {
 static enum cmd_retval
 cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = item->target.s;
+	struct session		*s = target->s;
-	char			*newname;
+	char			*newname, *tmp;
 
-	newname = format_single(item, args->argv[0], c, s, NULL, NULL);
+	tmp = format_single_from_target(item, args->argv[0]);
+	newname = session_check_name(tmp);
+	free(tmp);
 	if (strcmp(newname, s->name) == 0) {
 		free(newname);
 		return (CMD_RETURN_NORMAL);
 	}
-
-	if (!session_check_name(newname)) {
-		cmdq_error(item, "bad session name: %s", newname);
-		free(newname);
-		return (CMD_RETURN_ERROR);
-	}
 	if (session_find(newname) != NULL) {
 		cmdq_error(item, "duplicate session: %s", newname);
 		free(newname);

cmd-rename-window.c

@@ -45,16 +45,16 @@ const struct cmd_entry cmd_rename_window_entry = {
 static enum cmd_retval
 cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client	*c = cmd_find_client(item, NULL, 1);
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session	*s = item->target.s;
+	struct winlink		*wl = target->wl;
-	struct winlink	*wl = item->target.wl;
+	char			*newname;
-	char		*newname;
 
-	newname = format_single(item, args->argv[0], c, s, wl, NULL);
+	newname = format_single_from_target(item, args->argv[0]);
 	window_set_name(wl->window, newname);
 	options_set_number(wl->window->options, "automatic-rename", 0);
 
+	server_redraw_window_borders(wl->window);
 	server_status_window(wl->window);
 	free(newname);
 

cmd-resize-pane.c

@@ -36,8 +36,8 @@ const struct cmd_entry cmd_resize_pane_entry = {
 	.name = "resize-pane",
 	.alias = "resizep",
 
-	.args = { "DLMRt:Ux:y:Z", 0, 1 },
+	.args = { "DLMRTt:Ux:y:Z", 0, 1 },
-	.usage = "[-DLMRUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE " "
+	.usage = "[-DLMRTUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE " "
 		 "[adjustment]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -49,26 +49,39 @@ const struct cmd_entry cmd_resize_pane_entry = {
 static enum cmd_retval
 cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct cmdq_shared	*shared = item->shared;
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct window_pane	*wp = item->target.wp;
+	struct key_event	*event = cmdq_get_event(item);
-	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = target->wp;
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
-	struct client		*c = item->client;
+	struct client		*c = cmdq_get_client(item);
-	struct session		*s = item->target.s;
+	struct session		*s = target->s;
-	const char	       	*errstr, *p;
+	const char	       	*errstr;
-	char			*cause, *copy;
+	char			*cause;
 	u_int			 adjust;
-	int			 x, y, percentage;
+	int			 x, y;
-	size_t			 plen;
+	struct grid		*gd = wp->base.grid;
+
+	if (args_has(args, 'T')) {
+		if (!TAILQ_EMPTY(&wp->modes))
+			return (CMD_RETURN_NORMAL);
+		adjust = screen_size_y(&wp->base) - 1 - wp->base.cy;
+		if (adjust > gd->hsize)
+			adjust = gd->hsize;
+		grid_remove_history(gd, adjust);
+		wp->base.cy += adjust;
+		wp->flags |= PANE_REDRAW;
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (args_has(args, 'M')) {
-		if (cmd_mouse_window(&shared->mouse, &s) == NULL)
+		if (!event->m.valid || cmd_mouse_window(&event->m, &s) == NULL)
 			return (CMD_RETURN_NORMAL);
 		if (c == NULL || c->session != s)
 			return (CMD_RETURN_NORMAL);
 		c->tty.mouse_drag_update = cmd_resize_pane_mouse_update;
-		cmd_resize_pane_mouse_update(c, &shared->mouse);
+		cmd_resize_pane_mouse_update(c, &event->m);
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -78,7 +91,6 @@ cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 		else
 			window_zoom(wp);
 		server_redraw_window(w);
-		server_status_window(w);
 		return (CMD_RETURN_NORMAL);
 	}
 	server_unzoom_window(w);
@@ -93,58 +105,21 @@ cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 		}
 	}
 
-	if ((p = args_get(args, 'x')) != NULL) {
+	if (args_has(args, 'x')) {
-		plen = strlen(p);
+		x = args_percentage(args, 'x', 0, INT_MAX, w->sx, &cause);
-		if (p[plen - 1] == '%') {
+		if (cause != NULL) {
-			copy = xstrdup(p);
+			cmdq_error(item, "width %s", cause);
-			copy[plen - 1] = '\0';
+			free(cause);
-			percentage = strtonum(copy, 0, INT_MAX, &errstr);
+			return (CMD_RETURN_ERROR);
-			free(copy);
-			if (errstr != NULL) {
-				cmdq_error(item, "width %s", errstr);
-				return (CMD_RETURN_ERROR);
-			}
-			x = (w->sx * percentage) / 100;
-			if (x < PANE_MINIMUM)
-				x = PANE_MINIMUM;
-			if (x > INT_MAX)
-				x = INT_MAX;
-		} else {
-			x = args_strtonum(args, 'x', PANE_MINIMUM, INT_MAX,
-			    &cause);
-			if (cause != NULL) {
-				cmdq_error(item, "width %s", cause);
-				free(cause);
-				return (CMD_RETURN_ERROR);
-			}
 		}
 		layout_resize_pane_to(wp, LAYOUT_LEFTRIGHT, x);
 	}
-	if ((p = args_get(args, 'y')) != NULL) {
+	if (args_has(args, 'y')) {
-		plen = strlen(p);
+		y = args_percentage(args, 'y', 0, INT_MAX, w->sy, &cause);
-		if (p[plen - 1] == '%') {
+		if (cause != NULL) {
-			copy = xstrdup(p);
+			cmdq_error(item, "height %s", cause);
-			copy[plen - 1] = '\0';
+			free(cause);
-			percentage = strtonum(copy, 0, INT_MAX, &errstr);
+			return (CMD_RETURN_ERROR);
-			free(copy);
-			if (errstr != NULL) {
-				cmdq_error(item, "height %s", errstr);
-				return (CMD_RETURN_ERROR);
-			}
-			y = (w->sy * percentage) / 100;
-			if (y < PANE_MINIMUM)
-				y = PANE_MINIMUM;
-			if (y > INT_MAX)
-				y = INT_MAX;
-		}
-		else {
-			y = args_strtonum(args, 'y', PANE_MINIMUM, INT_MAX,
-			    &cause);
-			if (cause != NULL) {
-				cmdq_error(item, "height %s", cause);
-				free(cause);
-				return (CMD_RETURN_ERROR);
-			}
 		}
 		layout_resize_pane_to(wp, LAYOUT_TOPBOTTOM, y);
 	}

cmd-resize-window.c

@@ -46,10 +46,11 @@ const struct cmd_entry cmd_resize_window_entry = {
 static enum cmd_retval
 cmd_resize_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct winlink		*wl = item->target.wl;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
-	struct session		*s = item->target.s;
+	struct session		*s = target->s;
 	const char	       	*errstr;
 	char			*cause;
 	u_int			 adjust, sx, sy;

cmd-respawn-pane.c

@@ -47,11 +47,12 @@ const struct cmd_entry cmd_respawn_pane_entry = {
 static enum cmd_retval
 cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct spawn_context	 sc;
-	struct session		*s = item->target.s;
+	struct session		*s = target->s;
-	struct winlink		*wl = item->target.wl;
+	struct winlink		*wl = target->wl;
-	struct window_pane	*wp = item->target.wp;
+	struct window_pane	*wp = target->wp;
 	char			*cause = NULL;
 	const char		*add;
 	struct args_value	*value;
@@ -71,7 +72,7 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 
 	add = args_first_value(args, 'e', &value);
 	while (add != NULL) {
-		environ_put(sc.environ, add);
+		environ_put(sc.environ, add, 0);
 		add = args_next_value(&value);
 	}
 
@@ -89,6 +90,7 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	wp->flags |= PANE_REDRAW;
+	server_redraw_window_borders(wp->window);
 	server_status_window(wp->window);
 
 	environ_free(sc.environ);

cmd-respawn-window.c

@@ -47,10 +47,12 @@ const struct cmd_entry cmd_respawn_window_entry = {
 static enum cmd_retval
 cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct spawn_context	 sc;
-	struct session		*s = item->target.s;
+	struct client		*tc = cmdq_get_target_client(item);
-	struct winlink		*wl = item->target.wl;
+	struct session		*s = target->s;
+	struct winlink		*wl = target->wl;
 	char			*cause = NULL;
 	const char		*add;
 	struct args_value	*value;
@@ -59,7 +61,7 @@ cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 	sc.item = item;
 	sc.s = s;
 	sc.wl = wl;
-	sc.c = cmd_find_client(item, NULL, 1);
+	sc.tc = tc;
 
 	sc.name = NULL;
 	sc.argc = args->argc;
@@ -68,7 +70,7 @@ cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 
 	add = args_first_value(args, 'e', &value);
 	while (add != NULL) {
-		environ_put(sc.environ, add);
+		environ_put(sc.environ, add, 0);
 		add = args_next_value(&value);
 	}
 

cmd-rotate-window.c

@@ -43,16 +43,18 @@ const struct cmd_entry cmd_rotate_window_entry = {
 static enum cmd_retval
 cmd_rotate_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct cmd_find_state	*current = &item->shared->current;
+	struct args		*args = cmd_get_args(self);
-	struct winlink		*wl = item->target.wl;
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
 	struct window_pane	*wp, *wp2;
 	struct layout_cell	*lc;
 	u_int			 sx, sy, xoff, yoff;
 
-	window_push_zoom(w, args_has(self->args, 'Z'));
+	window_push_zoom(w, 0, args_has(args, 'Z'));
 
-	if (args_has(self->args, 'D')) {
+	if (args_has(args, 'D')) {
 		wp = TAILQ_LAST(&w->panes, window_panes);
 		TAILQ_REMOVE(&w->panes, wp, entry);
 		TAILQ_INSERT_HEAD(&w->panes, wp, entry);

cmd-run-shell.c

@@ -20,6 +20,7 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -31,6 +32,7 @@
 
 static enum cmd_retval	cmd_run_shell_exec(struct cmd *, struct cmdq_item *);
 
+static void	cmd_run_shell_timer(int, short, void *);
 static void	cmd_run_shell_callback(struct job *);
 static void	cmd_run_shell_free(void *);
 static void	cmd_run_shell_print(struct job *, const char *);
@@ -39,8 +41,8 @@ const struct cmd_entry cmd_run_shell_entry = {
 	.name = "run-shell",
 	.alias = "run",
 
-	.args = { "bt:", 1, 1 },
+	.args = { "bd:Ct:", 0, 1 },
-	.usage = "[-b] " CMD_TARGET_PANE_USAGE " shell-command",
+	.usage = "[-bC] [-d delay] " CMD_TARGET_PANE_USAGE " [shell-command]",
 
 	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
@@ -49,9 +51,16 @@ const struct cmd_entry cmd_run_shell_entry = {
 };
 
 struct cmd_run_shell_data {
+	struct client		*client;
 	char			*cmd;
+	int			 shell;
+	char			*cwd;
 	struct cmdq_item	*item;
+	struct session		*s;
 	int			 wp_id;
+	struct event		 timer;
+	int			 flags;
+	struct cmd_parse_input	 pi;
 };
 
 static void
@@ -78,48 +87,130 @@ cmd_run_shell_print(struct job *job, const char *msg)
 
 	wme = TAILQ_FIRST(&wp->modes);
 	if (wme == NULL || wme->mode != &window_view_mode)
-		window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
+		window_pane_set_mode(wp, NULL, &window_view_mode, NULL, NULL);
 	window_copy_add(wp, "%s", msg);
 }
 
 static enum cmd_retval
 cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
+	struct cmd_find_state		*target = cmdq_get_target(item);
 	struct cmd_run_shell_data	*cdata;
-	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct client			*tc = cmdq_get_target_client(item);
-	struct session			*s = item->target.s;
+	struct session			*s = target->s;
-	struct winlink			*wl = item->target.wl;
+	struct window_pane		*wp = target->wp;
-	struct window_pane		*wp = item->target.wp;
+	const char			*delay;
+	double				 d;
+	struct timeval			 tv;
+	char				*end;
+	int				 wait = !args_has(args, 'b');
+
+	if ((delay = args_get(args, 'd')) != NULL) {
+		d = strtod(delay, &end);
+		if (*end != '\0') {
+			cmdq_error(item, "invalid delay time: %s", delay);
+			return (CMD_RETURN_ERROR);
+		}
+	} else if (args->argc == 0)
+		return (CMD_RETURN_NORMAL);
 
 	cdata = xcalloc(1, sizeof *cdata);
-	cdata->cmd = format_single(item, args->argv[0], c, s, wl, wp);
+	if (args->argc != 0)
+		cdata->cmd = format_single_from_target(item, args->argv[0]);
+
+	cdata->shell = !args_has(args, 'C');
+	if (!cdata->shell) {
+		memset(&cdata->pi, 0, sizeof cdata->pi);
+		cmd_get_source(self, &cdata->pi.file, &cdata->pi.line);
+		if (wait)
+			cdata->pi.item = item;
+		cdata->pi.c = tc;
+		cmd_find_copy_state(&cdata->pi.fs, target);
+	}
 
 	if (args_has(args, 't') && wp != NULL)
 		cdata->wp_id = wp->id;
 	else
 		cdata->wp_id = -1;
 
-	if (!args_has(args, 'b'))
+	if (wait) {
+		cdata->client = cmdq_get_client(item);
 		cdata->item = item;
-
+	} else {
-	if (job_run(cdata->cmd, s, server_client_get_cwd(item->client, s), NULL,
+		cdata->client = tc;
-	    cmd_run_shell_callback, cmd_run_shell_free, cdata, 0) == NULL) {
+		cdata->flags |= JOB_NOWAIT;
-		cmdq_error(item, "failed to run command: %s", cdata->cmd);
-		free(cdata);
-		return (CMD_RETURN_ERROR);
 	}
+	if (cdata->client != NULL)
+		cdata->client->references++;
 
-	if (args_has(args, 'b'))
+	cdata->cwd = xstrdup(server_client_get_cwd(cmdq_get_client(item), s));
+
+	cdata->s = s;
+	if (s != NULL)
+		session_add_ref(s, __func__);
+
+	evtimer_set(&cdata->timer, cmd_run_shell_timer, cdata);
+	if (delay != NULL) {
+		timerclear(&tv);
+		tv.tv_sec = (time_t)d;
+		tv.tv_usec = (d - (double)tv.tv_sec) * 1000000U;
+		evtimer_add(&cdata->timer, &tv);
+	} else
+		event_active(&cdata->timer, EV_TIMEOUT, 1);
+
+	if (!wait)
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }
 
+static void
+cmd_run_shell_timer(__unused int fd, __unused short events, void* arg)
+{
+	struct cmd_run_shell_data	*cdata = arg;
+	struct client			*c = cdata->client;
+	const char			*cmd = cdata->cmd;
+	char				*error;
+	struct cmdq_item		*item = cdata->item;
+	enum cmd_parse_status		 status;
+
+	if (cmd != NULL && cdata->shell) {
+		if (job_run(cmd, 0, NULL, cdata->s, cdata->cwd, NULL,
+		    cmd_run_shell_callback, cmd_run_shell_free, cdata,
+		    cdata->flags, -1, -1) == NULL)
+			cmd_run_shell_free(cdata);
+		return;
+	}
+
+	if (cmd != NULL) {
+		if (item != NULL) {
+			status = cmd_parse_and_insert(cmd, &cdata->pi, item,
+			    cmdq_get_state(item), &error);
+		} else {
+			status = cmd_parse_and_append(cmd, &cdata->pi, c, NULL,
+			    &error);
+		}
+		if (status == CMD_PARSE_ERROR) {
+			if (cdata->item == NULL) {
+				*error = toupper((u_char)*error);
+				status_message_set(c, -1, 1, 0, "%s", error);
+			} else
+				cmdq_error(cdata->item, "%s", error);
+			free(error);
+		}
+	}
+
+	if (cdata->item != NULL)
+		cmdq_continue(cdata->item);
+	cmd_run_shell_free(cdata);
+}
+
 static void
 cmd_run_shell_callback(struct job *job)
 {
 	struct cmd_run_shell_data	*cdata = job_get_data(job);
 	struct bufferevent		*event = job_get_event(job);
+	struct cmdq_item		*item = cdata->item;
 	char				*cmd = cdata->cmd, *msg = NULL, *line;
 	size_t				 size;
 	int				 retcode, status;
@@ -149,13 +240,19 @@ cmd_run_shell_callback(struct job *job)
 	} else if (WIFSIGNALED(status)) {
 		retcode = WTERMSIG(status);
 		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);
-	}
+		retcode += 128;
+	} else
+		retcode = 0;
 	if (msg != NULL)
 		cmd_run_shell_print(job, msg);
 	free(msg);
 
-	if (cdata->item != NULL)
+	if (item != NULL) {
-		cmdq_continue(cdata->item);
+		if (cmdq_get_client(item) != NULL &&
+		    cmdq_get_client(item)->session == NULL)
+			cmdq_get_client(item)->retval = retcode;
+		cmdq_continue(item);
+	}
 }
 
 static void
@@ -163,6 +260,12 @@ cmd_run_shell_free(void *data)
 {
 	struct cmd_run_shell_data	*cdata = data;
 
+	evtimer_del(&cdata->timer);
+	if (cdata->s != NULL)
+		session_remove_ref(cdata->s, __func__);
+	if (cdata->client != NULL)
+		server_client_unref(cdata->client);
+	free(cdata->cwd);
 	free(cdata->cmd);
 	free(cdata);
 }

cmd-save-buffer.c

@@ -72,16 +72,13 @@ cmd_save_buffer_done(__unused struct client *c, const char *path, int error,
 static enum cmd_retval
 cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct client		*c = cmdq_get_client(item);
-	struct session		*s = item->target.s;
-	struct winlink		*wl = item->target.wl;
-	struct window_pane	*wp = item->target.wp;
 	struct paste_buffer	*pb;
 	int			 flags;
 	const char		*bufname = args_get(args, 'b'), *bufdata;
 	size_t			 bufsize;
-	char			*path;
+	char			*path, *tmp;
 
 	if (bufname == NULL) {
 		if ((pb = paste_get_top(NULL)) == NULL) {
@@ -97,15 +94,22 @@ cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 	}
 	bufdata = paste_buffer_data(pb, &bufsize);
 
-	if (self->entry == &cmd_show_buffer_entry)
+	if (cmd_get_entry(self) == &cmd_show_buffer_entry) {
+		if (c->session != NULL || (c->flags & CLIENT_CONTROL)) {
+			utf8_stravisx(&tmp, bufdata, bufsize,
+			    VIS_OCTAL|VIS_CSTYLE|VIS_TAB);
+			cmdq_print(item, "%s", tmp);
+			free(tmp);
+			return (CMD_RETURN_NORMAL);
+		}
 		path = xstrdup("-");
-	else
+	} else
-		path = format_single(item, args->argv[0], c, s, wl, wp);
+		path = format_single_from_target(item, args->argv[0]);
-	if (args_has(self->args, 'a'))
+	if (args_has(args, 'a'))
 		flags = O_APPEND;
 	else
-		flags = 0;
+		flags = O_TRUNC;
-	file_write(item->client, path, flags, bufdata, bufsize,
+	file_write(cmdq_get_client(item), path, flags, bufdata, bufsize,
 	    cmd_save_buffer_done, item);
 	free(path);
 

cmd-select-layout.c

@@ -71,20 +71,21 @@ const struct cmd_entry cmd_previous_layout_entry = {
 static enum cmd_retval
 cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct winlink		*wl = item->target.wl;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
-	struct window_pane	*wp = item->target.wp;
+	struct window_pane	*wp = target->wp;
 	const char		*layoutname;
 	char			*oldlayout;
 	int			 next, previous, layout;
 
 	server_unzoom_window(w);
 
-	next = self->entry == &cmd_next_layout_entry;
+	next = (cmd_get_entry(self) == &cmd_next_layout_entry);
 	if (args_has(args, 'n'))
 		next = 1;
-	previous = self->entry == &cmd_previous_layout_entry;
+	previous = (cmd_get_entry(self) == &cmd_previous_layout_entry);
 	if (args_has(args, 'p'))
 		previous = 1;
 

cmd-select-pane.c

@@ -83,19 +83,21 @@ cmd_select_pane_redraw(struct window *w)
 static enum cmd_retval
 cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = &item->shared->current;
+	const struct cmd_entry	*entry = cmd_get_entry(self);
-	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct winlink		*wl = item->target.wl;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*c = cmdq_get_client(item);
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
-	struct session		*s = item->target.s;
+	struct session		*s = target->s;
-	struct window_pane	*wp = item->target.wp, *lastwp, *markedwp;
+	struct window_pane	*wp = target->wp, *activewp, *lastwp, *markedwp;
-	char			*pane_title;
+	struct options		*oo = wp->options;
+	char			*title;
 	const char		*style;
-	struct style		*sy;
 	struct options_entry	*o;
 
-	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
+	if (entry == &cmd_last_pane_entry || args_has(args, 'l')) {
 		lastwp = w->last;
 		if (lastwp == NULL && window_count_panes(w) == 2) {
 			lastwp = TAILQ_PREV(w->active, window_panes, entry);
@@ -106,12 +108,16 @@ cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "no last pane");
 			return (CMD_RETURN_ERROR);
 		}
-		if (args_has(self->args, 'e'))
+		if (args_has(args, 'e')) {
 			lastwp->flags &= ~PANE_INPUTOFF;
-		else if (args_has(self->args, 'd'))
+			server_redraw_window_borders(lastwp->window);
+			server_status_window(lastwp->window);
+		} else if (args_has(args, 'd')) {
 			lastwp->flags |= PANE_INPUTOFF;
-		else {
+			server_redraw_window_borders(lastwp->window);
-			if (window_push_zoom(w, args_has(self->args, 'Z')))
+			server_status_window(lastwp->window);
+		} else {
+			if (window_push_zoom(w, 0, args_has(args, 'Z')))
 				server_redraw_window(w);
 			window_redraw_active_switch(w, lastwp);
 			if (window_set_active_pane(w, lastwp, 1)) {
@@ -127,7 +133,10 @@ cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 	if (args_has(args, 'm') || args_has(args, 'M')) {
 		if (args_has(args, 'm') && !window_pane_visible(wp))
 			return (CMD_RETURN_NORMAL);
-		lastwp = marked_pane.wp;
+		if (server_check_marked())
+			lastwp = marked_pane.wp;
+		else
+			lastwp = NULL;
 
 		if (args_has(args, 'M') || server_is_marked(s, wl, wp))
 			server_clear_marked();
@@ -146,73 +155,80 @@ cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(self->args, 'P') || args_has(self->args, 'g')) {
+	style = args_get(args, 'P');
-		if ((style = args_get(args, 'P')) != NULL) {
+	if (style != NULL) {
-			o = options_set_style(wp->options, "window-style", 0,
+		o = options_set_string(oo, "window-style", 0, "%s", style);
-			    style);
+		if (o == NULL) {
-			if (o == NULL) {
+			cmdq_error(item, "bad style: %s", style);
-				cmdq_error(item, "bad style: %s", style);
+			return (CMD_RETURN_ERROR);
-				return (CMD_RETURN_ERROR);
-			}
-			options_set_style(wp->options, "window-active-style", 0,
-			    style);
-			wp->flags |= (PANE_REDRAW|PANE_STYLECHANGED);
-		}
-		if (args_has(self->args, 'g')) {
-			sy = options_get_style(wp->options, "window-style");
-			cmdq_print(item, "%s", style_tostring(sy));
 		}
+		options_set_string(oo, "window-active-style", 0, "%s", style);
+		wp->flags |= (PANE_REDRAW|PANE_STYLECHANGED);
+	}
+	if (args_has(args, 'g')) {
+		cmdq_print(item, "%s", options_get_string(oo, "window-style"));
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(self->args, 'L')) {
+	if (args_has(args, 'L')) {
-		window_push_zoom(w, 1);
+		window_push_zoom(w, 0, 1);
 		wp = window_pane_find_left(wp);
 		window_pop_zoom(w);
-	} else if (args_has(self->args, 'R')) {
+	} else if (args_has(args, 'R')) {
-		window_push_zoom(w, 1);
+		window_push_zoom(w, 0, 1);
 		wp = window_pane_find_right(wp);
 		window_pop_zoom(w);
-	} else if (args_has(self->args, 'U')) {
+	} else if (args_has(args, 'U')) {
-		window_push_zoom(w, 1);
+		window_push_zoom(w, 0, 1);
 		wp = window_pane_find_up(wp);
 		window_pop_zoom(w);
-	} else if (args_has(self->args, 'D')) {
+	} else if (args_has(args, 'D')) {
-		window_push_zoom(w, 1);
+		window_push_zoom(w, 0, 1);
 		wp = window_pane_find_down(wp);
 		window_pop_zoom(w);
 	}
 	if (wp == NULL)
 		return (CMD_RETURN_NORMAL);
 
-	if (args_has(self->args, 'e')) {
+	if (args_has(args, 'e')) {
 		wp->flags &= ~PANE_INPUTOFF;
+		server_redraw_window_borders(wp->window);
+		server_status_window(wp->window);
 		return (CMD_RETURN_NORMAL);
 	}
-	if (args_has(self->args, 'd')) {
+	if (args_has(args, 'd')) {
 		wp->flags |= PANE_INPUTOFF;
+		server_redraw_window_borders(wp->window);
+		server_status_window(wp->window);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(self->args, 'T')) {
+	if (args_has(args, 'T')) {
-		pane_title = format_single(item, args_get(self->args, 'T'),
+		title = format_single_from_target(item, args_get(args, 'T'));
-		    c, s, wl, wp);
+		if (screen_set_title(&wp->base, title)) {
-		if (screen_set_title(&wp->base, pane_title))
+			notify_pane("pane-title-changed", wp);
+			server_redraw_window_borders(wp->window);
 			server_status_window(wp->window);
-		free(pane_title);
+		}
+		free(title);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (wp == w->active)
+	if (c != NULL && c->session != NULL && (c->flags & CLIENT_ACTIVEPANE))
+		activewp = server_client_get_pane(c);
+	else
+		activewp = w->active;
+	if (wp == activewp)
 		return (CMD_RETURN_NORMAL);
-	if (window_push_zoom(w, args_has(self->args, 'Z')))
+	if (window_push_zoom(w, 0, args_has(args, 'Z')))
 		server_redraw_window(w);
 	window_redraw_active_switch(w, wp);
-	if (window_set_active_pane(w, wp, 1)) {
+	if (c != NULL && c->session != NULL && (c->flags & CLIENT_ACTIVEPANE))
+		server_client_set_pane(c, wp);
+	else if (window_set_active_pane(w, wp, 1))
 		cmd_find_from_winlink_pane(current, wl, wp, 0);
-		cmdq_insert_hook(s, item, current, "after-select-pane");
+	cmdq_insert_hook(s, item, current, "after-select-pane");
-		cmd_select_pane_redraw(w);
+	cmd_select_pane_redraw(w);
-	}
 	if (window_pop_zoom(w))
 		server_redraw_window(w);
 

cmd-select-window.c

@@ -84,23 +84,26 @@ const struct cmd_entry cmd_last_window_entry = {
 static enum cmd_retval
 cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct cmd_find_state	*current = &item->shared->current;
+	struct args		*args = cmd_get_args(self);
-	struct winlink		*wl = item->target.wl;
+	struct client		*c = cmdq_get_client(item);
-	struct session		*s = item->target.s;
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	struct session		*s = target->s;
 	int			 next, previous, last, activity;
 
-	next = self->entry == &cmd_next_window_entry;
+	next = (cmd_get_entry(self) == &cmd_next_window_entry);
-	if (args_has(self->args, 'n'))
+	if (args_has(args, 'n'))
 		next = 1;
-	previous = self->entry == &cmd_previous_window_entry;
+	previous = (cmd_get_entry(self) == &cmd_previous_window_entry);
-	if (args_has(self->args, 'p'))
+	if (args_has(args, 'p'))
 		previous = 1;
-	last = self->entry == &cmd_last_window_entry;
+	last = (cmd_get_entry(self) == &cmd_last_window_entry);
-	if (args_has(self->args, 'l'))
+	if (args_has(args, 'l'))
 		last = 1;
 
 	if (next || previous || last) {
-		activity = args_has(self->args, 'a');
+		activity = args_has(args, 'a');
 		if (next) {
 			if (session_next(s, activity) != 0) {
 				cmdq_error(item, "no next window");
@@ -125,7 +128,7 @@ cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 		 * If -T and select-window is invoked on same window as
 		 * current, switch to previous window.
 		 */
-		if (args_has(self->args, 'T') && wl == s->curw) {
+		if (args_has(args, 'T') && wl == s->curw) {
 			if (session_last(s) != 0) {
 				cmdq_error(item, "no last window");
 				return (-1);
@@ -139,6 +142,8 @@ cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 		}
 		cmdq_insert_hook(s, item, current, "after-select-window");
 	}
+	if (c != NULL && c->session != NULL)
+		s->curw->window->latest = c;
 	recalculate_sizes();
 
 	return (CMD_RETURN_NORMAL);

cmd-send-keys.c

@@ -57,43 +57,42 @@ const struct cmd_entry cmd_send_prefix_entry = {
 };
 
 static struct cmdq_item *
-cmd_send_keys_inject_key(struct client *c, struct cmd_find_state *fs,
+cmd_send_keys_inject_key(struct cmdq_item *item, struct cmdq_item *after,
-    struct cmdq_item *item, key_code key)
+    key_code key)
 {
-	struct session			*s = fs->s;
+	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct winlink			*wl = fs->wl;
+	struct client			*tc = cmdq_get_target_client(item);
-	struct window_pane		*wp = fs->wp;
+	struct session			*s = target->s;
+	struct winlink			*wl = target->wl;
+	struct window_pane		*wp = target->wp;
 	struct window_mode_entry	*wme;
 	struct key_table		*table;
 	struct key_binding		*bd;
 
-	wme = TAILQ_FIRST(&fs->wp->modes);
+	wme = TAILQ_FIRST(&wp->modes);
 	if (wme == NULL || wme->mode->key_table == NULL) {
-		if (options_get_number(fs->wp->window->options, "xterm-keys"))
+		if (window_pane_key(wp, tc, s, wl, key, NULL) != 0)
-			key |= KEYC_XTERM;
-		if (window_pane_key(wp, item->client, s, wl, key, NULL) != 0)
 			return (NULL);
 		return (item);
 	}
 	table = key_bindings_get_table(wme->mode->key_table(wme), 1);
 
-	bd = key_bindings_get(table, key & ~KEYC_XTERM);
+	bd = key_bindings_get(table, key & ~KEYC_MASK_FLAGS);
 	if (bd != NULL) {
 		table->references++;
-		item = key_bindings_dispatch(bd, item, c, NULL, &item->target);
+		after = key_bindings_dispatch(bd, after, tc, NULL, target);
 		key_bindings_unref_table(table);
 	}
-	return (item);
+	return (after);
 }
 
 static struct cmdq_item *
-cmd_send_keys_inject_string(struct client *c, struct cmd_find_state *fs,
+cmd_send_keys_inject_string(struct cmdq_item *item, struct cmdq_item *after,
-    struct cmdq_item *item, struct args *args, int i)
+    struct args *args, int i)
 {
 	const char		*s = args->argv[i];
-	struct cmdq_item	*new_item;
+	struct utf8_data	*ud, *loop;
-	struct utf8_data	*ud, *uc;
+	utf8_char		 uc;
-	wchar_t			 wc;
 	key_code		 key;
 	char			*endptr;
 	long			 n;
@@ -103,42 +102,49 @@ cmd_send_keys_inject_string(struct client *c, struct cmd_find_state *fs,
 		n = strtol(s, &endptr, 16);
 		if (*s =='\0' || n < 0 || n > 0xff || *endptr != '\0')
 			return (item);
-		return (cmd_send_keys_inject_key(c, fs, item, KEYC_LITERAL|n));
+		return (cmd_send_keys_inject_key(item, after, KEYC_LITERAL|n));
 	}
 
 	literal = args_has(args, 'l');
 	if (!literal) {
 		key = key_string_lookup_string(s);
 		if (key != KEYC_NONE && key != KEYC_UNKNOWN) {
-			new_item = cmd_send_keys_inject_key(c, fs, item, key);
+			after = cmd_send_keys_inject_key(item, after, key);
-			if (new_item != NULL)
+			if (after != NULL)
-				return (new_item);
+				return (after);
 		}
 		literal = 1;
 	}
 	if (literal) {
 		ud = utf8_fromcstr(s);
-		for (uc = ud; uc->size != 0; uc++) {
+		for (loop = ud; loop->size != 0; loop++) {
-			if (utf8_combine(uc, &wc) != UTF8_DONE)
+			if (loop->size == 1 && loop->data[0] <= 0x7f)
-				continue;
+				key = loop->data[0];
-			item = cmd_send_keys_inject_key(c, fs, item, wc);
+			else {
+				if (utf8_from_data(loop, &uc) != UTF8_DONE)
+					continue;
+				key = uc;
+			}
+			after = cmd_send_keys_inject_key(item, after, key);
 		}
 		free(ud);
 	}
-	return (item);
+	return (after);
 }
 
 static enum cmd_retval
 cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
-	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct cmd_find_state		*fs = &item->target;
+	struct client			*tc = cmdq_get_target_client(item);
-	struct window_pane		*wp = item->target.wp;
+	struct session			*s = target->s;
-	struct session			*s = item->target.s;
+	struct winlink			*wl = target->wl;
-	struct winlink			*wl = item->target.wl;
+	struct window_pane		*wp = target->wp;
-	struct mouse_event		*m = &item->shared->mouse;
+	struct key_event		*event = cmdq_get_event(item);
+	struct mouse_event		*m = &event->m;
 	struct window_mode_entry	*wme = TAILQ_FIRST(&wp->modes);
+	struct cmdq_item		*after = item;
 	int				 i;
 	key_code			 key;
 	u_int				 np = 1;
@@ -152,7 +158,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 			return (CMD_RETURN_ERROR);
 		}
 		if (wme != NULL && (args_has(args, 'X') || args->argc == 0)) {
-			if (wme == NULL || wme->mode->command == NULL) {
+			if (wme->mode->command == NULL) {
 				cmdq_error(item, "not in a mode");
 				return (CMD_RETURN_ERROR);
 			}
@@ -167,7 +173,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 		}
 		if (!m->valid)
 			m = NULL;
-		wme->mode->command(wme, c, s, wl, args, m);
+		wme->mode->command(wme, tc, s, wl, args, m);
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -177,27 +183,29 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "no mouse target");
 			return (CMD_RETURN_ERROR);
 		}
-		window_pane_key(wp, item->client, s, wl, m->key, m);
+		window_pane_key(wp, tc, s, wl, m->key, m);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (self->entry == &cmd_send_prefix_entry) {
+	if (cmd_get_entry(self) == &cmd_send_prefix_entry) {
 		if (args_has(args, '2'))
 			key = options_get_number(s->options, "prefix2");
 		else
 			key = options_get_number(s->options, "prefix");
-		cmd_send_keys_inject_key(c, fs, item, key);
+		cmd_send_keys_inject_key(item, item, key);
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (args_has(args, 'R')) {
 		window_pane_reset_palette(wp);
-		input_reset(wp, 1);
+		input_reset(wp->ictx, 1);
 	}
 
 	for (; np != 0; np--) {
-		for (i = 0; i < args->argc; i++)
+		for (i = 0; i < args->argc; i++) {
-			item = cmd_send_keys_inject_string(c, fs, item, args, i);
+			after = cmd_send_keys_inject_string(item, after, args,
+			    i);
+		}
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-set-buffer.c

@@ -33,10 +33,11 @@ const struct cmd_entry cmd_set_buffer_entry = {
 	.name = "set-buffer",
 	.alias = "setb",
 
-	.args = { "ab:n:", 0, 1 },
+	.args = { "ab:t:n:w", 0, 1 },
-	.usage = "[-a] " CMD_BUFFER_USAGE " [-n new-buffer-name] data",
+	.usage = "[-aw] " CMD_BUFFER_USAGE " [-n new-buffer-name] "
+	         CMD_TARGET_CLIENT_USAGE " data",
 
-	.flags = CMD_AFTERHOOK,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG|CMD_CLIENT_CANFAIL,
 	.exec = cmd_set_buffer_exec
 };
 
@@ -54,7 +55,8 @@ const struct cmd_entry cmd_delete_buffer_entry = {
 static enum cmd_retval
 cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct client		*tc = cmdq_get_target_client(item);
 	struct paste_buffer	*pb;
 	char			*bufdata, *cause;
 	const char		*bufname, *olddata;
@@ -66,7 +68,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 	else
 		pb = paste_get_name(bufname);
 
-	if (self->entry == &cmd_delete_buffer_entry) {
+	if (cmd_get_entry(self) == &cmd_delete_buffer_entry) {
 		if (pb == NULL)
 			pb = paste_get_top(&bufname);
 		if (pb == NULL) {
@@ -118,6 +120,8 @@ cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
+	if (args_has(args, 'w') && tc != NULL)
+ 		tty_set_selection(&tc->tty, bufdata, bufsize);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-set-environment.c

@@ -34,8 +34,8 @@ const struct cmd_entry cmd_set_environment_entry = {
 	.name = "set-environment",
 	.alias = "setenv",
 
-	.args = { "grt:u", 1, 2 },
+	.args = { "Fhgrt:u", 1, 2 },
-	.usage = "[-gru] " CMD_TARGET_SESSION_USAGE " name [value]",
+	.usage = "[-Fhgru] " CMD_TARGET_SESSION_USAGE " name [value]",
 
 	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
@@ -46,9 +46,12 @@ const struct cmd_entry cmd_set_environment_entry = {
 static enum cmd_retval
 cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct environ	*env;
+	struct cmd_find_state	*target = cmdq_get_target(item);
-	const char	*name, *value, *target;
+	struct environ		*env;
+	const char		*name, *value, *tflag;
+	char			*expand = NULL;
+	enum cmd_retval		 retval = CMD_RETURN_NORMAL;
 
 	name = args->argv[0];
 	if (*name == '\0') {
@@ -62,42 +65,54 @@ cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
 
 	if (args->argc < 2)
 		value = NULL;
+	else if (args_has(args, 'F'))
+		value = expand = format_single_from_target(item, args->argv[1]);
 	else
 		value = args->argv[1];
 
-	if (args_has(self->args, 'g'))
+	if (args_has(args, 'g'))
 		env = global_environ;
 	else {
-		if (item->target.s == NULL) {
+		if (target->s == NULL) {
-			target = args_get(args, 't');
+			tflag = args_get(args, 't');
-			if (target != NULL)
+			if (tflag != NULL)
-				cmdq_error(item, "no such session: %s", target);
+				cmdq_error(item, "no such session: %s", tflag);
 			else
 				cmdq_error(item, "no current session");
-			return (CMD_RETURN_ERROR);
+			retval = CMD_RETURN_ERROR;
+			goto out;
 		}
-		env = item->target.s->environ;
+		env = target->s->environ;
 	}
 
-	if (args_has(self->args, 'u')) {
+	if (args_has(args, 'u')) {
 		if (value != NULL) {
 			cmdq_error(item, "can't specify a value with -u");
-			return (CMD_RETURN_ERROR);
+			retval = CMD_RETURN_ERROR;
+			goto out;
 		}
 		environ_unset(env, name);
-	} else if (args_has(self->args, 'r')) {
+	} else if (args_has(args, 'r')) {
 		if (value != NULL) {
 			cmdq_error(item, "can't specify a value with -r");
-			return (CMD_RETURN_ERROR);
+			retval = CMD_RETURN_ERROR;
+			goto out;
 		}
 		environ_clear(env, name);
 	} else {
 		if (value == NULL) {
 			cmdq_error(item, "no value specified");
-			return (CMD_RETURN_ERROR);
+			retval = CMD_RETURN_ERROR;
+			goto out;
 		}
-		environ_set(env, name, "%s", value);
+
+		if (args_has(args, 'h'))
+			environ_set(env, name, ENVIRON_HIDDEN, "%s", value);
+		else
+			environ_set(env, name, 0, "%s", value);
 	}
 
-	return (CMD_RETURN_NORMAL);
+out:
+	free(expand);
+	return (retval);
 }

cmd-set-option.c

@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <fnmatch.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -30,21 +29,12 @@
 
 static enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmdq_item *);
 
-static int	cmd_set_option_set(struct cmd *, struct cmdq_item *,
-		    struct options *, struct options_entry *, const char *);
-static int	cmd_set_option_flag(struct cmdq_item *,
-		    const struct options_table_entry *, struct options *,
-		    const char *);
-static int	cmd_set_option_choice(struct cmdq_item *,
-		    const struct options_table_entry *, struct options *,
-		    const char *);
-
 const struct cmd_entry cmd_set_option_entry = {
 	.name = "set-option",
 	.alias = "set",
 
-	.args = { "aFgopqst:uw", 1, 2 },
+	.args = { "aFgopqst:uUw", 1, 2 },
-	.usage = "[-aFgopqsuw] " CMD_TARGET_PANE_USAGE " option [value]",
+	.usage = "[-aFgopqsuUw] " CMD_TARGET_PANE_USAGE " option [value]",
 
 	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
@@ -69,10 +59,10 @@ const struct cmd_entry cmd_set_hook_entry = {
 	.name = "set-hook",
 	.alias = NULL,
 
-	.args = { "agRt:u", 1, 2 },
+	.args = { "agpRt:uw", 1, 2 },
-	.usage = "[-agRu] " CMD_TARGET_SESSION_USAGE " hook [command]",
+	.usage = "[-agpRuw] " CMD_TARGET_PANE_USAGE " hook [command]",
 
-	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_option_exec
@@ -81,29 +71,23 @@ const struct cmd_entry cmd_set_hook_entry = {
 static enum cmd_retval
 cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
 	int				 append = args_has(args, 'a');
-	struct cmd_find_state		*fs = &item->target;
+	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct client			*c, *loop;
+	struct window_pane		*loop;
-	struct session			*s = fs->s;
-	struct winlink			*wl = fs->wl;
-	struct window			*w;
-	struct window_pane		*wp;
 	struct options			*oo;
-	struct options_entry		*parent, *o;
+	struct options_entry		*parent, *o, *po;
 	char				*name, *argument, *value = NULL, *cause;
 	int				 window, idx, already, error, ambiguous;
 	int				 scope;
-	struct style			*sy;
 
-	window = (self->entry == &cmd_set_window_option_entry);
+	window = (cmd_get_entry(self) == &cmd_set_window_option_entry);
 
 	/* Expand argument. */
-	c = cmd_find_client(item, NULL, 1);
+	argument = format_single_from_target(item, args->argv[0]);
-	argument = format_single(item, args->argv[0], c, s, wl, NULL);
 
 	/* If set-hook -R, fire the hook straight away. */
-	if (self->entry == &cmd_set_hook_entry && args_has(args, 'R')) {
+	if (cmd_get_entry(self) == &cmd_set_hook_entry && args_has(args, 'R')) {
 		notify_hook(item, argument);
 		free(argument);
 		return (CMD_RETURN_NORMAL);
@@ -123,12 +107,13 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 	if (args->argc < 2)
 		value = NULL;
 	else if (args_has(args, 'F'))
-		value = format_single(item, args->argv[1], c, s, wl, NULL);
+		value = format_single_from_target(item, args->argv[1]);
 	else
 		value = xstrdup(args->argv[1]);
 
 	/* Get the scope and table for the option .*/
-	scope = options_scope_from_name(args, window, name, fs, &oo, &cause);
+	scope = options_scope_from_name(args, window, name, target, &oo,
+	    &cause);
 	if (scope == OPTIONS_TABLE_NONE) {
 		if (args_has(args, 'q'))
 			goto out;
@@ -140,7 +125,7 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 	parent = options_get(oo, name);
 
 	/* Check that array options and indexes match up. */
-	if (idx != -1 && (*name == '@' || !options_isarray(parent))) {
+	if (idx != -1 && (*name == '@' || !options_is_array(parent))) {
 		cmdq_error(item, "not an array: %s", argument);
 		goto fail;
 	}
@@ -164,19 +149,22 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	/* Change the option. */
-	if (args_has(args, 'u')) {
+	if (args_has(args, 'U') && scope == OPTIONS_TABLE_WINDOW) {
+		TAILQ_FOREACH(loop, &target->w->panes, entry) {
+			po = options_get_only(loop->options, name);
+			if (po == NULL)
+				continue;
+			if (options_remove_or_default(po, idx, &cause) != 0) {
+				cmdq_error(item, "%s", cause);
+				free(cause);
+				goto fail;
+			}
+		}
+	}
+	if (args_has(args, 'u') || args_has(args, 'U')) {
 		if (o == NULL)
 			goto out;
-		if (idx == -1) {
+		if (options_remove_or_default(o, idx, &cause) != 0) {
-			if (*name == '@')
-				options_remove(o);
-			else if (oo == global_options ||
-			    oo == global_s_options ||
-			    oo == global_w_options)
-				options_default(oo, options_table_entry(o));
-			else
-				options_remove(o);
-		} else if (options_array_set(o, idx, NULL, 0, &cause) != 0) {
 			cmdq_error(item, "%s", cause);
 			free(cause);
 			goto fail;
@@ -187,10 +175,15 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 			goto fail;
 		}
 		options_set_string(oo, name, append, "%s", value);
-	} else if (idx == -1 && !options_isarray(parent)) {
+	} else if (idx == -1 && !options_is_array(parent)) {
-		error = cmd_set_option_set(self, item, oo, parent, value);
+		error = options_from_string(oo, options_table_entry(parent),
-		if (error != 0)
+		    options_table_entry(parent)->name, value,
+		    args_has(args, 'a'), &cause);
+		if (error != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
 			goto fail;
+		}
 	} else {
 		if (value == NULL) {
 			cmdq_error(item, "empty value");
@@ -214,61 +207,7 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 		}
 	}
 
-	/* Update timers and so on for various options. */
+	options_push_changes(name);
-	if (strcmp(name, "automatic-rename") == 0) {
-		RB_FOREACH(w, windows, &windows) {
-			if (w->active == NULL)
-				continue;
-			if (options_get_number(w->options, "automatic-rename"))
-				w->active->flags |= PANE_CHANGED;
-		}
-	}
-	if (strcmp(name, "key-table") == 0) {
-		TAILQ_FOREACH(loop, &clients, entry)
-			server_client_set_key_table(loop, NULL);
-	}
-	if (strcmp(name, "user-keys") == 0) {
-		TAILQ_FOREACH(loop, &clients, entry) {
-			if (loop->tty.flags & TTY_OPENED)
-				tty_keys_build(&loop->tty);
-		}
-	}
-	if (strcmp(name, "status-fg") == 0 || strcmp(name, "status-bg") == 0) {
-		sy = options_get_style(oo, "status-style");
-		sy->gc.fg = options_get_number(oo, "status-fg");
-		sy->gc.bg = options_get_number(oo, "status-bg");
-	}
-	if (strcmp(name, "status-style") == 0) {
-		sy = options_get_style(oo, "status-style");
-		options_set_number(oo, "status-fg", sy->gc.fg);
-		options_set_number(oo, "status-bg", sy->gc.bg);
-	}
-	if (strcmp(name, "status") == 0 ||
-	    strcmp(name, "status-interval") == 0)
-		status_timer_start_all();
-	if (strcmp(name, "monitor-silence") == 0)
-		alerts_reset_all();
-	if (strcmp(name, "window-style") == 0 ||
-	    strcmp(name, "window-active-style") == 0) {
-		RB_FOREACH(wp, window_pane_tree, &all_window_panes)
-			wp->flags |= PANE_STYLECHANGED;
-	}
-	if (strcmp(name, "pane-border-status") == 0) {
-		RB_FOREACH(w, windows, &windows)
-			layout_fix_panes(w);
-	}
-	RB_FOREACH(s, sessions, &sessions)
-		status_update_cache(s);
-
-	/*
-	 * Update sizes and redraw. May not always be necessary but do it
-	 * anyway.
-	 */
-	recalculate_sizes();
-	TAILQ_FOREACH(loop, &clients, entry) {
-		if (loop->session != NULL)
-			server_redraw_client(loop);
-	}
 
 out:
 	free(argument);
@@ -282,130 +221,3 @@ fail:
 	free(name);
 	return (CMD_RETURN_ERROR);
 }
-
-static int
-cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
-    struct options_entry *parent, const char *value)
-{
-	const struct options_table_entry	*oe;
-	struct args				*args = self->args;
-	int					 append = args_has(args, 'a');
-	struct options_entry			*o;
-	long long				 number;
-	const char				*errstr, *new;
-	char					*old;
-	key_code				 key;
-
-	oe = options_table_entry(parent);
-	if (value == NULL &&
-	    oe->type != OPTIONS_TABLE_FLAG &&
-	    oe->type != OPTIONS_TABLE_CHOICE) {
-		cmdq_error(item, "empty value");
-		return (-1);
-	}
-
-	switch (oe->type) {
-	case OPTIONS_TABLE_STRING:
-		old = xstrdup(options_get_string(oo, oe->name));
-		options_set_string(oo, oe->name, append, "%s", value);
-		new = options_get_string(oo, oe->name);
-		if (oe->pattern != NULL && fnmatch(oe->pattern, new, 0) != 0) {
-			options_set_string(oo, oe->name, 0, "%s", old);
-			free(old);
-			cmdq_error(item, "value is invalid: %s", value);
-			return (-1);
-		}
-		free(old);
-		return (0);
-	case OPTIONS_TABLE_NUMBER:
-		number = strtonum(value, oe->minimum, oe->maximum, &errstr);
-		if (errstr != NULL) {
-			cmdq_error(item, "value is %s: %s", errstr, value);
-			return (-1);
-		}
-		options_set_number(oo, oe->name, number);
-		return (0);
-	case OPTIONS_TABLE_KEY:
-		key = key_string_lookup_string(value);
-		if (key == KEYC_UNKNOWN) {
-			cmdq_error(item, "bad key: %s", value);
-			return (-1);
-		}
-		options_set_number(oo, oe->name, key);
-		return (0);
-	case OPTIONS_TABLE_COLOUR:
-		if ((number = colour_fromstring(value)) == -1) {
-			cmdq_error(item, "bad colour: %s", value);
-			return (-1);
-		}
-		options_set_number(oo, oe->name, number);
-		return (0);
-	case OPTIONS_TABLE_FLAG:
-		return (cmd_set_option_flag(item, oe, oo, value));
-	case OPTIONS_TABLE_CHOICE:
-		return (cmd_set_option_choice(item, oe, oo, value));
-	case OPTIONS_TABLE_STYLE:
-		o = options_set_style(oo, oe->name, append, value);
-		if (o == NULL) {
-			cmdq_error(item, "bad style: %s", value);
-			return (-1);
-		}
-		return (0);
-	case OPTIONS_TABLE_COMMAND:
-		break;
-	}
-	return (-1);
-}
-
-static int
-cmd_set_option_flag(struct cmdq_item *item,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	int	flag;
-
-	if (value == NULL || *value == '\0')
-		flag = !options_get_number(oo, oe->name);
-	else if (strcmp(value, "1") == 0 ||
-	    strcasecmp(value, "on") == 0 ||
-	    strcasecmp(value, "yes") == 0)
-		flag = 1;
-	else if (strcmp(value, "0") == 0 ||
-	    strcasecmp(value, "off") == 0 ||
-	    strcasecmp(value, "no") == 0)
-		flag = 0;
-	else {
-		cmdq_error(item, "bad value: %s", value);
-		return (-1);
-	}
-	options_set_number(oo, oe->name, flag);
-	return (0);
-}
-
-static int
-cmd_set_option_choice(struct cmdq_item *item,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	const char	**cp;
-	int		  n, choice = -1;
-
-	if (value == NULL) {
-		choice = options_get_number(oo, oe->name);
-		if (choice < 2)
-			choice = !choice;
-	} else {
-		n = 0;
-		for (cp = oe->choices; *cp != NULL; cp++) {
-			if (strcmp(*cp, value) == 0)
-				choice = n;
-			n++;
-		}
-		if (choice == -1) {
-			cmdq_error(item, "unknown value: %s", value);
-			return (-1);
-		}
-	}
-	options_set_number(oo, oe->name, choice);
-	return (0);
-}

cmd-show-environment.c

@@ -38,8 +38,8 @@ const struct cmd_entry cmd_show_environment_entry = {
 	.name = "show-environment",
 	.alias = "showenv",
 
-	.args = { "gst:", 0, 1 },
+	.args = { "hgst:", 0, 1 },
-	.usage = "[-gs] " CMD_TARGET_SESSION_USAGE " [name]",
+	.usage = "[-hgs] " CMD_TARGET_SESSION_USAGE " [name]",
 
 	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
@@ -69,9 +69,15 @@ static void
 cmd_show_environment_print(struct cmd *self, struct cmdq_item *item,
     struct environ_entry *envent)
 {
-	char	*escaped;
+	struct args	*args = cmd_get_args(self);
+	char		*escaped;
 
-	if (!args_has(self->args, 's')) {
+	if (!args_has(args, 'h') && (envent->flags & ENVIRON_HIDDEN))
+		return;
+	if (args_has(args, 'h') && (~envent->flags & ENVIRON_HIDDEN))
+		return;
+
+	if (!args_has(args, 's')) {
 		if (envent->value != NULL)
 			cmdq_print(item, "%s=%s", envent->name, envent->value);
 		else
@@ -91,30 +97,31 @@ cmd_show_environment_print(struct cmd *self, struct cmdq_item *item,
 static enum cmd_retval
 cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct environ		*env;
 	struct environ_entry	*envent;
-	const char		*target;
+	const char		*tflag;
 
-	if ((target = args_get(args, 't')) != NULL) {
+	if ((tflag = args_get(args, 't')) != NULL) {
-		if (item->target.s == NULL) {
+		if (target->s == NULL) {
-			cmdq_error(item, "no such session: %s", target);
+			cmdq_error(item, "no such session: %s", tflag);
 			return (CMD_RETURN_ERROR);
 		}
 	}
 
-	if (args_has(self->args, 'g'))
+	if (args_has(args, 'g'))
 		env = global_environ;
 	else {
-		if (item->target.s == NULL) {
+		if (target->s == NULL) {
-			target = args_get(args, 't');
+			tflag = args_get(args, 't');
-			if (target != NULL)
+			if (tflag != NULL)
-				cmdq_error(item, "no such session: %s", target);
+				cmdq_error(item, "no such session: %s", tflag);
 			else
 				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
 		}
-		env = item->target.s->environ;
+		env = target->s->environ;
 	}
 
 	if (args->argc != 0) {

cmd-show-messages.c

@@ -18,16 +18,19 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
 #include <string.h>
-#include <time.h>
 #include <unistd.h>
 
 #include "tmux.h"
 
 /*
- * Show client message log.
+ * Show message log.
  */
 
+#define SHOW_MESSAGES_TEMPLATE \
+	"#{t/p:message_time}: #{message_text}"
+
 static enum cmd_retval	cmd_show_messages_exec(struct cmd *,
 			    struct cmdq_item *);
 
@@ -38,26 +41,28 @@ const struct cmd_entry cmd_show_messages_entry = {
 	.args = { "JTt:", 0, 0 },
 	.usage = "[-JT] " CMD_TARGET_CLIENT_USAGE,
 
-	.flags = CMD_AFTERHOOK,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
 	.exec = cmd_show_messages_exec
 };
 
-static int	cmd_show_messages_terminals(struct cmdq_item *, int);
-
 static int
-cmd_show_messages_terminals(struct cmdq_item *item, int blank)
+cmd_show_messages_terminals(struct cmd *self, struct cmdq_item *item, int blank)
 {
+	struct args	*args = cmd_get_args(self);
+	struct client	*tc = cmdq_get_target_client(item);
 	struct tty_term	*term;
 	u_int		 i, n;
 
 	n = 0;
 	LIST_FOREACH(term, &tty_terms, entry) {
+		if (args_has(args, 't') && term != tc->tty.term)
+			continue;
 		if (blank) {
 			cmdq_print(item, "%s", "");
 			blank = 0;
 		}
-		cmdq_print(item, "Terminal %u: %s [references=%u, flags=0x%x]:",
+		cmdq_print(item, "Terminal %u: %s for %s, flags=0x%x:", n,
-		    n, term->name, term->references, term->flags);
+		    term->name, term->tty->client->name, term->flags);
 		n++;
 		for (i = 0; i < tty_term_ncodes(); i++)
 			cmdq_print(item, "%s", tty_term_describe(term, i));
@@ -68,18 +73,15 @@ cmd_show_messages_terminals(struct cmdq_item *item, int blank)
 static enum cmd_retval
 cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct client		*c;
 	struct message_entry	*msg;
-	char			*tim;
+	char			*s;
 	int			 done, blank;
-
+	struct format_tree	*ft;
-	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
 
 	done = blank = 0;
 	if (args_has(args, 'T')) {
-		blank = cmd_show_messages_terminals(item, blank);
+		blank = cmd_show_messages_terminals(self, item, blank);
 		done = 1;
 	}
 	if (args_has(args, 'J')) {
@@ -89,12 +91,17 @@ cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
 	if (done)
 		return (CMD_RETURN_NORMAL);
 
-	TAILQ_FOREACH(msg, &c->message_log, entry) {
+	ft = format_create_from_target(item);
-		tim = ctime(&msg->msg_time);
+	TAILQ_FOREACH_REVERSE(msg, &message_log, message_list, entry) {
-		*strchr(tim, '\n') = '\0';
+		format_add(ft, "message_text", "%s", msg->msg);
+		format_add(ft, "message_number", "%u", msg->msg_num);
+		format_add_tv(ft, "message_time", &msg->msg_time);
 
-		cmdq_print(item, "%s %s", tim, msg->msg);
+		s = format_expand(ft, SHOW_MESSAGES_TEMPLATE);
+		cmdq_print(item, "%s", s);
+		free(s);
 	}
+	format_free(ft);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-show-options.c

@@ -64,10 +64,10 @@ const struct cmd_entry cmd_show_hooks_entry = {
 	.name = "show-hooks",
 	.alias = NULL,
 
-	.args = { "gt:", 0, 1 },
+	.args = { "gpt:w", 0, 1 },
-	.usage = "[-g] " CMD_TARGET_SESSION_USAGE,
+	.usage = "[-gpw] " CMD_TARGET_PANE_USAGE,
 
-	.target = { 't', CMD_FIND_SESSION, 0 },
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_options_exec
@@ -76,20 +76,18 @@ const struct cmd_entry cmd_show_hooks_entry = {
 static enum cmd_retval
 cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
-	struct cmd_find_state		*fs = &item->target;
+	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct client			*c = cmd_find_client(item, NULL, 1);
-	struct session			*s = item->target.s;
-	struct winlink			*wl = item->target.wl;
 	struct options			*oo;
 	char				*argument, *name = NULL, *cause;
 	int				 window, idx, ambiguous, parent, scope;
 	struct options_entry		*o;
 
-	window = (self->entry == &cmd_show_window_options_entry);
+	window = (cmd_get_entry(self) == &cmd_show_window_options_entry);
 
 	if (args->argc == 0) {
-		scope = options_scope_from_flags(args, window, fs, &oo, &cause);
+		scope = options_scope_from_flags(args, window, target, &oo,
+		    &cause);
 		if (scope == OPTIONS_TABLE_NONE) {
 			if (args_has(args, 'q'))
 				return (CMD_RETURN_NORMAL);
@@ -99,7 +97,7 @@ cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 		}
 		return (cmd_show_options_all(self, item, scope, oo));
 	}
-	argument = format_single(item, args->argv[0], c, s, wl, NULL);
+	argument = format_single_from_target(item, args->argv[0]);
 
 	name = options_match(argument, &idx, &ambiguous);
 	if (name == NULL) {
@@ -111,7 +109,8 @@ cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "invalid option: %s", argument);
 		goto fail;
 	}
-	scope = options_scope_from_name(args, window, name, fs, &oo, &cause);
+	scope = options_scope_from_name(args, window, name, target, &oo,
+	    &cause);
 	if (scope == OPTIONS_TABLE_NONE) {
 		if (args_has(args, 'q'))
 			goto fail;
@@ -142,6 +141,7 @@ static void
 cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
     struct options_entry *o, int idx, int parent)
 {
+	struct args			*args = cmd_get_args(self);
 	struct options_array_item	*a;
 	const char			*name = options_name(o);
 	char				*value, *tmp = NULL, *escaped;
@@ -150,10 +150,10 @@ cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
 		xasprintf(&tmp, "%s[%d]", name, idx);
 		name = tmp;
 	} else {
-		if (options_isarray(o)) {
+		if (options_is_array(o)) {
 			a = options_array_first(o);
 			if (a == NULL) {
-				if (!args_has(self->args, 'v'))
+				if (!args_has(args, 'v'))
 					cmdq_print(item, "%s", name);
 				return;
 			}
@@ -167,10 +167,10 @@ cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
 		}
 	}
 
-	value = options_tostring(o, idx, 0);
+	value = options_to_string(o, idx, 0);
-	if (args_has(self->args, 'v'))
+	if (args_has(args, 'v'))
 		cmdq_print(item, "%s", value);
-	else if (options_isstring(o)) {
+	else if (options_is_string(o)) {
 		escaped = args_escape(value);
 		if (parent)
 			cmdq_print(item, "%s* %s", name, escaped);
@@ -192,6 +192,7 @@ static enum cmd_retval
 cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
     struct options *oo)
 {
+	struct args				*args = cmd_get_args(self);
 	const struct options_table_entry	*oe;
 	struct options_entry			*o;
 	struct options_array_item		*a;
@@ -199,28 +200,28 @@ cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
 	u_int					 idx;
 	int					 parent;
 
-	o = options_first(oo);
+	if (cmd_get_entry(self) != &cmd_show_hooks_entry) {
-	while (o != NULL) {
+		o = options_first(oo);
-		if (options_table_entry(o) == NULL)
+		while (o != NULL) {
-			cmd_show_options_print(self, item, o, -1, 0);
+			if (options_table_entry(o) == NULL)
-		o = options_next(o);
+				cmd_show_options_print(self, item, o, -1, 0);
+			o = options_next(o);
+		}
 	}
 	for (oe = options_table; oe->name != NULL; oe++) {
 		if (~oe->scope & scope)
 			continue;
 
-		if ((self->entry != &cmd_show_hooks_entry &&
+		if ((cmd_get_entry(self) != &cmd_show_hooks_entry &&
-		    !args_has(self->args, 'H') &&
+		    !args_has(args, 'H') &&
-		    oe != NULL &&
 		    (oe->flags & OPTIONS_TABLE_IS_HOOK)) ||
-		    (self->entry == &cmd_show_hooks_entry &&
+		    (cmd_get_entry(self) == &cmd_show_hooks_entry &&
-		    (oe == NULL ||
+		    (~oe->flags & OPTIONS_TABLE_IS_HOOK)))
-		    (~oe->flags & OPTIONS_TABLE_IS_HOOK))))
 			continue;
 
 		o = options_get_only(oo, oe->name);
 		if (o == NULL) {
-			if (!args_has(self->args, 'A'))
+			if (!args_has(args, 'A'))
 				continue;
 			o = options_get(oo, oe->name);
 			if (o == NULL)
@@ -229,10 +230,10 @@ cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
 		} else
 			parent = 0;
 
-		if (!options_isarray(o))
+		if (!options_is_array(o))
 			cmd_show_options_print(self, item, o, -1, parent);
 		else if ((a = options_array_first(o)) == NULL) {
-			if (!args_has(self->args, 'v')) {
+			if (!args_has(args, 'v')) {
 				name = options_name(o);
 				if (parent)
 					cmdq_print(item, "%s*", name);

cmd-source-file.c

@@ -35,8 +35,8 @@ const struct cmd_entry cmd_source_file_entry = {
 	.name = "source-file",
 	.alias = "source",
 
-	.args = { "nqv", 1, -1 },
+	.args = { "Fnqv", 1, -1 },
-	.usage = "[-nqv] path ...",
+	.usage = "[-Fnqv] path ...",
 
 	.flags = 0,
 	.exec = cmd_source_file_exec
@@ -122,11 +122,11 @@ cmd_source_file_add(struct cmd_source_file_data *cdata, const char *path)
 static enum cmd_retval
 cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
 	struct cmd_source_file_data	*cdata;
-	struct client			*c = item->client;
+	struct client			*c = cmdq_get_client(item);
 	enum cmd_retval			 retval = CMD_RETURN_NORMAL;
-	char				*pattern, *cwd;
+	char				*pattern, *cwd, *expand = NULL;
 	const char			*path, *error;
 	glob_t				 g;
 	int				 i, result;
@@ -145,7 +145,12 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 	utf8_stravis(&cwd, server_client_get_cwd(c, NULL), VIS_GLOB);
 
 	for (i = 0; i < args->argc; i++) {
-		path = args->argv[i];
+		if (args_has(args, 'F')) {
+			free(expand);
+			expand = format_single_from_target(item, args->argv[i]);
+			path = expand;
+		} else
+			path = args->argv[i];
 		if (strcmp(path, "-") == 0) {
 			cmd_source_file_add(cdata, "-");
 			continue;
@@ -172,6 +177,7 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 			free(pattern);
 			continue;
 		}
+		free(expand);
 		free(pattern);
 
 		for (j = 0; j < g.gl_pathc; j++)

cmd-split-window.c

@@ -39,8 +39,8 @@ const struct cmd_entry cmd_split_window_entry = {
 	.name = "split-window",
 	.alias = "splitw",
 
-	.args = { "bc:de:fF:hIl:p:Pt:v", 0, -1 },
+	.args = { "bc:de:fF:hIl:p:Pt:vZ", 0, -1 },
-	.usage = "[-bdefhIPv] [-c start-directory] [-e environment] "
+	.usage = "[-bdefhIPvZ] [-c start-directory] [-e environment] "
 		 "[-F format] [-l size] " CMD_TARGET_PANE_USAGE " [command]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -52,13 +52,14 @@ const struct cmd_entry cmd_split_window_entry = {
 static enum cmd_retval
 cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = &item->shared->current;
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct spawn_context	 sc;
-	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct client		*tc = cmdq_get_target_client(item);
-	struct session		*s = item->target.s;
+	struct session		*s = target->s;
-	struct winlink		*wl = item->target.wl;
+	struct winlink		*wl = target->wl;
-	struct window_pane	*wp = item->target.wp, *new_wp;
+	struct window_pane	*wp = target->wp, *new_wp;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
 	struct cmd_find_state	 fs;
@@ -109,7 +110,7 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	} else
 		size = -1;
 
-	server_unzoom_window(wp->window);
+	window_push_zoom(wp->window, 1, args_has(args, 'Z'));
 	input = (args_has(args, 'I') && args->argc == 0);
 
 	flags = 0;
@@ -141,7 +142,7 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 
 	add = args_first_value(args, 'e', &value);
 	while (add != NULL) {
-		environ_put(sc.environ, add);
+		environ_put(sc.environ, add, 0);
 		add = args_next_value(&value);
 	}
 
@@ -151,6 +152,8 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	sc.flags = flags;
 	if (args_has(args, 'd'))
 		sc.flags |= SPAWN_DETACHED;
+	if (args_has(args, 'Z'))
+		sc.flags |= SPAWN_ZOOM;
 
 	if ((new_wp = spawn_pane(&sc, &cause)) == NULL) {
 		cmdq_error(item, "create pane failed: %s", cause);
@@ -158,6 +161,7 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_ERROR);
 	}
 	if (input && window_pane_start_input(new_wp, item, &cause) != 0) {
+		server_client_remove_pane(new_wp);
 		layout_close_pane(new_wp);
 		window_remove_pane(wp->window, new_wp);
 		cmdq_error(item, "%s", cause);
@@ -166,13 +170,14 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	}
 	if (!args_has(args, 'd'))
 		cmd_find_from_winlink_pane(current, wl, new_wp, 0);
+	window_pop_zoom(wp->window);
 	server_redraw_window(wp->window);
 	server_status_session(s);
 
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = SPLIT_WINDOW_TEMPLATE;
-		cp = format_single(item, template, c, s, wl, new_wp);
+		cp = format_single(item, template, tc, s, wl, new_wp);
 		cmdq_print(item, "%s", cp);
 		free(cp);
 	}

cmd-swap-pane.c

@@ -45,18 +45,20 @@ const struct cmd_entry cmd_swap_pane_entry = {
 static enum cmd_retval
 cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct window		*src_w, *dst_w;
 	struct window_pane	*tmp_wp, *src_wp, *dst_wp;
 	struct layout_cell	*src_lc, *dst_lc;
 	u_int			 sx, sy, xoff, yoff;
 
-	dst_w = item->target.wl->window;
+	dst_w = target->wl->window;
-	dst_wp = item->target.wp;
+	dst_wp = target->wp;
-	src_w = item->source.wl->window;
+	src_w = source->wl->window;
-	src_wp = item->source.wp;
+	src_wp = source->wp;
 
-	if (window_push_zoom(dst_w, args_has(args, 'Z')))
+	if (window_push_zoom(dst_w, 0, args_has(args, 'Z')))
 		server_redraw_window(dst_w);
 
 	if (args_has(args, 'D')) {
@@ -71,12 +73,15 @@ cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 			src_wp = TAILQ_LAST(&dst_w->panes, window_panes);
 	}
 
-	if (src_w != dst_w && window_push_zoom(src_w, args_has(args, 'Z')))
+	if (src_w != dst_w && window_push_zoom(src_w, 0, args_has(args, 'Z')))
 		server_redraw_window(src_w);
 
 	if (src_wp == dst_wp)
 		goto out;
 
+	server_client_remove_pane(src_wp);
+	server_client_remove_pane(dst_wp);
+
 	tmp_wp = TAILQ_PREV(dst_wp, window_panes, entry);
 	TAILQ_REMOVE(&dst_w->panes, dst_wp, entry);
 	TAILQ_REPLACE(&src_w->panes, src_wp, dst_wp, entry);

cmd-swap-window.c

@@ -45,20 +45,20 @@ const struct cmd_entry cmd_swap_window_entry = {
 static enum cmd_retval
 cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct session		*src, *dst;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct session		*src = source->s, *dst = target->s;
 	struct session_group	*sg_src, *sg_dst;
-	struct winlink		*wl_src, *wl_dst;
+	struct winlink		*wl_src = source->wl, *wl_dst = target->wl;
 	struct window		*w_src, *w_dst;
 
-	wl_src = item->source.wl;
-	src = item->source.s;
 	sg_src = session_group_contains(src);
-
-	wl_dst = item->target.wl;
-	dst = item->target.s;
 	sg_dst = session_group_contains(dst);
 
-	if (src != dst && sg_src != NULL && sg_dst != NULL &&
+	if (src != dst &&
+	    sg_src != NULL &&
+	    sg_dst != NULL &&
 	    sg_src == sg_dst) {
 		cmdq_error(item, "can't move window, sessions are grouped");
 		return (CMD_RETURN_ERROR);
@@ -77,7 +77,7 @@ cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
 	wl_src->window = w_dst;
 	TAILQ_INSERT_TAIL(&w_dst->winlinks, wl_src, wentry);
 
-	if (args_has(self->args, 'd')) {
+	if (args_has(args, 'd')) {
 		session_select(dst, wl_dst->idx);
 		if (src != dst)
 			session_select(src, wl_src->idx);

cmd-switch-client.c

@@ -34,24 +34,26 @@ const struct cmd_entry cmd_switch_client_entry = {
 	.name = "switch-client",
 	.alias = "switchc",
 
-	.args = { "lc:Enpt:rT:Z", 0, 0 },
+	.args = { "lc:EFnpt:rT:Z", 0, 0 },
 	.usage = "[-ElnprZ] [-c target-client] [-t target-session] "
 		 "[-T key-table]",
 
 	/* -t is special */
 
-	.flags = CMD_READONLY,
+	.flags = CMD_READONLY|CMD_CLIENT_CFLAG,
 	.exec = cmd_switch_client_exec
 };
 
 static enum cmd_retval
 cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	 target;
 	const char		*tflag = args_get(args, 't');
 	enum cmd_find_type	 type;
 	int			 flags;
-	struct client		*c;
+	struct client		*tc = cmdq_get_target_client(item);
 	struct session		*s;
 	struct winlink		*wl;
 	struct window		*w;
@@ -59,9 +61,6 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 	const char		*tablename;
 	struct key_table	*table;
 
-	if ((c = cmd_find_client(item, args_get(args, 'c'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
-
 	if (tflag != NULL && tflag[strcspn(tflag, ":.%")] != '\0') {
 		type = CMD_FIND_PANE;
 		flags = 0;
@@ -69,15 +68,18 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 		type = CMD_FIND_SESSION;
 		flags = CMD_FIND_PREFER_UNATTACHED;
 	}
-	if (cmd_find_target(&item->target, item, tflag, type, flags) != 0)
+	if (cmd_find_target(&target, item, tflag, type, flags) != 0)
 		return (CMD_RETURN_ERROR);
-	s = item->target.s;
+	s = target.s;
-	wl = item->target.wl;
+	wl = target.wl;
-	w = wl->window;
+	wp = target.wp;
-	wp = item->target.wp;
 
-	if (args_has(args, 'r'))
+	if (args_has(args, 'r')) {
-		c->flags ^= CLIENT_READONLY;
+		if (tc->flags & CLIENT_READONLY)
+			tc->flags &= ~(CLIENT_READONLY|CLIENT_IGNORESIZE);
+		else
+			tc->flags |= (CLIENT_READONLY|CLIENT_IGNORESIZE);
+	}
 
 	tablename = args_get(args, 'T');
 	if (tablename != NULL) {
@@ -87,24 +89,24 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 			return (CMD_RETURN_ERROR);
 		}
 		table->references++;
-		key_bindings_unref_table(c->keytable);
+		key_bindings_unref_table(tc->keytable);
-		c->keytable = table;
+		tc->keytable = table;
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (args_has(args, 'n')) {
-		if ((s = session_next_session(c->session)) == NULL) {
+		if ((s = session_next_session(tc->session)) == NULL) {
 			cmdq_error(item, "can't find next session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'p')) {
-		if ((s = session_previous_session(c->session)) == NULL) {
+		if ((s = session_previous_session(tc->session)) == NULL) {
 			cmdq_error(item, "can't find previous session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'l')) {
-		if (c->last_session != NULL && session_alive(c->last_session))
+		if (tc->last_session != NULL && session_alive(tc->last_session))
-			s = c->last_session;
+			s = tc->last_session;
 		else
 			s = NULL;
 		if (s == NULL) {
@@ -112,10 +114,11 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
-		if (item->client == NULL)
+		if (cmdq_get_client(item) == NULL)
 			return (CMD_RETURN_NORMAL);
-		if (wl != NULL && wp != NULL) {
+		if (wl != NULL && wp != NULL && wp != wl->window->active) {
-			if (window_push_zoom(w, args_has(self->args, 'Z')))
+			w = wl->window;
+			if (window_push_zoom(w, 0, args_has(args, 'Z')))
 				server_redraw_window(w);
 			window_redraw_active_switch(w, wp);
 			window_set_active_pane(w, wp, 1);
@@ -124,28 +127,28 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 		}
 		if (wl != NULL) {
 			session_set_current(s, wl);
-			cmd_find_from_session(&item->shared->current, s, 0);
+			cmd_find_from_session(current, s, 0);
 		}
 	}
 
 	if (!args_has(args, 'E'))
-		environ_update(s->options, c->environ, s->environ);
+		environ_update(s->options, tc->environ, s->environ);
 
-	if (c->session != NULL && c->session != s)
+	if (tc->session != NULL && tc->session != s)
-		c->last_session = c->session;
+		tc->last_session = tc->session;
-	c->session = s;
+	tc->session = s;
-	if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+	if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
-		server_client_set_key_table(c, NULL);
+		server_client_set_key_table(tc, NULL);
-	tty_update_client_offset(c);
+	tty_update_client_offset(tc);
-	status_timer_start(c);
+	status_timer_start(tc);
-	notify_client("client-session-changed", c);
+	notify_client("client-session-changed", tc);
 	session_update_activity(s, NULL);
 	gettimeofday(&s->last_attached_time, NULL);
 
 	server_check_unattached();
-	server_redraw_client(c);
+	server_redraw_client(tc);
 	s->curw->flags &= ~WINLINK_ALERTFLAGS;
-	s->curw->window->latest = c;
+	s->curw->window->latest = tc;
 	recalculate_sizes();
 	alerts_check_session(s);
 

cmd-unbind-key.c

@@ -32,8 +32,8 @@ const struct cmd_entry cmd_unbind_key_entry = {
 	.name = "unbind-key",
 	.alias = "unbind",
 
-	.args = { "anT:", 0, 1 },
+	.args = { "anqT:", 0, 1 },
-	.usage = "[-an] [-T key-table] key",
+	.usage = "[-anq] [-T key-table] key",
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_unbind_key_exec
@@ -42,47 +42,57 @@ const struct cmd_entry cmd_unbind_key_entry = {
 static enum cmd_retval
 cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args	*args = cmd_get_args(self);
 	key_code	 key;
 	const char	*tablename;
+	int		 quiet = args_has(args, 'q');
 
-	if (!args_has(args, 'a')) {
+	if (args_has(args, 'a')) {
-		if (args->argc != 1) {
-			cmdq_error(item, "missing key");
-			return (CMD_RETURN_ERROR);
-		}
-		key = key_string_lookup_string(args->argv[0]);
-		if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
-			cmdq_error(item, "unknown key: %s", args->argv[0]);
-			return (CMD_RETURN_ERROR);
-		}
-	} else {
 		if (args->argc != 0) {
-			cmdq_error(item, "key given with -a");
+			if (!quiet)
+				cmdq_error(item, "key given with -a");
 			return (CMD_RETURN_ERROR);
 		}
-		key = KEYC_UNKNOWN;
-	}
 
-	if (key == KEYC_UNKNOWN) {
 		tablename = args_get(args, 'T');
 		if (tablename == NULL) {
-			key_bindings_remove_table("root");
+			if (args_has(args, 'n'))
-			key_bindings_remove_table("prefix");
+				tablename = "root";
-			return (CMD_RETURN_NORMAL);
+			else
+				tablename = "prefix";
 		}
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(item, "table %s doesn't exist", tablename);
+			if (!quiet) {
+				cmdq_error(item, "table %s doesn't exist" ,
+				    tablename);
+			}
 			return (CMD_RETURN_ERROR);
 		}
+
 		key_bindings_remove_table(tablename);
 		return (CMD_RETURN_NORMAL);
 	}
 
+	if (args->argc != 1) {
+		if (!quiet)
+			cmdq_error(item, "missing key");
+		return (CMD_RETURN_ERROR);
+	}
+
+	key = key_string_lookup_string(args->argv[0]);
+	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
+		if (!quiet)
+			cmdq_error(item, "unknown key: %s", args->argv[0]);
+		return (CMD_RETURN_ERROR);
+	}
+
 	if (args_has(args, 'T')) {
 		tablename = args_get(args, 'T');
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(item, "table %s doesn't exist", tablename);
+			if (!quiet) {
+				cmdq_error(item, "table %s doesn't exist" ,
+				    tablename);
+			}
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'n'))

cmd-wait-for.c

@@ -120,7 +120,7 @@ cmd_wait_for_remove(struct wait_channel *wc)
 static enum cmd_retval
 cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args     	*args = self->args;
+	struct args     	*args = cmd_get_args(self);
 	const char		*name = args->argv[0];
 	struct wait_channel	*wc, wc0;
 
@@ -167,7 +167,7 @@ static enum cmd_retval
 cmd_wait_for_wait(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	struct client		*c = item->client;
+	struct client		*c = cmdq_get_client(item);
 	struct wait_item	*wi;
 
 	if (c == NULL) {
@@ -198,7 +198,7 @@ cmd_wait_for_lock(struct cmdq_item *item, const char *name,
 {
 	struct wait_item	*wi;
 
-	if (item->client == NULL) {
+	if (cmdq_get_client(item) == NULL) {
 		cmdq_error(item, "not able to lock");
 		return (CMD_RETURN_ERROR);
 	}

cmd.c

@@ -39,10 +39,12 @@ extern const struct cmd_entry cmd_clock_mode_entry;
 extern const struct cmd_entry cmd_command_prompt_entry;
 extern const struct cmd_entry cmd_confirm_before_entry;
 extern const struct cmd_entry cmd_copy_mode_entry;
+extern const struct cmd_entry cmd_customize_mode_entry;
 extern const struct cmd_entry cmd_delete_buffer_entry;
 extern const struct cmd_entry cmd_detach_client_entry;
 extern const struct cmd_entry cmd_display_menu_entry;
 extern const struct cmd_entry cmd_display_message_entry;
+extern const struct cmd_entry cmd_display_popup_entry;
 extern const struct cmd_entry cmd_display_panes_entry;
 extern const struct cmd_entry cmd_down_pane_entry;
 extern const struct cmd_entry cmd_find_window_entry;
@@ -128,10 +130,12 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_command_prompt_entry,
 	&cmd_confirm_before_entry,
 	&cmd_copy_mode_entry,
+	&cmd_customize_mode_entry,
 	&cmd_delete_buffer_entry,
 	&cmd_detach_client_entry,
 	&cmd_display_menu_entry,
 	&cmd_display_message_entry,
+	&cmd_display_popup_entry,
 	&cmd_display_panes_entry,
 	&cmd_find_window_entry,
 	&cmd_has_session_entry,
@@ -204,8 +208,27 @@ const struct cmd_entry *cmd_table[] = {
 	NULL
 };
 
+/* Instance of a command. */
+struct cmd {
+	const struct cmd_entry	 *entry;
+	struct args		 *args;
+	u_int			  group;
+
+	char			 *file;
+	u_int			  line;
+
+	char			 *alias;
+	int			  argc;
+	char			**argv;
+
+	TAILQ_ENTRY(cmd)	  qentry;
+};
+TAILQ_HEAD(cmds, cmd);
+
+/* Next group number for new command list. */
 static u_int cmd_list_next_group = 1;
 
+/* Log an argument vector. */
 void printflike(3, 4)
 cmd_log_argv(int argc, char **argv, const char *fmt, ...)
 {
@@ -222,6 +245,7 @@ cmd_log_argv(int argc, char **argv, const char *fmt, ...)
 	free(prefix);
 }
 
+/* Prepend to an argument vector. */
 void
 cmd_prepend_argv(int *argc, char ***argv, char *arg)
 {
@@ -238,6 +262,7 @@ cmd_prepend_argv(int *argc, char ***argv, char *arg)
 	(*argc)++;
 }
 
+/* Append to an argument vector. */
 void
 cmd_append_argv(int *argc, char ***argv, char *arg)
 {
@@ -245,6 +270,7 @@ cmd_append_argv(int *argc, char ***argv, char *arg)
 	(*argv)[(*argc)++] = xstrdup(arg);
 }
 
+/* Pack an argument vector up into a buffer. */
 int
 cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 {
@@ -267,6 +293,7 @@ cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 	return (0);
 }
 
+/* Unpack an argument vector from a packed buffer. */
 int
 cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 {
@@ -295,6 +322,7 @@ cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 	return (0);
 }
 
+/* Copy an argument vector, ensuring it is terminated by NULL. */
 char **
 cmd_copy_argv(int argc, char **argv)
 {
@@ -311,6 +339,7 @@ cmd_copy_argv(int argc, char **argv)
 	return (new_argv);
 }
 
+/* Free an argument vector. */
 void
 cmd_free_argv(int argc, char **argv)
 {
@@ -323,32 +352,67 @@ cmd_free_argv(int argc, char **argv)
 	free(argv);
 }
 
+/* Convert argument vector to a string. */
 char *
 cmd_stringify_argv(int argc, char **argv)
 {
-	char	*buf;
+	char	*buf = NULL, *s;
+	size_t	 len = 0;
 	int	 i;
-	size_t	 len;
 
 	if (argc == 0)
 		return (xstrdup(""));
 
-	len = 0;
-	buf = NULL;
-
 	for (i = 0; i < argc; i++) {
-		len += strlen(argv[i]) + 1;
+		s = args_escape(argv[i]);
+		log_debug("%s: %u %s = %s", __func__, i, argv[i], s);
+
+		len += strlen(s) + 1;
 		buf = xrealloc(buf, len);
 
 		if (i == 0)
 			*buf = '\0';
 		else
 			strlcat(buf, " ", len);
-		strlcat(buf, argv[i], len);
+		strlcat(buf, s, len);
+
+		free(s);
 	}
 	return (buf);
 }
 
+/* Get entry for command. */
+const struct cmd_entry *
+cmd_get_entry(struct cmd *cmd)
+{
+	return (cmd->entry);
+}
+
+/* Get arguments for command. */
+struct args *
+cmd_get_args(struct cmd *cmd)
+{
+	return (cmd->args);
+}
+
+/* Get group for command. */
+u_int
+cmd_get_group(struct cmd *cmd)
+{
+	return (cmd->group);
+}
+
+/* Get file and line for command. */
+void
+cmd_get_source(struct cmd *cmd, const char **file, u_int *line)
+{
+	if (file != NULL)
+		*file = cmd->file;
+	if (line != NULL)
+		*line = cmd->line;
+}
+
+/* Look for an alias for a command. */
 char *
 cmd_get_alias(const char *name)
 {
@@ -379,6 +443,7 @@ cmd_get_alias(const char *name)
 	return (NULL);
 }
 
+/* Look up a command entry by name. */
 static const struct cmd_entry *
 cmd_find(const char *name, char **cause)
 {
@@ -428,6 +493,7 @@ ambiguous:
 	return (NULL);
 }
 
+/* Parse a single command from an argument vector. */
 struct cmd *
 cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
 {
@@ -476,6 +542,7 @@ usage:
 	return (NULL);
 }
 
+/* Free a command. */
 void
 cmd_free(struct cmd *cmd)
 {
@@ -488,6 +555,7 @@ cmd_free(struct cmd *cmd)
 	free(cmd);
 }
 
+/* Get a command as a string. */
 char *
 cmd_print(struct cmd *cmd)
 {
@@ -503,6 +571,7 @@ cmd_print(struct cmd *cmd)
 	return (out);
 }
 
+/* Create a new command list. */
 struct cmd_list *
 cmd_list_new(void)
 {
@@ -511,29 +580,28 @@ cmd_list_new(void)
 	cmdlist = xcalloc(1, sizeof *cmdlist);
 	cmdlist->references = 1;
 	cmdlist->group = cmd_list_next_group++;
-	TAILQ_INIT(&cmdlist->list);
+	cmdlist->list = xcalloc(1, sizeof *cmdlist->list);
+	TAILQ_INIT(cmdlist->list);
 	return (cmdlist);
 }
 
+/* Append a command to a command list. */
 void
 cmd_list_append(struct cmd_list *cmdlist, struct cmd *cmd)
 {
 	cmd->group = cmdlist->group;
-	TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
+	TAILQ_INSERT_TAIL(cmdlist->list, cmd, qentry);
 }
 
+/* Move all commands from one command list to another */
 void
 cmd_list_move(struct cmd_list *cmdlist, struct cmd_list *from)
 {
-	struct cmd	*cmd, *cmd1;
+	TAILQ_CONCAT(cmdlist->list, from->list, qentry);
-
-	TAILQ_FOREACH_SAFE(cmd, &from->list, qentry, cmd1) {
-		TAILQ_REMOVE(&from->list, cmd, qentry);
-		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
-	}
 	cmdlist->group = cmd_list_next_group++;
 }
 
+/* Free a command list. */
 void
 cmd_list_free(struct cmd_list *cmdlist)
 {
@@ -542,36 +610,46 @@ cmd_list_free(struct cmd_list *cmdlist)
 	if (--cmdlist->references != 0)
 		return;
 
-	TAILQ_FOREACH_SAFE(cmd, &cmdlist->list, qentry, cmd1) {
+	TAILQ_FOREACH_SAFE(cmd, cmdlist->list, qentry, cmd1) {
-		TAILQ_REMOVE(&cmdlist->list, cmd, qentry);
+		TAILQ_REMOVE(cmdlist->list, cmd, qentry);
 		cmd_free(cmd);
 	}
-
+	free(cmdlist->list);
 	free(cmdlist);
 }
 
+/* Get a command list as a string. */
 char *
 cmd_list_print(struct cmd_list *cmdlist, int escaped)
 {
-	struct cmd	*cmd;
+	struct cmd	*cmd, *next;
 	char		*buf, *this;
 	size_t		 len;
 
 	len = 1;
 	buf = xcalloc(1, len);
 
-	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
 		this = cmd_print(cmd);
 
-		len += strlen(this) + 4;
+		len += strlen(this) + 6;
 		buf = xrealloc(buf, len);
 
 		strlcat(buf, this, len);
-		if (TAILQ_NEXT(cmd, qentry) != NULL) {
+
-			if (escaped)
+		next = TAILQ_NEXT(cmd, qentry);
-				strlcat(buf, " \\; ", len);
+		if (next != NULL) {
-			else
+			if (cmd->group != next->group) {
-				strlcat(buf, " ; ", len);
+				if (escaped)
+					strlcat(buf, " \\;\\; ", len);
+				else
+					strlcat(buf, " ;; ", len);
+			} else {
+				if (escaped)
+					strlcat(buf, " \\; ", len);
+				else
+					strlcat(buf, " ; ", len);
+			}
 		}
 
 		free(this);
@@ -580,6 +658,46 @@ cmd_list_print(struct cmd_list *cmdlist, int escaped)
 	return (buf);
 }
 
+/* Get first command in list. */
+struct cmd *
+cmd_list_first(struct cmd_list *cmdlist)
+{
+	return (TAILQ_FIRST(cmdlist->list));
+}
+
+/* Get next command in list. */
+struct cmd *
+cmd_list_next(struct cmd *cmd)
+{
+	return (TAILQ_NEXT(cmd, qentry));
+}
+
+/* Do all of the commands in this command list have this flag? */
+int
+cmd_list_all_have(struct cmd_list *cmdlist, int flag)
+{
+	struct cmd	*cmd;
+
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		if (~cmd->entry->flags & flag)
+			return (0);
+	}
+	return (1);
+}
+
+/* Do any of the commands in this command list have this flag? */
+int
+cmd_list_any_have(struct cmd_list *cmdlist, int flag)
+{
+	struct cmd	*cmd;
+
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		if (cmd->entry->flags & flag)
+			return (1);
+	}
+	return (0);
+}
+
 /* Adjust current mouse position for a pane. */
 int
 cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,

colour.c

@@ -22,6 +22,7 @@
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
+#include <math.h>
 
 #include "tmux.h"
 
@@ -111,6 +112,9 @@ colour_tostring(int c)
 	static char	s[32];
 	u_char		r, g, b;
 
+	if (c == -1)
+		return ("invalid");
+
 	if (c & COLOUR_FLAG_RGB) {
 		colour_split_rgb(c, &r, &g, &b);
 		xsnprintf(s, sizeof s, "#%02x%02x%02x", r, g, b);
@@ -189,6 +193,12 @@ colour_fromstring(const char *s)
 			return (-1);
 		return (n | COLOUR_FLAG_256);
 	}
+	if (strncasecmp(s, "color", (sizeof "color") - 1) == 0) {
+		n = strtonum(s + (sizeof "color") - 1, 0, 255, &errstr);
+		if (errstr != NULL)
+			return (-1);
+		return (n | COLOUR_FLAG_256);
+	}
 
 	if (strcasecmp(s, "default") == 0)
 		return (8);
@@ -227,7 +237,7 @@ colour_fromstring(const char *s)
 		return (96);
 	if (strcasecmp(s, "brightwhite") == 0 || strcmp(s, "97") == 0)
 		return (97);
-	return (-1);
+	return (colour_byname(s));
 }
 
 /* Convert 256 colour to RGB colour. */
@@ -329,3 +339,608 @@ colour_256to16(int c)
 
 	return (table[c & 0xff]);
 }
+
+/* Get colour by X11 colour name. */
+int
+colour_byname(const char *name)
+{
+	static const struct {
+		const char	*name;
+		int		 c;
+	} colours[] = {
+		{ "AliceBlue", 0xf0f8ff },
+		{ "AntiqueWhite", 0xfaebd7 },
+		{ "AntiqueWhite1", 0xffefdb },
+		{ "AntiqueWhite2", 0xeedfcc },
+		{ "AntiqueWhite3", 0xcdc0b0 },
+		{ "AntiqueWhite4", 0x8b8378 },
+		{ "BlanchedAlmond", 0xffebcd },
+		{ "BlueViolet", 0x8a2be2 },
+		{ "CadetBlue", 0x5f9ea0 },
+		{ "CadetBlue1", 0x98f5ff },
+		{ "CadetBlue2", 0x8ee5ee },
+		{ "CadetBlue3", 0x7ac5cd },
+		{ "CadetBlue4", 0x53868b },
+		{ "CornflowerBlue", 0x6495ed },
+		{ "DarkBlue", 0x00008b },
+		{ "DarkCyan", 0x008b8b },
+		{ "DarkGoldenrod", 0xb8860b },
+		{ "DarkGoldenrod1", 0xffb90f },
+		{ "DarkGoldenrod2", 0xeead0e },
+		{ "DarkGoldenrod3", 0xcd950c },
+		{ "DarkGoldenrod4", 0x8b6508 },
+		{ "DarkGray", 0xa9a9a9 },
+		{ "DarkGreen", 0x006400 },
+		{ "DarkGrey", 0xa9a9a9 },
+		{ "DarkKhaki", 0xbdb76b },
+		{ "DarkMagenta", 0x8b008b },
+		{ "DarkOliveGreen", 0x556b2f },
+		{ "DarkOliveGreen1", 0xcaff70 },
+		{ "DarkOliveGreen2", 0xbcee68 },
+		{ "DarkOliveGreen3", 0xa2cd5a },
+		{ "DarkOliveGreen4", 0x6e8b3d },
+		{ "DarkOrange", 0xff8c00 },
+		{ "DarkOrange1", 0xff7f00 },
+		{ "DarkOrange2", 0xee7600 },
+		{ "DarkOrange3", 0xcd6600 },
+		{ "DarkOrange4", 0x8b4500 },
+		{ "DarkOrchid", 0x9932cc },
+		{ "DarkOrchid1", 0xbf3eff },
+		{ "DarkOrchid2", 0xb23aee },
+		{ "DarkOrchid3", 0x9a32cd },
+		{ "DarkOrchid4", 0x68228b },
+		{ "DarkRed", 0x8b0000 },
+		{ "DarkSalmon", 0xe9967a },
+		{ "DarkSeaGreen", 0x8fbc8f },
+		{ "DarkSeaGreen1", 0xc1ffc1 },
+		{ "DarkSeaGreen2", 0xb4eeb4 },
+		{ "DarkSeaGreen3", 0x9bcd9b },
+		{ "DarkSeaGreen4", 0x698b69 },
+		{ "DarkSlateBlue", 0x483d8b },
+		{ "DarkSlateGray", 0x2f4f4f },
+		{ "DarkSlateGray1", 0x97ffff },
+		{ "DarkSlateGray2", 0x8deeee },
+		{ "DarkSlateGray3", 0x79cdcd },
+		{ "DarkSlateGray4", 0x528b8b },
+		{ "DarkSlateGrey", 0x2f4f4f },
+		{ "DarkTurquoise", 0x00ced1 },
+		{ "DarkViolet", 0x9400d3 },
+		{ "DeepPink", 0xff1493 },
+		{ "DeepPink1", 0xff1493 },
+		{ "DeepPink2", 0xee1289 },
+		{ "DeepPink3", 0xcd1076 },
+		{ "DeepPink4", 0x8b0a50 },
+		{ "DeepSkyBlue", 0x00bfff },
+		{ "DeepSkyBlue1", 0x00bfff },
+		{ "DeepSkyBlue2", 0x00b2ee },
+		{ "DeepSkyBlue3", 0x009acd },
+		{ "DeepSkyBlue4", 0x00688b },
+		{ "DimGray", 0x696969 },
+		{ "DimGrey", 0x696969 },
+		{ "DodgerBlue", 0x1e90ff },
+		{ "DodgerBlue1", 0x1e90ff },
+		{ "DodgerBlue2", 0x1c86ee },
+		{ "DodgerBlue3", 0x1874cd },
+		{ "DodgerBlue4", 0x104e8b },
+		{ "FloralWhite", 0xfffaf0 },
+		{ "ForestGreen", 0x228b22 },
+		{ "GhostWhite", 0xf8f8ff },
+		{ "GreenYellow", 0xadff2f },
+		{ "HotPink", 0xff69b4 },
+		{ "HotPink1", 0xff6eb4 },
+		{ "HotPink2", 0xee6aa7 },
+		{ "HotPink3", 0xcd6090 },
+		{ "HotPink4", 0x8b3a62 },
+		{ "IndianRed", 0xcd5c5c },
+		{ "IndianRed1", 0xff6a6a },
+		{ "IndianRed2", 0xee6363 },
+		{ "IndianRed3", 0xcd5555 },
+		{ "IndianRed4", 0x8b3a3a },
+		{ "LavenderBlush", 0xfff0f5 },
+		{ "LavenderBlush1", 0xfff0f5 },
+		{ "LavenderBlush2", 0xeee0e5 },
+		{ "LavenderBlush3", 0xcdc1c5 },
+		{ "LavenderBlush4", 0x8b8386 },
+		{ "LawnGreen", 0x7cfc00 },
+		{ "LemonChiffon", 0xfffacd },
+		{ "LemonChiffon1", 0xfffacd },
+		{ "LemonChiffon2", 0xeee9bf },
+		{ "LemonChiffon3", 0xcdc9a5 },
+		{ "LemonChiffon4", 0x8b8970 },
+		{ "LightBlue", 0xadd8e6 },
+		{ "LightBlue1", 0xbfefff },
+		{ "LightBlue2", 0xb2dfee },
+		{ "LightBlue3", 0x9ac0cd },
+		{ "LightBlue4", 0x68838b },
+		{ "LightCoral", 0xf08080 },
+		{ "LightCyan", 0xe0ffff },
+		{ "LightCyan1", 0xe0ffff },
+		{ "LightCyan2", 0xd1eeee },
+		{ "LightCyan3", 0xb4cdcd },
+		{ "LightCyan4", 0x7a8b8b },
+		{ "LightGoldenrod", 0xeedd82 },
+		{ "LightGoldenrod1", 0xffec8b },
+		{ "LightGoldenrod2", 0xeedc82 },
+		{ "LightGoldenrod3", 0xcdbe70 },
+		{ "LightGoldenrod4", 0x8b814c },
+		{ "LightGoldenrodYellow", 0xfafad2 },
+		{ "LightGray", 0xd3d3d3 },
+		{ "LightGreen", 0x90ee90 },
+		{ "LightGrey", 0xd3d3d3 },
+		{ "LightPink", 0xffb6c1 },
+		{ "LightPink1", 0xffaeb9 },
+		{ "LightPink2", 0xeea2ad },
+		{ "LightPink3", 0xcd8c95 },
+		{ "LightPink4", 0x8b5f65 },
+		{ "LightSalmon", 0xffa07a },
+		{ "LightSalmon1", 0xffa07a },
+		{ "LightSalmon2", 0xee9572 },
+		{ "LightSalmon3", 0xcd8162 },
+		{ "LightSalmon4", 0x8b5742 },
+		{ "LightSeaGreen", 0x20b2aa },
+		{ "LightSkyBlue", 0x87cefa },
+		{ "LightSkyBlue1", 0xb0e2ff },
+		{ "LightSkyBlue2", 0xa4d3ee },
+		{ "LightSkyBlue3", 0x8db6cd },
+		{ "LightSkyBlue4", 0x607b8b },
+		{ "LightSlateBlue", 0x8470ff },
+		{ "LightSlateGray", 0x778899 },
+		{ "LightSlateGrey", 0x778899 },
+		{ "LightSteelBlue", 0xb0c4de },
+		{ "LightSteelBlue1", 0xcae1ff },
+		{ "LightSteelBlue2", 0xbcd2ee },
+		{ "LightSteelBlue3", 0xa2b5cd },
+		{ "LightSteelBlue4", 0x6e7b8b },
+		{ "LightYellow", 0xffffe0 },
+		{ "LightYellow1", 0xffffe0 },
+		{ "LightYellow2", 0xeeeed1 },
+		{ "LightYellow3", 0xcdcdb4 },
+		{ "LightYellow4", 0x8b8b7a },
+		{ "LimeGreen", 0x32cd32 },
+		{ "MediumAquamarine", 0x66cdaa },
+		{ "MediumBlue", 0x0000cd },
+		{ "MediumOrchid", 0xba55d3 },
+		{ "MediumOrchid1", 0xe066ff },
+		{ "MediumOrchid2", 0xd15fee },
+		{ "MediumOrchid3", 0xb452cd },
+		{ "MediumOrchid4", 0x7a378b },
+		{ "MediumPurple", 0x9370db },
+		{ "MediumPurple1", 0xab82ff },
+		{ "MediumPurple2", 0x9f79ee },
+		{ "MediumPurple3", 0x8968cd },
+		{ "MediumPurple4", 0x5d478b },
+		{ "MediumSeaGreen", 0x3cb371 },
+		{ "MediumSlateBlue", 0x7b68ee },
+		{ "MediumSpringGreen", 0x00fa9a },
+		{ "MediumTurquoise", 0x48d1cc },
+		{ "MediumVioletRed", 0xc71585 },
+		{ "MidnightBlue", 0x191970 },
+		{ "MintCream", 0xf5fffa },
+		{ "MistyRose", 0xffe4e1 },
+		{ "MistyRose1", 0xffe4e1 },
+		{ "MistyRose2", 0xeed5d2 },
+		{ "MistyRose3", 0xcdb7b5 },
+		{ "MistyRose4", 0x8b7d7b },
+		{ "NavajoWhite", 0xffdead },
+		{ "NavajoWhite1", 0xffdead },
+		{ "NavajoWhite2", 0xeecfa1 },
+		{ "NavajoWhite3", 0xcdb38b },
+		{ "NavajoWhite4", 0x8b795e },
+		{ "NavyBlue", 0x000080 },
+		{ "OldLace", 0xfdf5e6 },
+		{ "OliveDrab", 0x6b8e23 },
+		{ "OliveDrab1", 0xc0ff3e },
+		{ "OliveDrab2", 0xb3ee3a },
+		{ "OliveDrab3", 0x9acd32 },
+		{ "OliveDrab4", 0x698b22 },
+		{ "OrangeRed", 0xff4500 },
+		{ "OrangeRed1", 0xff4500 },
+		{ "OrangeRed2", 0xee4000 },
+		{ "OrangeRed3", 0xcd3700 },
+		{ "OrangeRed4", 0x8b2500 },
+		{ "PaleGoldenrod", 0xeee8aa },
+		{ "PaleGreen", 0x98fb98 },
+		{ "PaleGreen1", 0x9aff9a },
+		{ "PaleGreen2", 0x90ee90 },
+		{ "PaleGreen3", 0x7ccd7c },
+		{ "PaleGreen4", 0x548b54 },
+		{ "PaleTurquoise", 0xafeeee },
+		{ "PaleTurquoise1", 0xbbffff },
+		{ "PaleTurquoise2", 0xaeeeee },
+		{ "PaleTurquoise3", 0x96cdcd },
+		{ "PaleTurquoise4", 0x668b8b },
+		{ "PaleVioletRed", 0xdb7093 },
+		{ "PaleVioletRed1", 0xff82ab },
+		{ "PaleVioletRed2", 0xee799f },
+		{ "PaleVioletRed3", 0xcd6889 },
+		{ "PaleVioletRed4", 0x8b475d },
+		{ "PapayaWhip", 0xffefd5 },
+		{ "PeachPuff", 0xffdab9 },
+		{ "PeachPuff1", 0xffdab9 },
+		{ "PeachPuff2", 0xeecbad },
+		{ "PeachPuff3", 0xcdaf95 },
+		{ "PeachPuff4", 0x8b7765 },
+		{ "PowderBlue", 0xb0e0e6 },
+		{ "RebeccaPurple", 0x663399 },
+		{ "RosyBrown", 0xbc8f8f },
+		{ "RosyBrown1", 0xffc1c1 },
+		{ "RosyBrown2", 0xeeb4b4 },
+		{ "RosyBrown3", 0xcd9b9b },
+		{ "RosyBrown4", 0x8b6969 },
+		{ "RoyalBlue", 0x4169e1 },
+		{ "RoyalBlue1", 0x4876ff },
+		{ "RoyalBlue2", 0x436eee },
+		{ "RoyalBlue3", 0x3a5fcd },
+		{ "RoyalBlue4", 0x27408b },
+		{ "SaddleBrown", 0x8b4513 },
+		{ "SandyBrown", 0xf4a460 },
+		{ "SeaGreen", 0x2e8b57 },
+		{ "SeaGreen1", 0x54ff9f },
+		{ "SeaGreen2", 0x4eee94 },
+		{ "SeaGreen3", 0x43cd80 },
+		{ "SeaGreen4", 0x2e8b57 },
+		{ "SkyBlue", 0x87ceeb },
+		{ "SkyBlue1", 0x87ceff },
+		{ "SkyBlue2", 0x7ec0ee },
+		{ "SkyBlue3", 0x6ca6cd },
+		{ "SkyBlue4", 0x4a708b },
+		{ "SlateBlue", 0x6a5acd },
+		{ "SlateBlue1", 0x836fff },
+		{ "SlateBlue2", 0x7a67ee },
+		{ "SlateBlue3", 0x6959cd },
+		{ "SlateBlue4", 0x473c8b },
+		{ "SlateGray", 0x708090 },
+		{ "SlateGray1", 0xc6e2ff },
+		{ "SlateGray2", 0xb9d3ee },
+		{ "SlateGray3", 0x9fb6cd },
+		{ "SlateGray4", 0x6c7b8b },
+		{ "SlateGrey", 0x708090 },
+		{ "SpringGreen", 0x00ff7f },
+		{ "SpringGreen1", 0x00ff7f },
+		{ "SpringGreen2", 0x00ee76 },
+		{ "SpringGreen3", 0x00cd66 },
+		{ "SpringGreen4", 0x008b45 },
+		{ "SteelBlue", 0x4682b4 },
+		{ "SteelBlue1", 0x63b8ff },
+		{ "SteelBlue2", 0x5cacee },
+		{ "SteelBlue3", 0x4f94cd },
+		{ "SteelBlue4", 0x36648b },
+		{ "VioletRed", 0xd02090 },
+		{ "VioletRed1", 0xff3e96 },
+		{ "VioletRed2", 0xee3a8c },
+		{ "VioletRed3", 0xcd3278 },
+		{ "VioletRed4", 0x8b2252 },
+		{ "WebGray", 0x808080 },
+		{ "WebGreen", 0x008000 },
+		{ "WebGrey", 0x808080 },
+		{ "WebMaroon", 0x800000 },
+		{ "WebPurple", 0x800080 },
+		{ "WhiteSmoke", 0xf5f5f5 },
+		{ "X11Gray", 0xbebebe },
+		{ "X11Green", 0x00ff00 },
+		{ "X11Grey", 0xbebebe },
+		{ "X11Maroon", 0xb03060 },
+		{ "X11Purple", 0xa020f0 },
+		{ "YellowGreen", 0x9acd32 },
+		{ "alice blue", 0xf0f8ff },
+		{ "antique white", 0xfaebd7 },
+		{ "aqua", 0x00ffff },
+		{ "aquamarine", 0x7fffd4 },
+		{ "aquamarine1", 0x7fffd4 },
+		{ "aquamarine2", 0x76eec6 },
+		{ "aquamarine3", 0x66cdaa },
+		{ "aquamarine4", 0x458b74 },
+		{ "azure", 0xf0ffff },
+		{ "azure1", 0xf0ffff },
+		{ "azure2", 0xe0eeee },
+		{ "azure3", 0xc1cdcd },
+		{ "azure4", 0x838b8b },
+		{ "beige", 0xf5f5dc },
+		{ "bisque", 0xffe4c4 },
+		{ "bisque1", 0xffe4c4 },
+		{ "bisque2", 0xeed5b7 },
+		{ "bisque3", 0xcdb79e },
+		{ "bisque4", 0x8b7d6b },
+		{ "black", 0x000000 },
+		{ "blanched almond", 0xffebcd },
+		{ "blue violet", 0x8a2be2 },
+		{ "blue", 0x0000ff },
+		{ "blue1", 0x0000ff },
+		{ "blue2", 0x0000ee },
+		{ "blue3", 0x0000cd },
+		{ "blue4", 0x00008b },
+		{ "brown", 0xa52a2a },
+		{ "brown1", 0xff4040 },
+		{ "brown2", 0xee3b3b },
+		{ "brown3", 0xcd3333 },
+		{ "brown4", 0x8b2323 },
+		{ "burlywood", 0xdeb887 },
+		{ "burlywood1", 0xffd39b },
+		{ "burlywood2", 0xeec591 },
+		{ "burlywood3", 0xcdaa7d },
+		{ "burlywood4", 0x8b7355 },
+		{ "cadet blue", 0x5f9ea0 },
+		{ "chartreuse", 0x7fff00 },
+		{ "chartreuse1", 0x7fff00 },
+		{ "chartreuse2", 0x76ee00 },
+		{ "chartreuse3", 0x66cd00 },
+		{ "chartreuse4", 0x458b00 },
+		{ "chocolate", 0xd2691e },
+		{ "chocolate1", 0xff7f24 },
+		{ "chocolate2", 0xee7621 },
+		{ "chocolate3", 0xcd661d },
+		{ "chocolate4", 0x8b4513 },
+		{ "coral", 0xff7f50 },
+		{ "coral1", 0xff7256 },
+		{ "coral2", 0xee6a50 },
+		{ "coral3", 0xcd5b45 },
+		{ "coral4", 0x8b3e2f },
+		{ "cornflower blue", 0x6495ed },
+		{ "cornsilk", 0xfff8dc },
+		{ "cornsilk1", 0xfff8dc },
+		{ "cornsilk2", 0xeee8cd },
+		{ "cornsilk3", 0xcdc8b1 },
+		{ "cornsilk4", 0x8b8878 },
+		{ "crimson", 0xdc143c },
+		{ "cyan", 0x00ffff },
+		{ "cyan1", 0x00ffff },
+		{ "cyan2", 0x00eeee },
+		{ "cyan3", 0x00cdcd },
+		{ "cyan4", 0x008b8b },
+		{ "dark blue", 0x00008b },
+		{ "dark cyan", 0x008b8b },
+		{ "dark goldenrod", 0xb8860b },
+		{ "dark gray", 0xa9a9a9 },
+		{ "dark green", 0x006400 },
+		{ "dark grey", 0xa9a9a9 },
+		{ "dark khaki", 0xbdb76b },
+		{ "dark magenta", 0x8b008b },
+		{ "dark olive green", 0x556b2f },
+		{ "dark orange", 0xff8c00 },
+		{ "dark orchid", 0x9932cc },
+		{ "dark red", 0x8b0000 },
+		{ "dark salmon", 0xe9967a },
+		{ "dark sea green", 0x8fbc8f },
+		{ "dark slate blue", 0x483d8b },
+		{ "dark slate gray", 0x2f4f4f },
+		{ "dark slate grey", 0x2f4f4f },
+		{ "dark turquoise", 0x00ced1 },
+		{ "dark violet", 0x9400d3 },
+		{ "deep pink", 0xff1493 },
+		{ "deep sky blue", 0x00bfff },
+		{ "dim gray", 0x696969 },
+		{ "dim grey", 0x696969 },
+		{ "dodger blue", 0x1e90ff },
+		{ "firebrick", 0xb22222 },
+		{ "firebrick1", 0xff3030 },
+		{ "firebrick2", 0xee2c2c },
+		{ "firebrick3", 0xcd2626 },
+		{ "firebrick4", 0x8b1a1a },
+		{ "floral white", 0xfffaf0 },
+		{ "forest green", 0x228b22 },
+		{ "fuchsia", 0xff00ff },
+		{ "gainsboro", 0xdcdcdc },
+		{ "ghost white", 0xf8f8ff },
+		{ "gold", 0xffd700 },
+		{ "gold1", 0xffd700 },
+		{ "gold2", 0xeec900 },
+		{ "gold3", 0xcdad00 },
+		{ "gold4", 0x8b7500 },
+		{ "goldenrod", 0xdaa520 },
+		{ "goldenrod1", 0xffc125 },
+		{ "goldenrod2", 0xeeb422 },
+		{ "goldenrod3", 0xcd9b1d },
+		{ "goldenrod4", 0x8b6914 },
+		{ "green yellow", 0xadff2f },
+		{ "green", 0x00ff00 },
+		{ "green1", 0x00ff00 },
+		{ "green2", 0x00ee00 },
+		{ "green3", 0x00cd00 },
+		{ "green4", 0x008b00 },
+		{ "honeydew", 0xf0fff0 },
+		{ "honeydew1", 0xf0fff0 },
+		{ "honeydew2", 0xe0eee0 },
+		{ "honeydew3", 0xc1cdc1 },
+		{ "honeydew4", 0x838b83 },
+		{ "hot pink", 0xff69b4 },
+		{ "indian red", 0xcd5c5c },
+		{ "indigo", 0x4b0082 },
+		{ "ivory", 0xfffff0 },
+		{ "ivory1", 0xfffff0 },
+		{ "ivory2", 0xeeeee0 },
+		{ "ivory3", 0xcdcdc1 },
+		{ "ivory4", 0x8b8b83 },
+		{ "khaki", 0xf0e68c },
+		{ "khaki1", 0xfff68f },
+		{ "khaki2", 0xeee685 },
+		{ "khaki3", 0xcdc673 },
+		{ "khaki4", 0x8b864e },
+		{ "lavender blush", 0xfff0f5 },
+		{ "lavender", 0xe6e6fa },
+		{ "lawn green", 0x7cfc00 },
+		{ "lemon chiffon", 0xfffacd },
+		{ "light blue", 0xadd8e6 },
+		{ "light coral", 0xf08080 },
+		{ "light cyan", 0xe0ffff },
+		{ "light goldenrod yellow", 0xfafad2 },
+		{ "light goldenrod", 0xeedd82 },
+		{ "light gray", 0xd3d3d3 },
+		{ "light green", 0x90ee90 },
+		{ "light grey", 0xd3d3d3 },
+		{ "light pink", 0xffb6c1 },
+		{ "light salmon", 0xffa07a },
+		{ "light sea green", 0x20b2aa },
+		{ "light sky blue", 0x87cefa },
+		{ "light slate blue", 0x8470ff },
+		{ "light slate gray", 0x778899 },
+		{ "light slate grey", 0x778899 },
+		{ "light steel blue", 0xb0c4de },
+		{ "light yellow", 0xffffe0 },
+		{ "lime green", 0x32cd32 },
+		{ "lime", 0x00ff00 },
+		{ "linen", 0xfaf0e6 },
+		{ "magenta", 0xff00ff },
+		{ "magenta1", 0xff00ff },
+		{ "magenta2", 0xee00ee },
+		{ "magenta3", 0xcd00cd },
+		{ "magenta4", 0x8b008b },
+		{ "maroon", 0xb03060 },
+		{ "maroon1", 0xff34b3 },
+		{ "maroon2", 0xee30a7 },
+		{ "maroon3", 0xcd2990 },
+		{ "maroon4", 0x8b1c62 },
+		{ "medium aquamarine", 0x66cdaa },
+		{ "medium blue", 0x0000cd },
+		{ "medium orchid", 0xba55d3 },
+		{ "medium purple", 0x9370db },
+		{ "medium sea green", 0x3cb371 },
+		{ "medium slate blue", 0x7b68ee },
+		{ "medium spring green", 0x00fa9a },
+		{ "medium turquoise", 0x48d1cc },
+		{ "medium violet red", 0xc71585 },
+		{ "midnight blue", 0x191970 },
+		{ "mint cream", 0xf5fffa },
+		{ "misty rose", 0xffe4e1 },
+		{ "moccasin", 0xffe4b5 },
+		{ "navajo white", 0xffdead },
+		{ "navy blue", 0x000080 },
+		{ "navy", 0x000080 },
+		{ "old lace", 0xfdf5e6 },
+		{ "olive drab", 0x6b8e23 },
+		{ "olive", 0x808000 },
+		{ "orange red", 0xff4500 },
+		{ "orange", 0xffa500 },
+		{ "orange1", 0xffa500 },
+		{ "orange2", 0xee9a00 },
+		{ "orange3", 0xcd8500 },
+		{ "orange4", 0x8b5a00 },
+		{ "orchid", 0xda70d6 },
+		{ "orchid1", 0xff83fa },
+		{ "orchid2", 0xee7ae9 },
+		{ "orchid3", 0xcd69c9 },
+		{ "orchid4", 0x8b4789 },
+		{ "pale goldenrod", 0xeee8aa },
+		{ "pale green", 0x98fb98 },
+		{ "pale turquoise", 0xafeeee },
+		{ "pale violet red", 0xdb7093 },
+		{ "papaya whip", 0xffefd5 },
+		{ "peach puff", 0xffdab9 },
+		{ "peru", 0xcd853f },
+		{ "pink", 0xffc0cb },
+		{ "pink1", 0xffb5c5 },
+		{ "pink2", 0xeea9b8 },
+		{ "pink3", 0xcd919e },
+		{ "pink4", 0x8b636c },
+		{ "plum", 0xdda0dd },
+		{ "plum1", 0xffbbff },
+		{ "plum2", 0xeeaeee },
+		{ "plum3", 0xcd96cd },
+		{ "plum4", 0x8b668b },
+		{ "powder blue", 0xb0e0e6 },
+		{ "purple", 0xa020f0 },
+		{ "purple1", 0x9b30ff },
+		{ "purple2", 0x912cee },
+		{ "purple3", 0x7d26cd },
+		{ "purple4", 0x551a8b },
+		{ "rebecca purple", 0x663399 },
+		{ "red", 0xff0000 },
+		{ "red1", 0xff0000 },
+		{ "red2", 0xee0000 },
+		{ "red3", 0xcd0000 },
+		{ "red4", 0x8b0000 },
+		{ "rosy brown", 0xbc8f8f },
+		{ "royal blue", 0x4169e1 },
+		{ "saddle brown", 0x8b4513 },
+		{ "salmon", 0xfa8072 },
+		{ "salmon1", 0xff8c69 },
+		{ "salmon2", 0xee8262 },
+		{ "salmon3", 0xcd7054 },
+		{ "salmon4", 0x8b4c39 },
+		{ "sandy brown", 0xf4a460 },
+		{ "sea green", 0x2e8b57 },
+		{ "seashell", 0xfff5ee },
+		{ "seashell1", 0xfff5ee },
+		{ "seashell2", 0xeee5de },
+		{ "seashell3", 0xcdc5bf },
+		{ "seashell4", 0x8b8682 },
+		{ "sienna", 0xa0522d },
+		{ "sienna1", 0xff8247 },
+		{ "sienna2", 0xee7942 },
+		{ "sienna3", 0xcd6839 },
+		{ "sienna4", 0x8b4726 },
+		{ "silver", 0xc0c0c0 },
+		{ "sky blue", 0x87ceeb },
+		{ "slate blue", 0x6a5acd },
+		{ "slate gray", 0x708090 },
+		{ "slate grey", 0x708090 },
+		{ "snow", 0xfffafa },
+		{ "snow1", 0xfffafa },
+		{ "snow2", 0xeee9e9 },
+		{ "snow3", 0xcdc9c9 },
+		{ "snow4", 0x8b8989 },
+		{ "spring green", 0x00ff7f },
+		{ "steel blue", 0x4682b4 },
+		{ "tan", 0xd2b48c },
+		{ "tan1", 0xffa54f },
+		{ "tan2", 0xee9a49 },
+		{ "tan3", 0xcd853f },
+		{ "tan4", 0x8b5a2b },
+		{ "teal", 0x008080 },
+		{ "thistle", 0xd8bfd8 },
+		{ "thistle1", 0xffe1ff },
+		{ "thistle2", 0xeed2ee },
+		{ "thistle3", 0xcdb5cd },
+		{ "thistle4", 0x8b7b8b },
+		{ "tomato", 0xff6347 },
+		{ "tomato1", 0xff6347 },
+		{ "tomato2", 0xee5c42 },
+		{ "tomato3", 0xcd4f39 },
+		{ "tomato4", 0x8b3626 },
+		{ "turquoise", 0x40e0d0 },
+		{ "turquoise1", 0x00f5ff },
+		{ "turquoise2", 0x00e5ee },
+		{ "turquoise3", 0x00c5cd },
+		{ "turquoise4", 0x00868b },
+		{ "violet red", 0xd02090 },
+		{ "violet", 0xee82ee },
+		{ "web gray", 0x808080 },
+		{ "web green", 0x008000 },
+		{ "web grey", 0x808080 },
+		{ "web maroon", 0x800000 },
+		{ "web purple", 0x800080 },
+		{ "wheat", 0xf5deb3 },
+		{ "wheat1", 0xffe7ba },
+		{ "wheat2", 0xeed8ae },
+		{ "wheat3", 0xcdba96 },
+		{ "wheat4", 0x8b7e66 },
+		{ "white smoke", 0xf5f5f5 },
+		{ "white", 0xffffff },
+		{ "x11 gray", 0xbebebe },
+		{ "x11 green", 0x00ff00 },
+		{ "x11 grey", 0xbebebe },
+		{ "x11 maroon", 0xb03060 },
+		{ "x11 purple", 0xa020f0 },
+		{ "yellow green", 0x9acd32 },
+		{ "yellow", 0xffff00 },
+		{ "yellow1", 0xffff00 },
+		{ "yellow2", 0xeeee00 },
+		{ "yellow3", 0xcdcd00 },
+		{ "yellow4", 0x8b8b00 }
+	};
+	u_int	i;
+	int	c;
+
+	if (strncmp(name, "grey", 4) == 0 || strncmp(name, "gray", 4) == 0) {
+		if (!isdigit((u_char)name[4]))
+			return (0xbebebe|COLOUR_FLAG_RGB);
+		c = round(2.55 * atoi(name + 4));
+		if (c < 0 || c > 255)
+			return (-1);
+		return (colour_join_rgb(c, c, c));
+	}
+	for (i = 0; i < nitems(colours); i++) {
+		if (strcasecmp(colours[i].name, name) == 0)
+			return (colours[i].c|COLOUR_FLAG_RGB);
+	}
+	return (-1);
+}

compat.h

@@ -27,10 +27,35 @@
 #include <termios.h>
 #include <wchar.h>
 
+#ifdef HAVE_EVENT2_EVENT_H
+#include <event2/event.h>
+#include <event2/event_compat.h>
+#include <event2/event_struct.h>
+#include <event2/buffer.h>
+#include <event2/buffer_compat.h>
+#include <event2/bufferevent.h>
+#include <event2/bufferevent_struct.h>
+#include <event2/bufferevent_compat.h>
+#else
+#include <event.h>
+#endif
+
+#ifdef HAVE_MALLOC_TRIM
+#include <malloc.h>
+#endif
+
+#ifdef HAVE_UTF8PROC
+#include <utf8proc.h>
+#endif
+
 #ifndef __GNUC__
 #define __attribute__(a)
 #endif
 
+#ifdef BROKEN___DEAD
+#undef __dead
+#endif
+
 #ifndef __unused
 #define __unused __attribute__ ((__unused__))
 #endif
@@ -40,6 +65,9 @@
 #ifndef __packed
 #define __packed __attribute__ ((__packed__))
 #endif
+#ifndef __weak
+#define __weak __attribute__ ((__weak__))
+#endif
 
 #ifndef ECHOPRT
 #define ECHOPRT 0
@@ -90,10 +118,18 @@ void	warnx(const char *, ...);
 #define _PATH_DEFPATH	"/usr/bin:/bin"
 #endif
 
+#ifndef _PATH_VI
+#define _PATH_VI	"/usr/bin/vi"
+#endif
+
 #ifndef __OpenBSD__
 #define pledge(s, p) (0)
 #endif
 
+#ifndef IMAXBEL
+#define IMAXBEL 0
+#endif
+
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #else
@@ -229,6 +265,13 @@ void	warnx(const char *, ...);
 #define HOST_NAME_MAX 255
 #endif
 
+#ifndef CLOCK_REALTIME
+#define CLOCK_REALTIME 0
+#endif
+#ifndef CLOCK_MONOTONIC
+#define CLOCK_MONOTONIC CLOCK_REALTIME
+#endif
+
 #ifndef HAVE_FLOCK
 #define LOCK_SH 0
 #define LOCK_EX 0
@@ -306,6 +349,11 @@ const char	*getprogname(void);
 void		 setproctitle(const char *, ...);
 #endif
 
+#ifndef HAVE_CLOCK_GETTIME
+/* clock_gettime.c */
+int		 clock_gettime(int, struct timespec *);
+#endif
+
 #ifndef HAVE_B64_NTOP
 /* base64.c */
 #undef b64_ntop
@@ -337,6 +385,11 @@ int		 vasprintf(char **, const char *, va_list);
 char		*fgetln(FILE *, size_t *);
 #endif
 
+#ifndef HAVE_GETLINE
+/* getline.c */
+ssize_t		 getline(char **, size_t *, FILE *);
+#endif
+
 #ifndef HAVE_SETENV
 /* setenv.c */
 int		 setenv(const char *, const char *, int);
@@ -370,6 +423,11 @@ int		 utf8proc_mbtowc(wchar_t *, const char *, size_t);
 int		 utf8proc_wctomb(char *, wchar_t);
 #endif
 
+#ifdef NEED_FUZZING
+/* tmux.c */
+#define main __weak main
+#endif
+
 /* getopt.c */
 extern int	BSDopterr;
 extern int	BSDoptind;

compat/clock_gettime.c

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 Nicholas Marriott <nicholas.marriott@gmail.com>
+ *
+ * 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>
+#include <sys/time.h>
+
+#include "compat.h"
+
+#ifndef TIMEVAL_TO_TIMESPEC
+#define TIMEVAL_TO_TIMESPEC(tv, ts) do {	\
+	(ts)->tv_sec = (tv)->tv_sec;		\
+	(ts)->tv_nsec = (tv)->tv_usec * 1000;	\
+} while (0)
+#endif
+
+int
+clock_gettime(int clock, struct timespec *ts)
+{
+	struct timeval	tv;
+
+	gettimeofday(&tv, NULL);
+	TIMEVAL_TO_TIMESPEC(&tv, ts);
+	return 0;
+}

compat/closefrom.c

@@ -44,6 +44,9 @@
 #  include <ndir.h>
 # endif
 #endif
+#if defined(HAVE_LIBPROC_H)
+# include <libproc.h>
+#endif
 
 #include "compat.h"
 
@@ -55,39 +58,15 @@
 __unused static const char rcsid[] = "$Sudo: closefrom.c,v 1.11 2006/08/17 15:26:54 millert Exp $";
 #endif /* lint */
 
+#ifndef HAVE_FCNTL_CLOSEM
 /*
  * Close all file descriptors greater than or equal to lowfd.
  */
-#ifdef HAVE_FCNTL_CLOSEM
+static void
-void
+closefrom_fallback(int lowfd)
-closefrom(int lowfd)
 {
-    (void) fcntl(lowfd, F_CLOSEM, 0);
+	long fd, maxfd;
-}
-#else
-void
-closefrom(int lowfd)
-{
-    long fd, maxfd;
-#if defined(HAVE_DIRFD) && defined(HAVE_PROC_PID)
-    char fdpath[PATH_MAX], *endp;
-    struct dirent *dent;
-    DIR *dirp;
-    int len;
 
-    /* Check for a /proc/$$/fd directory. */
-    len = snprintf(fdpath, sizeof(fdpath), "/proc/%ld/fd", (long)getpid());
-    if (len > 0 && (size_t)len <= sizeof(fdpath) && (dirp = opendir(fdpath))) {
-	while ((dent = readdir(dirp)) != NULL) {
-	    fd = strtol(dent->d_name, &endp, 10);
-	    if (dent->d_name != endp && *endp == '\0' &&
-		fd >= 0 && fd < INT_MAX && fd >= lowfd && fd != dirfd(dirp))
-		(void) close((int) fd);
-	}
-	(void) closedir(dirp);
-    } else
-#endif
-    {
 	/*
 	 * Fall back on sysconf() or getdtablesize().  We avoid checking
 	 * resource limits since it is possible to open a file descriptor
@@ -99,11 +78,78 @@ closefrom(int lowfd)
 	maxfd = getdtablesize();
 #endif /* HAVE_SYSCONF */
 	if (maxfd < 0)
-	    maxfd = OPEN_MAX;
+		maxfd = OPEN_MAX;
 
 	for (fd = lowfd; fd < maxfd; fd++)
-	    (void) close((int) fd);
+		(void) close((int) fd);
+}
+#endif /* HAVE_FCNTL_CLOSEM */
+
+#ifdef HAVE_FCNTL_CLOSEM
+void
+closefrom(int lowfd)
+{
+    (void) fcntl(lowfd, F_CLOSEM, 0);
+}
+#elif defined(HAVE_LIBPROC_H) && defined(HAVE_PROC_PIDINFO)
+void
+closefrom(int lowfd)
+{
+	int i, r, sz;
+	pid_t pid = getpid();
+	struct proc_fdinfo *fdinfo_buf = NULL;
+
+	sz = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, NULL, 0);
+	if (sz == 0)
+		return; /* no fds, really? */
+	else if (sz == -1)
+		goto fallback;
+	if ((fdinfo_buf = malloc(sz)) == NULL)
+		goto fallback;
+	r = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, fdinfo_buf, sz);
+	if (r < 0 || r > sz)
+		goto fallback;
+	for (i = 0; i < r / (int)PROC_PIDLISTFD_SIZE; i++) {
+		if (fdinfo_buf[i].proc_fd >= lowfd)
+			close(fdinfo_buf[i].proc_fd);
+	}
+	free(fdinfo_buf);
+	return;
+ fallback:
+	free(fdinfo_buf);
+	closefrom_fallback(lowfd);
+	return;
+}
+#elif defined(HAVE_DIRFD) && defined(HAVE_PROC_PID)
+void
+closefrom(int lowfd)
+{
+    long fd;
+    char fdpath[PATH_MAX], *endp;
+    struct dirent *dent;
+    DIR *dirp;
+    int len;
+
+    /* Check for a /proc/$$/fd directory. */
+    len = snprintf(fdpath, sizeof(fdpath), "/proc/%ld/fd", (long)getpid());
+    if (len > 0 && (size_t)len < sizeof(fdpath) && (dirp = opendir(fdpath))) {
+	while ((dent = readdir(dirp)) != NULL) {
+	    fd = strtol(dent->d_name, &endp, 10);
+	    if (dent->d_name != endp && *endp == '\0' &&
+		fd >= 0 && fd < INT_MAX && fd >= lowfd && fd != dirfd(dirp))
+		(void) close((int) fd);
+	}
+	(void) closedir(dirp);
+	return;
     }
+    /* /proc/$$/fd strategy failed, fall back to brute force closure */
+    closefrom_fallback(lowfd);
+}
+#else
+void
+closefrom(int lowfd)
+{
+	closefrom_fallback(lowfd);
 }
 #endif /* !HAVE_FCNTL_CLOSEM */
 #endif /* HAVE_CLOSEFROM */

compat/forkpty-haiku.c

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
+ *
+ * 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>
+#include <sys/ioctl.h>
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "compat.h"
+
+void fatal(const char *, ...);
+void fatalx(const char *, ...);
+
+pid_t
+forkpty(int *master, char *name, struct termios *tio, struct winsize *ws)
+{
+	int	slave = -1;
+	char   *path;
+	pid_t	pid;
+
+	if ((*master = open("/dev/ptmx", O_RDWR|O_NOCTTY)) == -1)
+		return (-1);
+	if (grantpt(*master) != 0)
+		goto out;
+	if (unlockpt(*master) != 0)
+		goto out;
+
+	if ((path = ptsname(*master)) == NULL)
+		goto out;
+	if (name != NULL)
+		strlcpy(name, path, TTY_NAME_MAX);
+	if ((slave = open(path, O_RDWR|O_NOCTTY)) == -1)
+		goto out;
+
+	switch (pid = fork()) {
+	case -1:
+		goto out;
+	case 0:
+		close(*master);
+
+		setsid();
+		if (ioctl(slave, TIOCSCTTY, NULL) == -1)
+			fatal("ioctl failed");
+
+		if (tio != NULL && tcsetattr(slave, TCSAFLUSH, tio) == -1)
+			fatal("tcsetattr failed");
+		if (ioctl(slave, TIOCSWINSZ, ws) == -1)
+			fatal("ioctl failed");
+
+		dup2(slave, 0);
+		dup2(slave, 1);
+		dup2(slave, 2);
+		if (slave > 2)
+			close(slave);
+		return (0);
+	}
+
+	close(slave);
+	return (pid);
+
+out:
+	if (*master != -1)
+		close(*master);
+	if (slave != -1)
+		close(slave);
+	return (-1);
+}

compat/getdtablesize.c

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Nicholas Marriott <nicholas.marriott@gmail.com>
+ *
+ * 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>
+
+#include <unistd.h>
+
+#include "compat.h"
+
+#ifdef HAVE_SYSCONF
+int
+getdtablesize(void)
+{
+	return (sysconf(_SC_OPEN_MAX));
+}
+#endif

compat/getline.c

@@ -0,0 +1,93 @@
+/*	$NetBSD: getline.c,v 1.1.1.6 2015/01/02 20:34:27 christos Exp $	*/
+
+/*	NetBSD: getline.c,v 1.2 2014/09/16 17:23:50 christos Exp 	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Christos Zoulas.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* NETBSD ORIGINAL: external/bsd/file/dist/src/getline.c */
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+
+#include "tmux.h"
+
+static ssize_t
+getdelim(char **buf, size_t *bufsiz, int delimiter, FILE *fp)
+{
+	char *ptr, *eptr;
+
+
+	if (*buf == NULL || *bufsiz == 0) {
+		if ((*buf = malloc(BUFSIZ)) == NULL)
+			return -1;
+		*bufsiz = BUFSIZ;
+	}
+
+	for (ptr = *buf, eptr = *buf + *bufsiz;;) {
+		int c = fgetc(fp);
+		if (c == -1) {
+			if (feof(fp)) {
+				ssize_t diff = (ssize_t)(ptr - *buf);
+				if (diff != 0) {
+					*ptr = '\0';
+					return diff;
+				}
+			}
+			return -1;
+		}
+		*ptr++ = c;
+		if (c == delimiter) {
+			*ptr = '\0';
+			return ptr - *buf;
+		}
+		if (ptr + 2 >= eptr) {
+			char *nbuf;
+			size_t nbufsiz = *bufsiz * 2;
+			ssize_t d = ptr - *buf;
+			if ((nbuf = realloc(*buf, nbufsiz)) == NULL)
+				return -1;
+			*buf = nbuf;
+			*bufsiz = nbufsiz;
+			eptr = nbuf + nbufsiz;
+			ptr = nbuf + d;
+		}
+	}
+}
+
+ssize_t
+getline(char **buf, size_t *bufsiz, FILE *fp)
+{
+	return getdelim(buf, bufsiz, '\n', fp);
+}

compat/imsg-buffer.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: imsg-buffer.c,v 1.11 2017/12/14 09:27:44 kettenis Exp $	*/
+/*	$OpenBSD: imsg-buffer.c,v 1.12 2019/01/20 02:50:03 bcook Exp $	*/
 
 /*
  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
@@ -70,7 +70,7 @@ ibuf_dynamic(size_t len, size_t max)
 static int
 ibuf_realloc(struct ibuf *buf, size_t len)
 {
-	u_char	*b;
+	unsigned char	*b;
 
 	/* on static buffers max is eq size and so the following fails */
 	if (buf->wpos + len > buf->max) {

compat/imsg.h

@@ -1,4 +1,4 @@
-/*	$OpenBSD: imsg.h,v 1.4 2017/03/24 09:34:12 nicm Exp $	*/
+/*	$OpenBSD: imsg.h,v 1.5 2019/01/20 02:50:03 bcook Exp $	*/
 
 /*
  * Copyright (c) 2006, 2007 Pierre-Yves Ritschard <pyr@openbsd.org>
@@ -21,13 +21,15 @@
 #ifndef _IMSG_H_
 #define _IMSG_H_
 
+#include <stdint.h>
+
 #define IBUF_READ_SIZE		65535
 #define IMSG_HEADER_SIZE	sizeof(struct imsg_hdr)
 #define MAX_IMSGSIZE		16384
 
 struct ibuf {
 	TAILQ_ENTRY(ibuf)	 entry;
-	u_char			*buf;
+	unsigned char		*buf;
 	size_t			 size;
 	size_t			 max;
 	size_t			 wpos;
@@ -42,8 +44,8 @@ struct msgbuf {
 };
 
 struct ibuf_read {
-	u_char			 buf[IBUF_READ_SIZE];
+	unsigned char		 buf[IBUF_READ_SIZE];
-	u_char			*rptr;
+	unsigned char		*rptr;
 	size_t			 wpos;
 };
 

configure.ac

@@ -1,6 +1,6 @@
 # configure.ac
 
-AC_INIT([tmux], 3.1b)
+AC_INIT([tmux], 3.2)
 AC_PREREQ([2.60])
 
 AC_CONFIG_AUX_DIR(etc)
@@ -21,6 +21,26 @@ SAVED_CFLAGS="$CFLAGS"
 SAVED_CPPFLAGS="$CPPFLAGS"
 SAVED_LDFLAGS="$LDFLAGS"
 
+# Is this oss-fuzz build?
+AC_ARG_ENABLE(
+	fuzzing,
+	AC_HELP_STRING(--enable-fuzzing, build fuzzers)
+)
+AC_ARG_VAR(
+	FUZZING_LIBS,
+	AC_HELP_STRING(libraries to link fuzzing targets with)
+)
+
+# Set up convenient fuzzing defaults before initializing compiler.
+if test "x$enable_fuzzing" = xyes; then
+	AC_DEFINE(NEED_FUZZING)
+	test "x$CC" == x && CC=clang
+	test "x$FUZZING_LIBS" == x && \
+		FUZZING_LIBS="-fsanitize=fuzzer"
+	test "x$SAVED_CFLAGS" == x && \
+		AM_CFLAGS="-g -fsanitize=fuzzer-no-link,address"
+fi
+
 # Set up the compiler in two different ways and say yes we may want to install.
 AC_PROG_CC
 AM_PROG_CC_C_O
@@ -54,8 +74,11 @@ if test "x$enable_static" = xyes; then
 	LDFLAGS="$AM_LDFLAGS $SAVED_LDFLAGS"
 fi
 
+# Do we need fuzzers?
+AM_CONDITIONAL(NEED_FUZZING, test "x$enable_fuzzing" = xyes)
+
 # Is this gcc?
-AM_CONDITIONAL(IS_GCC, test "x$GCC" = xyes)
+AM_CONDITIONAL(IS_GCC, test "x$GCC" = xyes -a "x$enable_fuzzing" != xyes)
 
 # Is this Sun CC?
 AC_EGREP_CPP(
@@ -76,6 +99,7 @@ AC_CHECK_HEADERS([ \
 	dirent.h \
 	fcntl.h \
 	inttypes.h \
+	libproc.h \
 	libutil.h \
 	ndir.h \
 	paths.h \
@@ -87,6 +111,12 @@ AC_CHECK_HEADERS([ \
 	util.h \
 ])
 
+# Look for sys_signame.
+AC_SEARCH_LIBS(sys_signame, , AC_DEFINE(HAVE_SYS_SIGNAME))
+
+# Look for fmod.
+AC_CHECK_LIB(m, fmod)
+
 # Look for library needed for flock.
 AC_SEARCH_LIBS(flock, bsd)
 
@@ -95,22 +125,24 @@ AC_CHECK_FUNCS([ \
 	dirfd \
 	flock \
 	prctl \
-	sysconf \
+	proc_pidinfo \
+	sysconf
 ])
 
 # Check for functions with a compatibility implementation.
 AC_REPLACE_FUNCS([ \
 	asprintf \
 	cfmakeraw \
+	clock_gettime \
 	closefrom \
 	explicit_bzero \
 	fgetln \
 	freezero \
 	getdtablecount \
+	getdtablesize \
+	getline \
 	getprogname \
 	memmem \
-	recallocarray \
-	reallocarray \
 	setenv \
 	setproctitle \
 	strcasestr \
@@ -122,6 +154,26 @@ AC_REPLACE_FUNCS([ \
 ])
 AC_FUNC_STRNLEN
 
+# Clang sanitizers wrap reallocarray even if it isn't available on the target
+# system. When compiled it always returns NULL and crashes the program. To
+# detect this we need a more complicated test.
+AC_MSG_CHECKING([for working reallocarray])
+AC_RUN_IFELSE([AC_LANG_PROGRAM(
+		[#include <stdlib.h>],
+		[return (reallocarray(NULL, 1, 1) == NULL);]
+	)],
+	AC_MSG_RESULT(yes),
+	[AC_LIBOBJ(reallocarray) AC_MSG_RESULT([no])]
+)
+AC_MSG_CHECKING([for working recallocarray])
+AC_RUN_IFELSE([AC_LANG_PROGRAM(
+		[#include <stdlib.h>],
+		[return (recallocarray(NULL, 1, 1, 1) == NULL);]
+	)],
+	AC_MSG_RESULT(yes),
+	[AC_LIBOBJ(recallocarray) AC_MSG_RESULT([no])]
+)
+
 # Look for clock_gettime. Must come before event_init.
 AC_SEARCH_LIBS(clock_gettime, rt)
 
@@ -131,88 +183,112 @@ AC_SEARCH_LIBS(clock_gettime, rt)
 # implementations.
 AC_LIBOBJ(getopt)
 
-# Look for libevent.
+# Look for libevent. Try libevent_core or libevent with pkg-config first then
+# look for the library.
 PKG_CHECK_MODULES(
-	LIBEVENT,
+	LIBEVENT_CORE,
-	libevent,
+	[libevent_core >= 2],
 	[
-		AM_CFLAGS="$LIBEVENT_CFLAGS $AM_CFLAGS"
+		AM_CPPFLAGS="$LIBEVENT_CORE_CFLAGS $AM_CPPFLAGS"
-		CFLAGS="$AM_CFLAGS $SAVED_CFLAGS"
+		CPPFLAGS="$AM_CPPFLAGS $SAVED_CPPFLAGS"
-		LIBS="$LIBEVENT_LIBS $LIBS"
+		LIBS="$LIBEVENT_CORE_LIBS $LIBS"
 		found_libevent=yes
 	],
+	found_libevent=no
+)
+if test x$found_libevent = xno; then
+	PKG_CHECK_MODULES(
+		LIBEVENT,
+		[libevent >= 2],
+		[
+			AM_CPPFLAGS="$LIBEVENT_CFLAGS $AM_CPPFLAGS"
+			CPPFLAGS="$AM_CPPFLAGS $SAVED_CPPFLAGS"
+			LIBS="$LIBEVENT_LIBS $LIBS"
+			found_libevent=yes
+		],
+		found_libevent=no
+	)
+fi
+if test x$found_libevent = xno; then
+	AC_SEARCH_LIBS(
+		event_init,
+		[event_core event event-1.4],
+		found_libevent=yes,
+		found_libevent=no
+	)
+fi
+AC_CHECK_HEADER(
+	event2/event.h,
+	AC_DEFINE(HAVE_EVENT2_EVENT_H),
 	[
-		AC_SEARCH_LIBS(
+		AC_CHECK_HEADER(
-			event_init,
+			event.h,
-			[event event-1.4 event2],
+			AC_DEFINE(HAVE_EVENT_H),
-			found_libevent=yes,
 			found_libevent=no
 		)
 	]
 )
-AC_CHECK_HEADER(
-	event.h,
-	,
-	found_libevent=no
-)
 if test "x$found_libevent" = xno; then
 	AC_MSG_ERROR("libevent not found")
 fi
 
-# Look for ncurses.
+# Look for ncurses or curses. Try pkg-config first then directly for the
+# library.
 PKG_CHECK_MODULES(
 	LIBTINFO,
 	tinfo,
-	found_ncurses=yes,
+	[
+		AM_CPPFLAGS="$LIBTINFO_CFLAGS $AM_CPPFLAGS"
+		CPPFLAGS="$LIBTINFO_CFLAGS $SAVED_CPPFLAGS"
+		LIBS="$LIBTINFO_LIBS $LIBS"
+		found_ncurses=yes
+	],
 	found_ncurses=no
 )
 if test "x$found_ncurses" = xno; then
 	PKG_CHECK_MODULES(
 		LIBNCURSES,
 		ncurses,
-		found_ncurses=yes,
+		[
+			AM_CPPFLAGS="$LIBNCURSES_CFLAGS $AM_CPPFLAGS"
+			CPPFLAGS="$LIBNCURSES_CFLAGS $SAVED_CPPFLAGS"
+			LIBS="$LIBNCURSES_LIBS $LIBS"
+			found_ncurses=yes
+		],
 		found_ncurses=no
 	)
 fi
 if test "x$found_ncurses" = xno; then
 	PKG_CHECK_MODULES(
-		LIBNCURSES,
+		LIBNCURSESW,
 		ncursesw,
-		found_ncurses=yes,
+		[
+			AM_CPPFLAGS="$LIBNCURSESW_CFLAGS $AM_CPPFLAGS"
+			CPPFLAGS="$LIBNCURSESW_CFLAGS $SAVED_CPPFLAGS"
+			LIBS="$LIBNCURSESW_LIBS $LIBS"
+			found_ncurses=yes
+		],
 		found_ncurses=no
 	)
 fi
-if test "x$found_ncurses" = xyes; then
+if test "x$found_ncurses" = xno; then
-	AM_CFLAGS="$LIBNCURSES_CFLAGS $LIBTINFO_CFLAGS $AM_CFLAGS"
+	AC_SEARCH_LIBS(
-	CFLAGS="$LIBNCURSES_CFLAGS $LIBTINFO_CFLAGS $CFLAGS"
-	LIBS="$LIBNCURSES_LIBS $LIBTINFO_LIBS $LIBS"
-else
-	# pkg-config didn't work, try ncurses.
-	AC_CHECK_LIB(
-		tinfo,
 		setupterm,
+		[tinfo ncurses ncursesw],
 		found_ncurses=yes,
 		found_ncurses=no
 	)
-	if test "x$found_ncurses" = xno; then
-		AC_CHECK_LIB(
-			ncurses,
-			setupterm,
-			found_ncurses=yes,
-			found_ncurses=no
-		)
-	fi
 	if test "x$found_ncurses" = xyes; then
 		AC_CHECK_HEADER(
 			ncurses.h,
 			LIBS="$LIBS -lncurses",
-			found_ncurses=no)
+			found_ncurses=no
+		)
 	fi
 fi
 if test "x$found_ncurses" = xyes; then
 	AC_DEFINE(HAVE_NCURSES_H)
 else
-	# No ncurses, try curses.
 	AC_CHECK_LIB(
 		curses,
 		setupterm,
@@ -222,7 +298,8 @@ else
 	AC_CHECK_HEADER(
 		curses.h,
 		,
-		found_curses=no)
+		found_curses=no
+	)
 	if test "x$found_curses" = xyes; then
 		LIBS="$LIBS -lcurses"
 		AC_DEFINE(HAVE_CURSES_H)
@@ -288,12 +365,11 @@ AC_TRY_LINK(
 	found_b64_ntop=yes,
 	found_b64_ntop=no
 )
+AC_MSG_RESULT($found_b64_ntop)
+OLD_LIBS="$LIBS"
 if test "x$found_b64_ntop" = xno; then
-	AC_MSG_RESULT(no)
-
 	AC_MSG_CHECKING(for b64_ntop with -lresolv)
-	OLD_LIBS="$LIBS"
+	LIBS="$OLD_LIBS -lresolv"
-	LIBS="$LIBS -lresolv"
 	AC_TRY_LINK(
 		[
 			#include <sys/types.h>
@@ -304,15 +380,27 @@ if test "x$found_b64_ntop" = xno; then
 		found_b64_ntop=yes,
 		found_b64_ntop=no
 	)
-	if test "x$found_b64_ntop" = xno; then
+	AC_MSG_RESULT($found_b64_ntop)
-		LIBS="$OLD_LIBS"
+fi
-		AC_MSG_RESULT(no)
+if test "x$found_b64_ntop" = xno; then
-	fi
+	AC_MSG_CHECKING(for b64_ntop with -lnetwork)
+	LIBS="$OLD_LIBS -lnetwork"
+	AC_TRY_LINK(
+		[
+			#include <sys/types.h>
+			#include <netinet/in.h>
+			#include <resolv.h>
+		],
+		[b64_ntop(NULL, 0, NULL, 0);],
+		found_b64_ntop=yes,
+		found_b64_ntop=no
+	)
+	AC_MSG_RESULT($found_b64_ntop)
 fi
 if test "x$found_b64_ntop" = xyes; then
 	AC_DEFINE(HAVE_B64_NTOP)
-	AC_MSG_RESULT(yes)
 else
+	LIBS="$OLD_LIBS"
 	AC_LIBOBJ(base64)
 fi
 
@@ -321,8 +409,34 @@ AC_SEARCH_LIBS(inet_ntoa, nsl)
 AC_SEARCH_LIBS(socket, socket)
 AC_CHECK_LIB(xnet, socket)
 
-# Check for CMSG_DATA. Some platforms require _XOPEN_SOURCE_EXTENDED (for
+# Check if using glibc and have malloc_trim(3). The glibc free(3) is pretty bad
-# example see xopen_networking(7) on HP-UX).
+# about returning memory to the kernel unless the application tells it when to
+# with malloc_trim(3).
+AC_MSG_CHECKING(if free doesn't work very well)
+AC_LINK_IFELSE([AC_LANG_SOURCE(
+	[
+		#include <stdlib.h>
+		#ifdef __GLIBC__
+		#include <malloc.h>
+		int main(void) {
+			malloc_trim (0);
+			exit(0);
+		}
+		#else
+		no
+		#endif
+	])],
+	found_malloc_trim=yes,
+	found_malloc_trim=no
+)
+AC_MSG_RESULT($found_malloc_trim)
+if test "x$found_malloc_trim" = xyes; then
+	AC_DEFINE(HAVE_MALLOC_TRIM)
+fi
+
+# Check for CMSG_DATA. On some platforms like HP-UX this requires UNIX 95
+# (_XOPEN_SOURCE and _XOPEN_SOURCE_EXTENDED) (see xopen_networking(7)). On
+# others, UNIX 03 (_XOPEN_SOURCE 600, see standards(7) on Solaris).
 XOPEN_DEFINES=
 AC_MSG_CHECKING(for CMSG_DATA)
 AC_EGREP_CPP(
@@ -355,6 +469,25 @@ if test "x$found_cmsg_data" = xno; then
 	AC_MSG_RESULT($found_cmsg_data)
 	if test "x$found_cmsg_data" = xyes; then
 		XOPEN_DEFINES="-D_XOPEN_SOURCE -D_XOPEN_SOURCE_EXTENDED"
+	fi
+fi
+if test "x$found_cmsg_data" = xno; then
+	AC_MSG_CHECKING(if CMSG_DATA needs _XOPEN_SOURCE 600)
+	AC_EGREP_CPP(
+		yes,
+		[
+			#define _XOPEN_SOURCE 600
+			#include <sys/socket.h>
+			#ifdef CMSG_DATA
+			yes
+			#endif
+		],
+		found_cmsg_data=yes,
+		found_cmsg_data=no
+	)
+	AC_MSG_RESULT($found_cmsg_data)
+	if test "x$found_cmsg_data" = xyes; then
+		XOPEN_DEFINES="-D_XOPEN_SOURCE=600"
 	else
 		AC_MSG_ERROR("CMSG_DATA not found")
 	fi
@@ -543,6 +676,12 @@ case "$host_os" in
 		AC_MSG_RESULT(darwin)
 		PLATFORM=darwin
 		#
+		# OS X uses __dead2 instead of __dead, like FreeBSD. But it
+		# defines __dead away so it needs to be removed before we can
+		# replace it.
+		#
+		AC_DEFINE(BROKEN___DEAD)
+		#
 		# OS X CMSG_FIRSTHDR is broken, so redefine it with a working
 		# one. daemon works but has some stupid side effects, so use
 		# our internal version which has a workaround.
@@ -597,6 +736,10 @@ case "$host_os" in
 		AC_MSG_RESULT(cygwin)
 		PLATFORM=cygwin
 		;;
+	*haiku*)
+		AC_MSG_RESULT(haiku)
+		PLATFORM=haiku
+		;;
 	*)
 		AC_MSG_RESULT(unknown)
 		PLATFORM=unknown
@@ -612,6 +755,7 @@ AM_CONDITIONAL(IS_NETBSD, test "x$PLATFORM" = xnetbsd)
 AM_CONDITIONAL(IS_OPENBSD, test "x$PLATFORM" = xopenbsd)
 AM_CONDITIONAL(IS_SUNOS, test "x$PLATFORM" = xsunos)
 AM_CONDITIONAL(IS_HPUX, test "x$PLATFORM" = xhpux)
+AM_CONDITIONAL(IS_HAIKU, test "x$PLATFORM" = xhaiku)
 AM_CONDITIONAL(IS_UNKNOWN, test "x$PLATFORM" = xunknown)
 
 # Save our CFLAGS/CPPFLAGS/LDFLAGS for the Makefile and restore the old user

control-notify.c

@@ -26,40 +26,6 @@
 #define CONTROL_SHOULD_NOTIFY_CLIENT(c) \
 	((c) != NULL && ((c)->flags & CLIENT_CONTROL))
 
-void
-control_notify_input(struct client *c, struct window_pane *wp,
-    const u_char *buf, size_t len)
-{
-	struct evbuffer *message;
-	u_int		 i;
-
-	if (c->session == NULL)
-	    return;
-
-	if (c->flags & CLIENT_CONTROL_NOOUTPUT)
-		return;
-
-	/*
-	 * Only write input if the window pane is linked to a window belonging
-	 * to the client's session.
-	 */
-	if (winlink_find_by_window(&c->session->windows, wp->window) != NULL) {
-		message = evbuffer_new();
-		if (message == NULL)
-			fatalx("out of memory");
-		evbuffer_add_printf(message, "%%output %%%u ", wp->id);
-		for (i = 0; i < len; i++) {
-			if (buf[i] < ' ' || buf[i] == '\\')
-			    evbuffer_add_printf(message, "\\%03o", buf[i]);
-			else
-			    evbuffer_add_printf(message, "%c", buf[i]);
-		}
-		evbuffer_add(message, "", 1);
-		control_write(c, "%s", EVBUFFER_DATA(message));
-		evbuffer_free(message);
-	}
-}
-
 void
 control_notify_pane_mode_changed(int pane)
 {
@@ -83,7 +49,7 @@ control_notify_window_layout_changed(struct window *w)
 	char		*cp;
 
 	template = "%layout-change #{window_id} #{window_layout} "
-	    "#{window_visible_layout} #{window_flags}";
+	    "#{window_visible_layout} #{window_raw_flags}";
 
 	TAILQ_FOREACH(c, &clients, entry) {
 		if (!CONTROL_SHOULD_NOTIFY_CLIENT(c) || c->session == NULL)
@@ -205,6 +171,17 @@ control_notify_client_session_changed(struct client *cc)
 	}
 }
 
+void
+control_notify_client_detached(struct client *cc)
+{
+	struct client	*c;
+
+	TAILQ_FOREACH(c, &clients, entry) {
+		if (CONTROL_SHOULD_NOTIFY_CLIENT(c))
+			control_write(c, "%%client-detached %s", cc->name);
+	}
+}
+
 void
 control_notify_session_renamed(struct session *s)
 {

environ.c

@@ -18,6 +18,7 @@
 
 #include <sys/types.h>
 
+#include <fnmatch.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ -86,8 +87,10 @@ environ_copy(struct environ *srcenv, struct environ *dstenv)
 	RB_FOREACH(envent, environ, srcenv) {
 		if (envent->value == NULL)
 			environ_clear(dstenv, envent->name);
-		else
+		else {
-			environ_set(dstenv, envent->name, "%s", envent->value);
+			environ_set(dstenv, envent->name, envent->flags,
+			    "%s", envent->value);
+		}
 	}
 }
 
@@ -103,18 +106,21 @@ environ_find(struct environ *env, const char *name)
 
 /* Set an environment variable. */
 void
-environ_set(struct environ *env, const char *name, const char *fmt, ...)
+environ_set(struct environ *env, const char *name, int flags, const char *fmt,
+    ...)
 {
 	struct environ_entry	*envent;
 	va_list			 ap;
 
 	va_start(ap, fmt);
 	if ((envent = environ_find(env, name)) != NULL) {
+		envent->flags = flags;
 		free(envent->value);
 		xvasprintf(&envent->value, fmt, ap);
 	} else {
 		envent = xmalloc(sizeof *envent);
 		envent->name = xstrdup(name);
+		envent->flags = flags;
 		xvasprintf(&envent->value, fmt, ap);
 		RB_INSERT(environ, env, envent);
 	}
@@ -133,6 +139,7 @@ environ_clear(struct environ *env, const char *name)
 	} else {
 		envent = xmalloc(sizeof *envent);
 		envent->name = xstrdup(name);
+		envent->flags = 0;
 		envent->value = NULL;
 		RB_INSERT(environ, env, envent);
 	}
@@ -140,7 +147,7 @@ environ_clear(struct environ *env, const char *name)
 
 /* Set an environment variable from a NAME=VALUE string. */
 void
-environ_put(struct environ *env, const char *var)
+environ_put(struct environ *env, const char *var, int flags)
 {
 	char	*name, *value;
 
@@ -152,7 +159,7 @@ environ_put(struct environ *env, const char *var)
 	name = xstrdup(var);
 	name[strcspn(name, "=")] = '\0';
 
-	environ_set(env, name, "%s", value);
+	environ_set(env, name, flags, "%s", value);
 	free(name);
 }
 
@@ -170,7 +177,7 @@ environ_unset(struct environ *env, const char *name)
 	free(envent);
 }
 
-/* Copy variables from a destination into a source * environment. */
+/* Copy variables from a destination into a source environment. */
 void
 environ_update(struct options *oo, struct environ *src, struct environ *dst)
 {
@@ -185,10 +192,14 @@ environ_update(struct options *oo, struct environ *src, struct environ *dst)
 	a = options_array_first(o);
 	while (a != NULL) {
 		ov = options_array_item_value(a);
-		if ((envent = environ_find(src, ov->string)) == NULL)
+		RB_FOREACH(envent, environ, src) {
+			if (fnmatch(ov->string, envent->name, 0) == 0)
+				break;
+		}
+		if (envent == NULL)
 			environ_clear(dst, ov->string);
 		else
-			environ_set(dst, envent->name, "%s", envent->value);
+			environ_set(dst, envent->name, 0, "%s", envent->value);
 		a = options_array_next(a);
 	}
 }
@@ -201,7 +212,9 @@ environ_push(struct environ *env)
 
 	environ = xcalloc(1, sizeof *environ);
 	RB_FOREACH(envent, environ, env) {
-		if (envent->value != NULL && *envent->name != '\0')
+		if (envent->value != NULL &&
+		    *envent->name != '\0' &&
+		    (~envent->flags & ENVIRON_HIDDEN))
 			setenv(envent->name, envent->value, 1);
 	}
 }
@@ -243,14 +256,17 @@ environ_for_session(struct session *s, int no_TERM)
 
 	if (!no_TERM) {
 		value = options_get_string(global_options, "default-terminal");
-		environ_set(env, "TERM", "%s", value);
+		environ_set(env, "TERM", 0, "%s", value);
+		environ_set(env, "TERM_PROGRAM", 0, "%s", "tmux");
+		environ_set(env, "TERM_PROGRAM_VERSION", 0, "%s", getversion());
 	}
 
 	if (s != NULL)
 		idx = s->id;
 	else
 		idx = -1;
-	environ_set(env, "TMUX", "%s,%ld,%d", socket_path, (long)getpid(), idx);
+	environ_set(env, "TMUX", 0, "%s,%ld,%d", socket_path, (long)getpid(),
+	    idx);
 
 	return (env);
 }

file.c

@@ -17,7 +17,6 @@
  */
 
 #include <sys/types.h>
-#include <sys/queue.h>
 
 #include <errno.h>
 #include <fcntl.h>
@@ -28,10 +27,17 @@
 
 #include "tmux.h"
 
+/*
+ * IPC file handling. Both client and server use the same data structures
+ * (client_file and client_files) to store list of active files. Most functions
+ * are for use either in client or server but not both.
+ */
+
 static int	file_next_stream = 3;
 
 RB_GENERATE(client_files, client_file, entry, file_cmp);
 
+/* Get path for file, either as given or from working directory. */
 static char *
 file_get_path(struct client *c, const char *file)
 {
@@ -44,6 +50,7 @@ file_get_path(struct client *c, const char *file)
 	return (path);
 }
 
+/* Tree comparison function. */
 int
 file_cmp(struct client_file *cf1, struct client_file *cf2)
 {
@@ -54,11 +61,47 @@ file_cmp(struct client_file *cf1, struct client_file *cf2)
 	return (0);
 }
 
+/*
+ * Create a file object in the client process - the peer is the server to send
+ * messages to. Check callback is fired when the file is finished with so the
+ * process can decide if it needs to exit (if it is waiting for files to
+ * flush).
+ */
 struct client_file *
-file_create(struct client *c, int stream, client_file_cb cb, void *cbdata)
+file_create_with_peer(struct tmuxpeer *peer, struct client_files *files,
+    int stream, client_file_cb cb, void *cbdata)
 {
 	struct client_file	*cf;
 
+	cf = xcalloc(1, sizeof *cf);
+	cf->c = NULL;
+	cf->references = 1;
+	cf->stream = stream;
+
+	cf->buffer = evbuffer_new();
+	if (cf->buffer == NULL)
+		fatalx("out of memory");
+
+	cf->cb = cb;
+	cf->data = cbdata;
+
+	cf->peer = peer;
+	cf->tree = files;
+	RB_INSERT(client_files, files, cf);
+
+	return (cf);
+}
+
+/* Create a file object in the server, communicating with the given client. */
+struct client_file *
+file_create_with_client(struct client *c, int stream, client_file_cb cb,
+    void *cbdata)
+{
+	struct client_file	*cf;
+
+	if (c != NULL && (c->flags & CLIENT_ATTACHED))
+		c = NULL;
+
 	cf = xcalloc(1, sizeof *cf);
 	cf->c = c;
 	cf->references = 1;
@@ -72,6 +115,8 @@ file_create(struct client *c, int stream, client_file_cb cb, void *cbdata)
 	cf->data = cbdata;
 
 	if (cf->c != NULL) {
+		cf->peer = cf->c->peer;
+		cf->tree = &cf->c->files;
 		RB_INSERT(client_files, &cf->c->files, cf);
 		cf->c->references++;
 	}
@@ -79,6 +124,7 @@ file_create(struct client *c, int stream, client_file_cb cb, void *cbdata)
 	return (cf);
 }
 
+/* Free a file. */
 void
 file_free(struct client_file *cf)
 {
@@ -88,13 +134,15 @@ file_free(struct client_file *cf)
 	evbuffer_free(cf->buffer);
 	free(cf->path);
 
-	if (cf->c != NULL) {
+	if (cf->tree != NULL)
-		RB_REMOVE(client_files, &cf->c->files, cf);
+		RB_REMOVE(client_files, cf->tree, cf);
+	if (cf->c != NULL)
 		server_client_unref(cf->c);
-	}
+
 	free(cf);
 }
 
+/* Event to fire the done callback. */
 static void
 file_fire_done_cb(__unused int fd, __unused short events, void *arg)
 {
@@ -106,21 +154,22 @@ file_fire_done_cb(__unused int fd, __unused short events, void *arg)
 	file_free(cf);
 }
 
+/* Add an event to fire the done callback (used by the server). */
 void
 file_fire_done(struct client_file *cf)
 {
 	event_once(-1, EV_TIMEOUT, file_fire_done_cb, cf, NULL);
 }
 
+/* Fire the read callback. */
 void
 file_fire_read(struct client_file *cf)
 {
-	struct client	*c = cf->c;
-
 	if (cf->cb != NULL)
-		cf->cb(c, cf->path, cf->error, 0, cf->buffer, cf->data);
+		cf->cb(cf->c, cf->path, cf->error, 0, cf->buffer, cf->data);
 }
 
+/* Can this file be printed to? */
 int
 file_can_print(struct client *c)
 {
@@ -131,6 +180,7 @@ file_can_print(struct client *c)
 	return (1);
 }
 
+/* Print a message to a file. */
 void
 file_print(struct client *c, const char *fmt, ...)
 {
@@ -141,6 +191,7 @@ file_print(struct client *c, const char *fmt, ...)
 	va_end(ap);
 }
 
+/* Print a message to a file. */
 void
 file_vprint(struct client *c, const char *fmt, va_list ap)
 {
@@ -152,7 +203,7 @@ file_vprint(struct client *c, const char *fmt, va_list ap)
 
 	find.stream = 1;
 	if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL) {
-		cf = file_create(c, 1, NULL, NULL);
+		cf = file_create_with_client(c, 1, NULL, NULL);
 		cf->path = xstrdup("-");
 
 		evbuffer_add_vprintf(cf->buffer, fmt, ap);
@@ -167,6 +218,7 @@ file_vprint(struct client *c, const char *fmt, va_list ap)
 	}
 }
 
+/* Print a buffer to a file. */
 void
 file_print_buffer(struct client *c, void *data, size_t size)
 {
@@ -178,7 +230,7 @@ file_print_buffer(struct client *c, void *data, size_t size)
 
 	find.stream = 1;
 	if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL) {
-		cf = file_create(c, 1, NULL, NULL);
+		cf = file_create_with_client(c, 1, NULL, NULL);
 		cf->path = xstrdup("-");
 
 		evbuffer_add(cf->buffer, data, size);
@@ -193,6 +245,7 @@ file_print_buffer(struct client *c, void *data, size_t size)
 	}
 }
 
+/* Report an error to a file. */
 void
 file_error(struct client *c, const char *fmt, ...)
 {
@@ -207,7 +260,7 @@ file_error(struct client *c, const char *fmt, ...)
 
 	find.stream = 2;
 	if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL) {
-		cf = file_create(c, 2, NULL, NULL);
+		cf = file_create_with_client(c, 2, NULL, NULL);
 		cf->path = xstrdup("-");
 
 		evbuffer_add_vprintf(cf->buffer, fmt, ap);
@@ -224,30 +277,34 @@ file_error(struct client *c, const char *fmt, ...)
 	va_end(ap);
 }
 
+/* Write data to a file. */
 void
 file_write(struct client *c, const char *path, int flags, const void *bdata,
     size_t bsize, client_file_cb cb, void *cbdata)
 {
 	struct client_file	*cf;
-	FILE			*f;
 	struct msg_write_open	*msg;
 	size_t			 msglen;
 	int			 fd = -1;
+	u_int			 stream = file_next_stream++;
+	FILE			*f;
 	const char		*mode;
 
 	if (strcmp(path, "-") == 0) {
-		cf = file_create(c, file_next_stream++, cb, cbdata);
+		cf = file_create_with_client(c, stream, cb, cbdata);
 		cf->path = xstrdup("-");
 
 		fd = STDOUT_FILENO;
-		if (c == NULL || c->flags & CLIENT_ATTACHED) {
+		if (c == NULL ||
+		    (c->flags & CLIENT_ATTACHED) ||
+		    (c->flags & CLIENT_CONTROL)) {
 			cf->error = EBADF;
 			goto done;
 		}
 		goto skip;
 	}
 
-	cf = file_create(c, file_next_stream++, cb, cbdata);
+	cf = file_create_with_client(c, stream, cb, cbdata);
 	cf->path = file_get_path(c, path);
 
 	if (c == NULL || c->flags & CLIENT_ATTACHED) {
@@ -282,7 +339,7 @@ skip:
 	msg->fd = fd;
 	msg->flags = flags;
 	memcpy(msg + 1, cf->path, msglen - sizeof *msg);
-	if (proc_send(c->peer, MSG_WRITE_OPEN, -1, msg, msglen) != 0) {
+	if (proc_send(cf->peer, MSG_WRITE_OPEN, -1, msg, msglen) != 0) {
 		free(msg);
 		cf->error = EINVAL;
 		goto done;
@@ -294,29 +351,34 @@ done:
 	file_fire_done(cf);
 }
 
+/* Read a file. */
 void
 file_read(struct client *c, const char *path, client_file_cb cb, void *cbdata)
 {
 	struct client_file	*cf;
-	FILE			*f;
 	struct msg_read_open	*msg;
-	size_t			 msglen, size;
+	size_t			 msglen;
 	int			 fd = -1;
+	u_int			 stream = file_next_stream++;
+	FILE			*f;
+	size_t			 size;
 	char			 buffer[BUFSIZ];
 
 	if (strcmp(path, "-") == 0) {
-		cf = file_create(c, file_next_stream++, cb, cbdata);
+		cf = file_create_with_client(c, stream, cb, cbdata);
 		cf->path = xstrdup("-");
 
 		fd = STDIN_FILENO;
-		if (c == NULL || c->flags & CLIENT_ATTACHED) {
+		if (c == NULL ||
+		    (c->flags & CLIENT_ATTACHED) ||
+		    (c->flags & CLIENT_CONTROL)) {
 			cf->error = EBADF;
 			goto done;
 		}
 		goto skip;
 	}
 
-	cf = file_create(c, file_next_stream++, cb, cbdata);
+	cf = file_create_with_client(c, stream, cb, cbdata);
 	cf->path = file_get_path(c, path);
 
 	if (c == NULL || c->flags & CLIENT_ATTACHED) {
@@ -352,7 +414,7 @@ skip:
 	msg->stream = cf->stream;
 	msg->fd = fd;
 	memcpy(msg + 1, cf->path, msglen - sizeof *msg);
-	if (proc_send(c->peer, MSG_READ_OPEN, -1, msg, msglen) != 0) {
+	if (proc_send(cf->peer, MSG_READ_OPEN, -1, msg, msglen) != 0) {
 		free(msg);
 		cf->error = EINVAL;
 		goto done;
@@ -364,21 +426,21 @@ done:
 	file_fire_done(cf);
 }
 
+/* Push event, fired if there is more writing to be done. */
 static void
 file_push_cb(__unused int fd, __unused short events, void *arg)
 {
 	struct client_file	*cf = arg;
-	struct client		*c = cf->c;
 
-	if (~c->flags & CLIENT_DEAD)
+	if (cf->c == NULL || ~cf->c->flags & CLIENT_DEAD)
 		file_push(cf);
 	file_free(cf);
 }
 
+/* Push uwritten data to the client for a file, if it will accept it. */
 void
 file_push(struct client_file *cf)
 {
-	struct client		*c = cf->c;
 	struct msg_write_data	*msg;
 	size_t			 msglen, sent, left;
 	struct msg_write_close	 close;
@@ -394,21 +456,364 @@ file_push(struct client_file *cf)
 		msg = xrealloc(msg, msglen);
 		msg->stream = cf->stream;
 		memcpy(msg + 1, EVBUFFER_DATA(cf->buffer), sent);
-		if (proc_send(c->peer, MSG_WRITE, -1, msg, msglen) != 0)
+		if (proc_send(cf->peer, MSG_WRITE, -1, msg, msglen) != 0)
 			break;
 		evbuffer_drain(cf->buffer, sent);
 
 		left = EVBUFFER_LENGTH(cf->buffer);
-		log_debug("%s: file %d sent %zu, left %zu", c->name, cf->stream,
+		log_debug("file %d sent %zu, left %zu", cf->stream, sent, left);
-		    sent, left);
 	}
 	if (left != 0) {
 		cf->references++;
 		event_once(-1, EV_TIMEOUT, file_push_cb, cf, NULL);
 	} else if (cf->stream > 2) {
 		close.stream = cf->stream;
-		proc_send(c->peer, MSG_WRITE_CLOSE, -1, &close, sizeof close);
+		proc_send(cf->peer, MSG_WRITE_CLOSE, -1, &close, sizeof close);
 		file_fire_done(cf);
 	}
 	free(msg);
 }
+
+/* Check if any files have data left to write. */
+int
+file_write_left(struct client_files *files)
+{
+	struct client_file	*cf;
+	size_t			 left;
+	int			 waiting = 0;
+
+	RB_FOREACH(cf, client_files, files) {
+		if (cf->event == NULL)
+			continue;
+		left = EVBUFFER_LENGTH(cf->event->output);
+		if (left != 0) {
+			waiting++;
+			log_debug("file %u %zu bytes left", cf->stream, left);
+		}
+	}
+	return (waiting != 0);
+}
+
+/* Client file write error callback. */
+static void
+file_write_error_callback(__unused struct bufferevent *bev, __unused short what,
+    void *arg)
+{
+	struct client_file	*cf = arg;
+
+	log_debug("write error file %d", cf->stream);
+
+	if (cf->cb != NULL)
+		cf->cb(NULL, NULL, 0, -1, NULL, cf->data);
+
+	bufferevent_free(cf->event);
+	cf->event = NULL;
+
+	close(cf->fd);
+	cf->fd = -1;
+}
+
+/* Client file write callback. */
+static void
+file_write_callback(__unused struct bufferevent *bev, void *arg)
+{
+	struct client_file	*cf = arg;
+
+	log_debug("write check file %d", cf->stream);
+
+	if (cf->cb != NULL)
+		cf->cb(NULL, NULL, 0, -1, NULL, cf->data);
+
+	if (cf->closed && EVBUFFER_LENGTH(cf->event->output) == 0) {
+		bufferevent_free(cf->event);
+		close(cf->fd);
+		RB_REMOVE(client_files, cf->tree, cf);
+		file_free(cf);
+	}
+}
+
+/* Handle a file write open message (client). */
+void
+file_write_open(struct client_files *files, struct tmuxpeer *peer,
+    struct imsg *imsg, int allow_streams, int close_received,
+    client_file_cb cb, void *cbdata)
+{
+	struct msg_write_open	*msg = imsg->data;
+	size_t			 msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
+	const char		*path;
+	struct msg_write_ready	 reply;
+	struct client_file	 find, *cf;
+	const int		 flags = O_NONBLOCK|O_WRONLY|O_CREAT;
+	int			 error = 0;
+
+	if (msglen < sizeof *msg)
+		fatalx("bad MSG_WRITE_OPEN size");
+	if (msglen == sizeof *msg)
+		path = "-";
+	else
+		path = (const char *)(msg + 1);
+	log_debug("open write file %d %s", msg->stream, path);
+
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, files, &find)) != NULL) {
+		error = EBADF;
+		goto reply;
+	}
+	cf = file_create_with_peer(peer, files, msg->stream, cb, cbdata);
+	if (cf->closed) {
+		error = EBADF;
+		goto reply;
+	}
+
+	cf->fd = -1;
+	if (msg->fd == -1)
+		cf->fd = open(path, msg->flags|flags, 0644);
+	else if (allow_streams) {
+		if (msg->fd != STDOUT_FILENO && msg->fd != STDERR_FILENO)
+			errno = EBADF;
+		else {
+			cf->fd = dup(msg->fd);
+			if (close_received)
+				close(msg->fd); /* can only be used once */
+		}
+	} else
+	      errno = EBADF;
+	if (cf->fd == -1) {
+		error = errno;
+		goto reply;
+	}
+
+	cf->event = bufferevent_new(cf->fd, NULL, file_write_callback,
+	    file_write_error_callback, cf);
+	bufferevent_enable(cf->event, EV_WRITE);
+	goto reply;
+
+reply:
+	reply.stream = msg->stream;
+	reply.error = error;
+	proc_send(peer, MSG_WRITE_READY, -1, &reply, sizeof reply);
+}
+
+/* Handle a file write data message (client). */
+void
+file_write_data(struct client_files *files, struct imsg *imsg)
+{
+	struct msg_write_data	*msg = imsg->data;
+	size_t			 msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
+	struct client_file	 find, *cf;
+	size_t			 size = msglen - sizeof *msg;
+
+	if (msglen < sizeof *msg)
+		fatalx("bad MSG_WRITE size");
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, files, &find)) == NULL)
+		fatalx("unknown stream number");
+	log_debug("write %zu to file %d", size, cf->stream);
+
+	if (cf->event != NULL)
+		bufferevent_write(cf->event, msg + 1, size);
+}
+
+/* Handle a file write close message (client). */
+void
+file_write_close(struct client_files *files, struct imsg *imsg)
+{
+	struct msg_write_close	*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_CLOSE size");
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, files, &find)) == NULL)
+		fatalx("unknown stream number");
+	log_debug("close file %d", cf->stream);
+
+	if (cf->event == NULL || EVBUFFER_LENGTH(cf->event->output) == 0) {
+		if (cf->event != NULL)
+			bufferevent_free(cf->event);
+		if (cf->fd != -1)
+			close(cf->fd);
+		RB_REMOVE(client_files, files, cf);
+		file_free(cf);
+	}
+}
+
+/* Client file read error callback. */
+static void
+file_read_error_callback(__unused struct bufferevent *bev, __unused short what,
+    void *arg)
+{
+	struct client_file	*cf = arg;
+	struct msg_read_done	 msg;
+
+	log_debug("read error file %d", cf->stream);
+
+	msg.stream = cf->stream;
+	msg.error = 0;
+	proc_send(cf->peer, MSG_READ_DONE, -1, &msg, sizeof msg);
+
+	bufferevent_free(cf->event);
+	close(cf->fd);
+	RB_REMOVE(client_files, cf->tree, cf);
+	file_free(cf);
+}
+
+/* Client file read callback. */
+static void
+file_read_callback(__unused struct bufferevent *bev, void *arg)
+{
+	struct client_file	*cf = arg;
+	void			*bdata;
+	size_t			 bsize;
+	struct msg_read_data	*msg;
+	size_t			 msglen;
+
+	msg = xmalloc(sizeof *msg);
+	for (;;) {
+		bdata = EVBUFFER_DATA(cf->event->input);
+		bsize = EVBUFFER_LENGTH(cf->event->input);
+
+		if (bsize == 0)
+			break;
+		if (bsize > MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg)
+			bsize = MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg;
+		log_debug("read %zu from file %d", bsize, cf->stream);
+
+		msglen = (sizeof *msg) + bsize;
+		msg = xrealloc(msg, msglen);
+		msg->stream = cf->stream;
+		memcpy(msg + 1, bdata, bsize);
+		proc_send(cf->peer, MSG_READ, -1, msg, msglen);
+
+		evbuffer_drain(cf->event->input, bsize);
+	}
+	free(msg);
+}
+
+/* Handle a file read open message (client). */
+void
+file_read_open(struct client_files *files, struct tmuxpeer *peer,
+    struct imsg *imsg, int allow_streams, int close_received, client_file_cb cb,
+    void *cbdata)
+{
+	struct msg_read_open	*msg = imsg->data;
+	size_t			 msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
+	const char		*path;
+	struct msg_read_done	 reply;
+	struct client_file	 find, *cf;
+	const int		 flags = O_NONBLOCK|O_RDONLY;
+	int			 error;
+
+	if (msglen < sizeof *msg)
+		fatalx("bad MSG_READ_OPEN size");
+	if (msglen == sizeof *msg)
+		path = "-";
+	else
+		path = (const char *)(msg + 1);
+	log_debug("open read file %d %s", msg->stream, path);
+
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, files, &find)) != NULL) {
+		error = EBADF;
+		goto reply;
+	}
+	cf = file_create_with_peer(peer, files, msg->stream, cb, cbdata);
+	if (cf->closed) {
+		error = EBADF;
+		goto reply;
+	}
+
+	cf->fd = -1;
+	if (msg->fd == -1)
+		cf->fd = open(path, flags);
+	else if (allow_streams) {
+		if (msg->fd != STDIN_FILENO)
+			errno = EBADF;
+		else {
+			cf->fd = dup(msg->fd);
+			if (close_received)
+				close(msg->fd); /* can only be used once */
+		}
+	} else
+		errno = EBADF;
+	if (cf->fd == -1) {
+		error = errno;
+		goto reply;
+	}
+
+	cf->event = bufferevent_new(cf->fd, file_read_callback, NULL,
+	    file_read_error_callback, cf);
+	bufferevent_enable(cf->event, EV_READ);
+	return;
+
+reply:
+	reply.stream = msg->stream;
+	reply.error = error;
+	proc_send(peer, MSG_READ_DONE, -1, &reply, sizeof reply);
+}
+
+/* Handle a write ready message (server). */
+void
+file_write_ready(struct client_files *files, struct imsg *imsg)
+{
+	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, files, &find)) == NULL)
+		return;
+	if (msg->error != 0) {
+		cf->error = msg->error;
+		file_fire_done(cf);
+	} else
+		file_push(cf);
+}
+
+/* Handle read data message (server). */
+void
+file_read_data(struct client_files *files, struct imsg *imsg)
+{
+	struct msg_read_data	*msg = imsg->data;
+	size_t			 msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
+	struct client_file	 find, *cf;
+	void			*bdata = msg + 1;
+	size_t			 bsize = msglen - sizeof *msg;
+
+	if (msglen < sizeof *msg)
+		fatalx("bad MSG_READ_DATA size");
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, files, &find)) == NULL)
+		return;
+
+	log_debug("file %d read %zu bytes", 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);
+	}
+}
+
+/* Handle a read done message (server). */
+void
+file_read_done(struct client_files *files, struct imsg *imsg)
+{
+	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, files, &find)) == NULL)
+		return;
+
+	log_debug("file %d read done", cf->stream);
+	cf->error = msg->error;
+	file_fire_done(cf);
+}

format-draw.c

@@ -157,13 +157,14 @@ format_draw_put_list(struct screen_write_ctx *octx,
 static void
 format_draw_none(struct screen_write_ctx *octx, u_int available, u_int ocx,
     u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
-    struct format_ranges *frs)
+    struct screen *abs_centre, struct format_ranges *frs)
 {
-	u_int	width_left, width_centre, width_right;
+	u_int	width_left, width_centre, width_right, width_abs_centre;
 
 	width_left = left->cx;
 	width_centre = centre->cx;
 	width_right = right->cx;
+	width_abs_centre = abs_centre->cx;
 
 	/*
 	 * Try to keep as much of the left and right as possible at the expense
@@ -199,23 +200,34 @@ format_draw_none(struct screen_write_ctx *octx, u_int available, u_int ocx,
 	    - width_centre / 2,
 	    centre->cx / 2 - width_centre / 2,
 	    width_centre);
+
+	/*
+	 * Write abs_centre in the perfect centre of all horizontal space.
+	 */
+	if (width_abs_centre > available)
+		width_abs_centre = available;
+	format_draw_put(octx, ocx, ocy, abs_centre, frs,
+	    (available - width_abs_centre) / 2,
+	    0,
+	    width_abs_centre);
 }
 
 /* Draw format with list on the left. */
 static void
 format_draw_left(struct screen_write_ctx *octx, u_int available, u_int ocx,
     u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
-    struct screen *list, struct screen *list_left, struct screen *list_right,
+    struct screen *abs_centre, struct screen *list, struct screen *list_left,
-    struct screen *after, int focus_start, int focus_end,
+    struct screen *list_right, struct screen *after, int focus_start,
-    struct format_ranges *frs)
+    int focus_end, struct format_ranges *frs)
 {
 	u_int			width_left, width_centre, width_right;
-	u_int			width_list, width_after;
+	u_int			width_list, width_after, width_abs_centre;
 	struct screen_write_ctx	ctx;
 
 	width_left = left->cx;
 	width_centre = centre->cx;
 	width_right = right->cx;
+	width_abs_centre = abs_centre->cx;
 	width_list = list->cx;
 	width_after = after->cx;
 
@@ -242,12 +254,12 @@ format_draw_left(struct screen_write_ctx *octx, u_int available, u_int ocx,
 
 	/* If there is no list left, pass off to the no list function. */
 	if (width_list == 0) {
-		screen_write_start(&ctx, NULL, left);
+		screen_write_start(&ctx, left);
 		screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
 		screen_write_stop(&ctx);
 
 		format_draw_none(octx, available, ocx, ocy, left, centre,
-		    right, frs);
+		    right, abs_centre, frs);
 		return;
 	}
 
@@ -291,23 +303,34 @@ format_draw_left(struct screen_write_ctx *octx, u_int available, u_int ocx,
 		focus_start = focus_end = 0;
 	format_draw_put_list(octx, ocx, ocy, width_left, width_list, list,
 	    list_left, list_right, focus_start, focus_end, frs);
+
+	/*
+	 * Write abs_centre in the perfect centre of all horizontal space.
+	 */
+	if (width_abs_centre > available)
+		width_abs_centre = available;
+	format_draw_put(octx, ocx, ocy, abs_centre, frs,
+	    (available - width_abs_centre) / 2,
+	    0,
+	    width_abs_centre);
 }
 
 /* Draw format with list in the centre. */
 static void
 format_draw_centre(struct screen_write_ctx *octx, u_int available, u_int ocx,
     u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
-    struct screen *list, struct screen *list_left, struct screen *list_right,
+    struct screen *abs_centre, struct screen *list, struct screen *list_left,
-    struct screen *after, int focus_start, int focus_end,
+    struct screen *list_right, struct screen *after, int focus_start,
-    struct format_ranges *frs)
+    int focus_end, struct format_ranges *frs)
 {
-	u_int			width_left, width_centre, width_right;
+	u_int			width_left, width_centre, width_right, middle;
-	u_int			width_list, width_after, middle;
+	u_int			width_list, width_after, width_abs_centre;
 	struct screen_write_ctx	ctx;
 
 	width_left = left->cx;
 	width_centre = centre->cx;
 	width_right = right->cx;
+	width_abs_centre = abs_centre->cx;
 	width_list = list->cx;
 	width_after = after->cx;
 
@@ -334,12 +357,12 @@ format_draw_centre(struct screen_write_ctx *octx, u_int available, u_int ocx,
 
 	/* If there is no list left, pass off to the no list function. */
 	if (width_list == 0) {
-		screen_write_start(&ctx, NULL, centre);
+		screen_write_start(&ctx, centre);
 		screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
 		screen_write_stop(&ctx);
 
 		format_draw_none(octx, available, ocx, ocy, left, centre,
-		    right, frs);
+		    right, abs_centre, frs);
 		return;
 	}
 
@@ -388,23 +411,34 @@ format_draw_centre(struct screen_write_ctx *octx, u_int available, u_int ocx,
 	format_draw_put_list(octx, ocx, ocy, middle - width_list / 2,
 	    width_list, list, list_left, list_right, focus_start, focus_end,
 	    frs);
+
+	/*
+	 * Write abs_centre in the perfect centre of all horizontal space.
+	 */
+	if (width_abs_centre > available)
+		width_abs_centre = available;
+	format_draw_put(octx, ocx, ocy, abs_centre, frs,
+	    (available - width_abs_centre) / 2,
+	    0,
+	    width_abs_centre);
 }
 
 /* Draw format with list on the right. */
 static void
 format_draw_right(struct screen_write_ctx *octx, u_int available, u_int ocx,
     u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
-    struct screen *list, struct screen *list_left, struct screen *list_right,
+    struct screen *abs_centre,     struct screen *list,
-    struct screen *after, int focus_start, int focus_end,
+    struct screen *list_left, struct screen *list_right, struct screen *after,
-    struct format_ranges *frs)
+    int focus_start, int focus_end, struct format_ranges *frs)
 {
 	u_int			width_left, width_centre, width_right;
-	u_int			width_list, width_after;
+	u_int			width_list, width_after, width_abs_centre;
 	struct screen_write_ctx	ctx;
 
 	width_left = left->cx;
 	width_centre = centre->cx;
 	width_right = right->cx;
+	width_abs_centre = abs_centre->cx;
 	width_list = list->cx;
 	width_after = after->cx;
 
@@ -431,12 +465,12 @@ format_draw_right(struct screen_write_ctx *octx, u_int available, u_int ocx,
 
 	/* If there is no list left, pass off to the no list function. */
 	if (width_list == 0) {
-		screen_write_start(&ctx, NULL, right);
+		screen_write_start(&ctx, right);
 		screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
 		screen_write_stop(&ctx);
 
 		format_draw_none(octx, available, ocx, ocy, left, centre,
-		    right, frs);
+		    right, abs_centre, frs);
 		return;
 	}
 
@@ -484,6 +518,130 @@ format_draw_right(struct screen_write_ctx *octx, u_int available, u_int ocx,
 	format_draw_put_list(octx, ocx, ocy, available - width_list -
 	    width_after, width_list, list, list_left, list_right, focus_start,
 	    focus_end, frs);
+
+	/*
+	 * Write abs_centre in the perfect centre of all horizontal space.
+	 */
+	if (width_abs_centre > available)
+		width_abs_centre = available;
+	format_draw_put(octx, ocx, ocy, abs_centre, frs,
+	    (available - width_abs_centre) / 2,
+	    0,
+	    width_abs_centre);
+}
+
+static void
+format_draw_absolute_centre(struct screen_write_ctx *octx, u_int available,
+    u_int ocx, u_int ocy, struct screen *left, struct screen *centre,
+    struct screen *right, struct screen *abs_centre, struct screen *list,
+    struct screen *list_left, struct screen *list_right, struct screen *after,
+    int focus_start, int focus_end, struct format_ranges *frs)
+{
+	u_int	width_left, width_centre, width_right, width_abs_centre;
+	u_int	width_list, width_after, middle, abs_centre_offset;
+
+	width_left = left->cx;
+	width_centre = centre->cx;
+	width_right = right->cx;
+	width_abs_centre = abs_centre->cx;
+	width_list = list->cx;
+	width_after = after->cx;
+
+	/*
+	 * Trim first centre, then the right, then the left.
+	 */
+	while (width_left +
+	    width_centre +
+	    width_right > available) {
+		if (width_centre > 0)
+			width_centre--;
+		else if (width_right > 0)
+			width_right--;
+		else
+			width_left--;
+	}
+
+	/*
+	 * We trim list after and abs_centre independently, as we are drawing
+	 * them over the rest. Trim first the list, then after the list, then
+	 * abs_centre.
+	 */
+	while (width_list + width_after + width_abs_centre > available) {
+		if (width_list > 0)
+			width_list--;
+		else if (width_after > 0)
+			width_after--;
+		else
+			width_abs_centre--;
+	}
+
+	/* Write left at 0. */
+	format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
+
+	/* Write right at available - width_right. */
+	format_draw_put(octx, ocx, ocy, right, frs,
+	    available - width_right,
+	    right->cx - width_right,
+	    width_right);
+
+	/*
+	 * Keep writing centre at the relative centre. Only the list is written
+	 * in the absolute centre of the horizontal space.
+	 */
+	middle = (width_left + ((available - width_right) - width_left) / 2);
+
+	/*
+	 * Write centre at
+	 *     middle - width_centre.
+	 */
+	format_draw_put(octx, ocx, ocy, centre, frs,
+		middle - width_centre,
+		0,
+		width_centre);
+
+	/*
+	 * If there is no focus given, keep the centre in focus.
+	 */
+	if (focus_start == -1 || focus_end == -1)
+		focus_start = focus_end = list->cx / 2;
+
+	/*
+	 * We centre abs_centre and the list together, so their shared centre is
+	 * in the perfect centre of horizontal space.
+	 */
+	abs_centre_offset = (available - width_list - width_abs_centre) / 2;
+
+	/*
+	 * Write abs_centre before the list.
+	 */
+	format_draw_put(octx, ocx, ocy, abs_centre, frs, abs_centre_offset,
+	    0, width_abs_centre);
+	abs_centre_offset += width_abs_centre;
+
+	/*
+	 * Draw the list in the absolute centre
+	 */
+	format_draw_put_list(octx, ocx, ocy, abs_centre_offset, width_list,
+	    list, list_left, list_right, focus_start, focus_end, frs);
+	abs_centre_offset += width_list;
+
+	/*
+	 * Write after at the end of the centre
+	 */
+	format_draw_put(octx, ocx, ocy, after, frs, abs_centre_offset, 0,
+	    width_after);
+}
+
+/* Draw multiple characters. */
+static void
+format_draw_many(struct screen_write_ctx *ctx, struct style *sy, char ch,
+    u_int n)
+{
+	u_int	i;
+
+	utf8_set(&sy->gc.data, ch);
+	for (i = 0; i < n; i++)
+		screen_write_cell(ctx, &sy->gc);
 }
 
 /* Draw a format to a screen. */
@@ -494,6 +652,7 @@ format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
 	enum { LEFT,
 	       CENTRE,
 	       RIGHT,
+	       ABSOLUTE_CENTRE,
 	       LIST,
 	       LIST_LEFT,
 	       LIST_RIGHT,
@@ -502,6 +661,7 @@ format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
 	const char	        *names[] = { "LEFT",
 					     "CENTRE",
 					     "RIGHT",
+					     "ABSOLUTE_CENTRE",
 					     "LIST",
 					     "LIST_LEFT",
 					     "LIST_RIGHT",
@@ -509,10 +669,14 @@ format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
 	size_t			 size = strlen(expanded);
 	struct screen		*os = octx->s, s[TOTAL];
 	struct screen_write_ctx	 ctx[TOTAL];
-	u_int			 ocx = os->cx, ocy = os->cy, i, width[TOTAL];
+	u_int			 ocx = os->cx, ocy = os->cy, n, i, width[TOTAL];
-	u_int			 map[] = { LEFT, LEFT, CENTRE, RIGHT };
+	u_int			 map[] = { LEFT,
+					   LEFT,
+					   CENTRE,
+					   RIGHT,
+					   ABSOLUTE_CENTRE };
 	int			 focus_start = -1, focus_end = -1;
-	int			 list_state = -1, fill = -1;
+	int			 list_state = -1, fill = -1, even;
 	enum style_align	 list_align = STYLE_ALIGN_DEFAULT;
 	struct grid_cell	 gc, current_default;
 	struct style		 sy, saved_sy;
@@ -536,7 +700,7 @@ format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
 	 */
 	for (i = 0; i < TOTAL; i++) {
 		screen_init(&s[i], size, 1, 0);
-		screen_write_start(&ctx[i], NULL, &s[i]);
+		screen_write_start(&ctx[i], &s[i]);
 		screen_write_clearendofline(&ctx[i], current_default.bg);
 		width[i] = 0;
 	}
@@ -547,7 +711,39 @@ format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
 	 */
 	cp = expanded;
 	while (*cp != '\0') {
-		if (cp[0] != '#' || cp[1] != '[') {
+		/* Handle sequences of #. */
+		if (cp[0] == '#' && cp[1] != '[' && cp[1] != '\0') {
+			for (n = 1; cp[n] == '#'; n++)
+				 /* nothing */;
+			even = ((n % 2) == 0);
+			if (cp[n] != '[') {
+				cp += n;
+				if (even)
+					n = (n / 2);
+				else
+					n = (n / 2) + 1;
+				width[current] += n;
+				format_draw_many(&ctx[current], &sy, '#', n);
+				continue;
+			}
+			if (even)
+				cp += (n + 1);
+			else
+				cp += (n - 1);
+			if (sy.ignore)
+				continue;
+			format_draw_many(&ctx[current], &sy, '#', n / 2);
+			width[current] += (n / 2);
+			if (even) {
+				utf8_set(ud, '[');
+				screen_write_cell(&ctx[current], &sy.gc);
+				width[current]++;
+			}
+			continue;
+		}
+
+		/* Is this not a style? */
+		if (cp[0] != '#' || cp[1] != '[' || sy.ignore) {
 			/* See if this is a UTF-8 character. */
 			if ((more = utf8_open(ud, *cp)) == UTF8_MORE) {
 				while (*++cp != '\0' && more == UTF8_MORE)
@@ -600,7 +796,8 @@ format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
 
 		/* If this style pushed or popped the default, update it. */
 		if (sy.default_type == STYLE_DEFAULT_PUSH) {
-			memcpy(&current_default, &saved_sy.gc, sizeof current_default);
+			memcpy(&current_default, &saved_sy.gc,
+			    sizeof current_default);
 			sy.default_type = STYLE_DEFAULT_BASE;
 		} else if (sy.default_type == STYLE_DEFAULT_POP) {
 			memcpy(&current_default, base, sizeof current_default);
@@ -738,31 +935,41 @@ format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
 
 	/*
 	 * Draw the screens. How they are arranged depends on where the list
-	 * appearsq.
+	 * appears.
 	 */
 	switch (list_align) {
 	case STYLE_ALIGN_DEFAULT:
 		/* No list. */
 		format_draw_none(octx, available, ocx, ocy, &s[LEFT],
-		    &s[CENTRE], &s[RIGHT], &frs);
+		    &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &frs);
 		break;
 	case STYLE_ALIGN_LEFT:
 		/* List is part of the left. */
 		format_draw_left(octx, available, ocx, ocy, &s[LEFT],
-		    &s[CENTRE], &s[RIGHT], &s[LIST], &s[LIST_LEFT],
+		    &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &s[LIST],
-		    &s[LIST_RIGHT], &s[AFTER], focus_start, focus_end, &frs);
+		    &s[LIST_LEFT], &s[LIST_RIGHT], &s[AFTER],
+		    focus_start, focus_end, &frs);
 		break;
 	case STYLE_ALIGN_CENTRE:
 		/* List is part of the centre. */
 		format_draw_centre(octx, available, ocx, ocy, &s[LEFT],
-		    &s[CENTRE], &s[RIGHT], &s[LIST], &s[LIST_LEFT],
+		    &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &s[LIST],
-		    &s[LIST_RIGHT], &s[AFTER], focus_start, focus_end, &frs);
+		    &s[LIST_LEFT], &s[LIST_RIGHT], &s[AFTER],
+		    focus_start, focus_end, &frs);
 		break;
 	case STYLE_ALIGN_RIGHT:
 		/* List is part of the right. */
 		format_draw_right(octx, available, ocx, ocy, &s[LEFT],
-		    &s[CENTRE], &s[RIGHT], &s[LIST], &s[LIST_LEFT],
+		    &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &s[LIST],
-		    &s[LIST_RIGHT], &s[AFTER], focus_start, focus_end, &frs);
+		    &s[LIST_LEFT], &s[LIST_RIGHT], &s[AFTER],
+		    focus_start, focus_end, &frs);
+		break;
+	case STYLE_ALIGN_ABSOLUTE_CENTRE:
+		/* List is in the centre of the entire horizontal space. */
+		format_draw_absolute_centre(octx, available, ocx, ocy, &s[LEFT],
+		    &s[CENTRE], &s[RIGHT], &s[ABSOLUTE_CENTRE], &s[LIST],
+		    &s[LIST_LEFT], &s[LIST_RIGHT], &s[AFTER],
+		    focus_start, focus_end, &frs);
 		break;
 	}
 
@@ -795,16 +1002,36 @@ u_int
 format_width(const char *expanded)
 {
 	const char		*cp, *end;
-	u_int			 width = 0;
+	u_int			 n, width = 0;
 	struct utf8_data	 ud;
 	enum utf8_state		 more;
 
 	cp = expanded;
 	while (*cp != '\0') {
-		if (cp[0] == '#' && cp[1] == '[') {
+		if (*cp == '#') {
+			for (n = 1; cp[n] == '#'; n++)
+				/* nothing */;
+			if (cp[n] != '[') {
+				width += n;
+				cp += n;
+				continue;
+			}
+			width += (n / 2); /* one for each ## */
+
+			if ((n % 2) == 0) {
+				/*
+				 * An even number of #s means that all #s are
+				 * escaped, so not a style.
+				 */
+				width++; /* one for the [ */
+				cp += (n + 1);
+				continue;
+			}
+			cp += (n - 1); /* point to the [ */
+
 			end = format_skip(cp + 2, "]");
 			if (end == NULL)
-				return 0;
+				return (0);
 			cp = end + 1;
 		} else if ((more = utf8_open(&ud, *cp)) == UTF8_MORE) {
 			while (*++cp != '\0' && more == UTF8_MORE)
@@ -822,19 +1049,57 @@ format_width(const char *expanded)
 	return (width);
 }
 
-/* Trim on the left, taking #[] into account. */
+/*
+ * Trim on the left, taking #[] into account.  Note, we copy the whole set of
+ * unescaped #s, but only add their escaped size to width. This is because the
+ * format_draw function will actually do the escaping when it runs
+ */
 char *
 format_trim_left(const char *expanded, u_int limit)
 {
 	char			*copy, *out;
 	const char		*cp = expanded, *end;
-	u_int			 width = 0;
+	u_int			 even, n, width = 0;
 	struct utf8_data	 ud;
 	enum utf8_state		 more;
 
-	out = copy = xmalloc(strlen(expanded) + 1);
+	out = copy = xcalloc(1, strlen(expanded) + 1);
 	while (*cp != '\0') {
-		if (cp[0] == '#' && cp[1] == '[') {
+		if (width >= limit)
+			break;
+		if (*cp == '#') {
+			for (end = cp + 1; *end == '#'; end++)
+				/* nothing */;
+			n = end - cp;
+			if (*end != '[') {
+				if (n > limit - width)
+					n = limit - width;
+				memcpy(out, cp, n);
+				out += n;
+				width += n;
+				cp = end;
+				continue;
+			}
+			even = ((n % 2) == 0);
+
+			n /= 2;
+			if (n > limit - width)
+				n = limit - width;
+			width += n;
+			n *= 2;
+			memcpy(out, cp, n);
+			out += n;
+
+			if (even) {
+				if (width + 1 <= limit) {
+					*out++ = '[';
+					width++;
+				}
+				cp = end + 1;
+				continue;
+			}
+			cp = end - 1;
+
 			end = format_skip(cp + 2, "]");
 			if (end == NULL)
 				break;
@@ -872,7 +1137,7 @@ format_trim_right(const char *expanded, u_int limit)
 {
 	char			*copy, *out;
 	const char		*cp = expanded, *end;
-	u_int			 width = 0, total_width, skip;
+	u_int			 width = 0, total_width, skip, old_n, even, n;
 	struct utf8_data	 ud;
 	enum utf8_state		 more;
 
@@ -881,12 +1146,64 @@ format_trim_right(const char *expanded, u_int limit)
 		return (xstrdup(expanded));
 	skip = total_width - limit;
 
-	out = copy = xmalloc(strlen(expanded) + 1);
+	out = copy = xcalloc(1, strlen(expanded) + 1);
 	while (*cp != '\0') {
-		if (cp[0] == '#' && cp[1] == '[') {
+		if (*cp == '#') {
+			for (end = cp + 1; *end == '#'; end++)
+				/* nothing */;
+			old_n = n = end - cp;
+			if (*end != '[') {
+				if (width <= skip) {
+					if (skip - width >= n)
+						n = 0;
+					else
+						n -= (skip - width);
+				}
+				if (n != 0) {
+					memcpy(out, cp, n);
+					out += n;
+				}
+
+				/*
+				 * The width always increases by the full
+				 * amount even if we can't copy anything yet.
+				 */
+				width += old_n;
+				cp = end;
+				continue;
+			}
+			even = ((n % 2) == 0);
+
+			n /= 2;
+			if (width <= skip) {
+				if (skip - width >= n)
+					n = 0;
+				else
+					n -= (skip - width);
+			}
+			if (n != 0) {
+				/*
+				 * Copy the full amount because it hasn't been
+				 * escaped yet.
+				 */
+				memcpy(out, cp, old_n);
+				out += old_n;
+			}
+			cp += old_n;
+			width += (old_n / 2) - even;
+
+			if (even) {
+				if (width > skip)
+					*out++ = '[';
+				width++;
+				continue;
+			}
+			cp = end - 1;
+
 			end = format_skip(cp + 2, "]");
-			if (end == NULL)
+			if (end == NULL) {
 				break;
+			}
 			memcpy(out, cp, end + 1 - cp);
 			out += (end + 1 - cp);
 			cp = end + 1;

fuzz/input-fuzzer.c

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2020 Sergey Nizovtsev <snizovtsev@gmail.com>
+ *
+ * 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 <stddef.h>
+#include <assert.h>
+
+#include "tmux.h"
+
+#define FUZZER_MAXLEN 512
+#define PANE_WIDTH 80
+#define PANE_HEIGHT 25
+
+struct event_base *libevent;
+
+int
+LLVMFuzzerTestOneInput(const unsigned char *data, size_t size)
+{
+	struct bufferevent	*vpty[2];
+	struct window		*w;
+	struct window_pane 	*wp;
+	int			 error;
+
+	/*
+	 * Since AFL doesn't support -max_len paramenter we have to
+	 * discard long inputs manually.
+	 */
+	if (size > FUZZER_MAXLEN)
+		return 0;
+
+	w = window_create(PANE_WIDTH, PANE_HEIGHT, 0, 0);
+	wp = window_add_pane(w, NULL, 0, 0);
+	bufferevent_pair_new(libevent, BEV_OPT_CLOSE_ON_FREE, vpty);
+	wp->ictx = input_init(wp, vpty[0]);
+	window_add_ref(w, __func__);
+
+	input_parse_buffer(wp, (u_char*) data, size);
+	while (cmdq_next(NULL) != 0)
+		;
+	error = event_base_loop(libevent, EVLOOP_NONBLOCK);
+	if (error == -1)
+		errx(1, "event_base_loop failed");
+
+	assert(w->references == 1);
+	window_remove_ref(w, __func__);
+
+	bufferevent_free(vpty[0]);
+	bufferevent_free(vpty[1]);
+
+	return 0;
+}
+
+int
+LLVMFuzzerInitialize(__unused int *argc, __unused char ***argv)
+{
+	const struct options_table_entry	*oe;
+
+	global_environ = environ_create();
+	global_options = options_create(NULL);
+	global_s_options = options_create(NULL);
+	global_w_options = options_create(NULL);
+	for (oe = options_table; oe->name != NULL; oe++) {
+		if (oe->scope & OPTIONS_TABLE_SERVER)
+			options_default(global_options, oe);
+		if (oe->scope & OPTIONS_TABLE_SESSION)
+			options_default(global_s_options, oe);
+		if (oe->scope & OPTIONS_TABLE_WINDOW)
+			options_default(global_w_options, oe);
+	}
+	libevent = osdep_event_init();
+
+	options_set_number(global_w_options, "monitor-bell", 0);
+	options_set_number(global_w_options, "allow-rename", 1);
+	options_set_number(global_options, "set-clipboard", 2);
+
+	return 0;
+}

fuzz/input-fuzzer.dict

@@ -0,0 +1,8 @@
+"\x1b["
+"1000"
+"2004"
+"1049"
+"38;2"
+"100;"
+"tmux;"
+"rgb:00/00/00"

fuzz/input-fuzzer.options

@@ -0,0 +1,2 @@
+[libfuzzer]
+max_len = 512

grid-reader.c

@@ -0,0 +1,389 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2020 Anindya Mukherjee <anindya49@hotmail.com>
+ *
+ * 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 "tmux.h"
+#include <string.h>
+
+/* Initialise virtual cursor. */
+void
+grid_reader_start(struct grid_reader *gr, struct grid *gd, u_int cx, u_int cy)
+{
+	gr->gd = gd;
+	gr->cx = cx;
+	gr->cy = cy;
+}
+
+/* Get cursor position from reader. */
+void
+grid_reader_get_cursor(struct grid_reader *gr, u_int *cx, u_int *cy)
+{
+	*cx = gr->cx;
+	*cy = gr->cy;
+}
+
+/* Get length of line containing the cursor. */
+u_int
+grid_reader_line_length(struct grid_reader *gr)
+{
+	return (grid_line_length(gr->gd, gr->cy));
+}
+
+/* Move cursor forward one position. */
+void
+grid_reader_cursor_right(struct grid_reader *gr, int wrap, int all)
+{
+	u_int			px;
+	struct grid_cell	gc;
+
+	if (all)
+		px = gr->gd->sx;
+	else
+		px = grid_reader_line_length(gr);
+
+	if (wrap && gr->cx >= px && gr->cy < gr->gd->hsize + gr->gd->sy - 1) {
+		grid_reader_cursor_start_of_line(gr, 0);
+		grid_reader_cursor_down(gr);
+	} else if (gr->cx < px) {
+		gr->cx++;
+		while (gr->cx < px) {
+			grid_get_cell(gr->gd, gr->cx, gr->cy, &gc);
+			if (~gc.flags & GRID_FLAG_PADDING)
+				break;
+			gr->cx++;
+		}
+	}
+}
+
+/* Move cursor back one position. */
+void
+grid_reader_cursor_left(struct grid_reader *gr, int wrap)
+{
+	struct grid_cell	gc;
+
+	while (gr->cx > 0) {
+		grid_get_cell(gr->gd, gr->cx, gr->cy, &gc);
+		if (~gc.flags & GRID_FLAG_PADDING)
+			break;
+		gr->cx--;
+	}
+	if (gr->cx == 0 && gr->cy > 0 &&
+	    (wrap ||
+	     grid_get_line(gr->gd, gr->cy - 1)->flags & GRID_LINE_WRAPPED)) {
+		grid_reader_cursor_up(gr);
+		grid_reader_cursor_end_of_line(gr, 0, 0);
+	} else if (gr->cx > 0)
+		gr->cx--;
+}
+
+/* Move cursor down one line. */
+void
+grid_reader_cursor_down(struct grid_reader *gr)
+{
+	struct grid_cell	gc;
+
+	if (gr->cy < gr->gd->hsize + gr->gd->sy - 1)
+		gr->cy++;
+	while (gr->cx > 0) {
+		grid_get_cell(gr->gd, gr->cx, gr->cy, &gc);
+		if (~gc.flags & GRID_FLAG_PADDING)
+			break;
+		gr->cx--;
+	}
+}
+
+/* Move cursor up one line. */
+void
+grid_reader_cursor_up(struct grid_reader *gr)
+{
+	struct grid_cell	gc;
+
+	if (gr->cy > 0)
+		gr->cy--;
+	while (gr->cx > 0) {
+		grid_get_cell(gr->gd, gr->cx, gr->cy, &gc);
+		if (~gc.flags & GRID_FLAG_PADDING)
+			break;
+		gr->cx--;
+	}
+}
+
+/* Move cursor to the start of the line. */
+void
+grid_reader_cursor_start_of_line(struct grid_reader *gr, int wrap)
+{
+	if (wrap) {
+		while (gr->cy > 0 &&
+		    grid_get_line(gr->gd, gr->cy - 1)->flags &
+		        GRID_LINE_WRAPPED)
+			gr->cy--;
+	}
+	gr->cx = 0;
+}
+
+/* Move cursor to the end of the line. */
+void
+grid_reader_cursor_end_of_line(struct grid_reader *gr, int wrap, int all)
+{
+	u_int	yy;
+
+	if (wrap) {
+		yy = gr->gd->hsize + gr->gd->sy - 1;
+		while (gr->cy < yy && grid_get_line(gr->gd, gr->cy)->flags &
+		    GRID_LINE_WRAPPED)
+			gr->cy++;
+	}
+	if (all)
+		gr->cx = gr->gd->sx;
+	else
+		gr->cx = grid_reader_line_length(gr);
+}
+
+/* Check if character under cursor is in set. */
+int
+grid_reader_in_set(struct grid_reader *gr, const char *set)
+{
+	struct grid_cell	gc;
+
+	grid_get_cell(gr->gd, gr->cx, gr->cy, &gc);
+	if (gc.flags & GRID_FLAG_PADDING)
+		return (0);
+	return (utf8_cstrhas(set, &gc.data));
+}
+
+/* Move cursor to the start of the next word. */
+void
+grid_reader_cursor_next_word(struct grid_reader *gr, const char *separators)
+{
+	u_int	xx, yy;
+	int expected = 0;
+
+	/* Do not break up wrapped words. */
+	if (grid_get_line(gr->gd, gr->cy)->flags & GRID_LINE_WRAPPED)
+		xx = gr->gd->sx - 1;
+	else
+		xx = grid_reader_line_length(gr);
+	yy = gr->gd->hsize + gr->gd->sy - 1;
+
+	/*
+	 * If we started inside a word, skip over word characters. Then skip
+	 * over separators till the next word.
+	 *
+	 * expected is initially set to 0 for the former and then 1 for the
+	 * latter. It is finally set to 0 when the beginning of the next word is
+	 * found.
+	 */
+	do {
+		while (gr->cx > xx ||
+		    grid_reader_in_set(gr, separators) == expected) {
+			/* Move down if we are past the end of the line. */
+			if (gr->cx > xx) {
+				if (gr->cy == yy)
+					return;
+				grid_reader_cursor_start_of_line(gr, 0);
+				grid_reader_cursor_down(gr);
+
+				if (grid_get_line(gr->gd, gr->cy)->flags &
+				    GRID_LINE_WRAPPED)
+					xx = gr->gd->sx - 1;
+				else
+					xx = grid_reader_line_length(gr);
+			} else
+				gr->cx++;
+		}
+		expected = !expected;
+	} while (expected == 1);
+}
+
+/* Move cursor to the end of the next word. */
+void
+grid_reader_cursor_next_word_end(struct grid_reader *gr, const char *separators)
+{
+	u_int	xx, yy;
+	int	expected = 1;
+
+	/* Do not break up wrapped words. */
+	if (grid_get_line(gr->gd, gr->cy)->flags & GRID_LINE_WRAPPED)
+		xx = gr->gd->sx - 1;
+	else
+		xx = grid_reader_line_length(gr);
+	yy = gr->gd->hsize + gr->gd->sy - 1;
+
+	/*
+	 * If we started on a separator, skip over separators. Then skip over
+	 * word characters till the next separator.
+	 *
+	 * expected is initially set to 1 for the former and then 1 for the
+	 * latter. It is finally set to 1 when the end of the next word is
+	 * found.
+	 */
+	do {
+		while (gr->cx > xx ||
+		    grid_reader_in_set(gr, separators) == expected) {
+			/* Move down if we are past the end of the line. */
+			if (gr->cx > xx) {
+				if (gr->cy == yy)
+					return;
+				grid_reader_cursor_start_of_line(gr, 0);
+				grid_reader_cursor_down(gr);
+
+				if (grid_get_line(gr->gd, gr->cy)->flags &
+				    GRID_LINE_WRAPPED)
+					xx = gr->gd->sx - 1;
+				else
+					xx = grid_reader_line_length(gr);
+			} else
+				gr->cx++;
+		}
+		expected = !expected;
+	} while (expected == 0);
+}
+
+/* Move to the previous place where a word begins. */
+void
+grid_reader_cursor_previous_word(struct grid_reader *gr, const char *separators,
+    int already)
+{
+	int	oldx, oldy, r;
+
+	/* Move back to the previous word character. */
+	if (already || grid_reader_in_set(gr, separators)) {
+		for (;;) {
+			if (gr->cx > 0) {
+				gr->cx--;
+				if (!grid_reader_in_set(gr, separators))
+					break;
+			} else {
+				if (gr->cy == 0)
+					return;
+				grid_reader_cursor_up(gr);
+				grid_reader_cursor_end_of_line(gr, 0, 0);
+
+				/* Stop if separator at EOL. */
+				if (gr->cx > 0) {
+					oldx = gr->cx;
+					gr->cx--;
+					r = grid_reader_in_set(gr, separators);
+					gr->cx = oldx;
+					if (r)
+						break;
+				}
+			}
+		}
+	}
+
+	/* Move back to the beginning of this word. */
+	do {
+		oldx = gr->cx;
+		oldy = gr->cy;
+		if (gr->cx == 0) {
+			if (gr->cy == 0 ||
+			  ~grid_get_line(gr->gd, gr->cy - 1)->flags &
+			  GRID_LINE_WRAPPED)
+				break;
+			grid_reader_cursor_up(gr);
+			grid_reader_cursor_end_of_line(gr, 0, 1);
+		}
+		if (gr->cx > 0)
+			gr->cx--;
+	} while (!grid_reader_in_set(gr, separators));
+	gr->cx = oldx;
+	gr->cy = oldy;
+}
+
+/* Jump forward to character. */
+int
+grid_reader_cursor_jump(struct grid_reader *gr, const struct utf8_data *jc)
+{
+	struct grid_cell	gc;
+	u_int			px, py, xx, yy;
+
+	px = gr->cx;
+	yy = gr->gd->hsize + gr->gd->sy - 1;
+
+	for (py = gr->cy; py <= yy; py++) {
+		xx = grid_line_length(gr->gd, py);
+		while (px < xx) {
+			grid_get_cell(gr->gd, px, py, &gc);
+			if (!(gc.flags & GRID_FLAG_PADDING) &&
+			    gc.data.size == jc->size &&
+			    memcmp(gc.data.data, jc->data, gc.data.size) == 0) {
+				gr->cx = px;
+				gr->cy = py;
+				return 1;
+			}
+			px++;
+		}
+
+		if (py == yy ||
+		    !(grid_get_line(gr->gd, py)->flags & GRID_LINE_WRAPPED))
+			return 0;
+		px = 0;
+	}
+	return 0;
+}
+
+/* Jump back to character. */
+int
+grid_reader_cursor_jump_back(struct grid_reader *gr, const struct utf8_data *jc)
+{
+	struct grid_cell	gc;
+	u_int			px, py, xx;
+
+	xx = gr->cx + 1;
+
+	for (py = gr->cy + 1; py > 0; py--) {
+		for (px = xx; px > 0; px--) {
+			grid_get_cell(gr->gd, px - 1, py - 1, &gc);
+			if (!(gc.flags & GRID_FLAG_PADDING) &&
+			    gc.data.size == jc->size &&
+			    memcmp(gc.data.data, jc->data, gc.data.size) == 0) {
+				gr->cx = px - 1;
+				gr->cy = py - 1;
+				return 1;
+			}
+		}
+
+		if (py == 1 ||
+		    !(grid_get_line(gr->gd, py - 2)->flags & GRID_LINE_WRAPPED))
+			return 0;
+		xx = grid_line_length(gr->gd, py - 2);
+	}
+	return 0;
+}
+
+/* Jump back to the first non-blank character of the line. */
+void
+grid_reader_cursor_back_to_indentation(struct grid_reader *gr)
+{
+	struct grid_cell	gc;
+	u_int			px, py, xx, yy;
+
+	yy = gr->gd->hsize + gr->gd->sy - 1;
+	grid_reader_cursor_start_of_line(gr, 1);
+
+	for (py = gr->cy; py <= yy; py++) {
+		xx = grid_line_length(gr->gd, py);
+		for (px = 0; px < xx; px++) {
+			grid_get_cell(gr->gd, px, py, &gc);
+			if (gc.data.size != 1 || *gc.data.data != ' ')
+				break;
+		}
+		if (~grid_get_line(gr->gd, py)->flags & GRID_LINE_WRAPPED)
+			break;
+	}
+}

grid-view.c

@@ -45,6 +45,13 @@ grid_view_set_cell(struct grid *gd, u_int px, u_int py,
 	grid_set_cell(gd, grid_view_x(gd, px), grid_view_y(gd, py), gc);
 }
 
+/* Set padding. */
+void
+grid_view_set_padding(struct grid *gd, u_int px, u_int py)
+{
+	grid_set_padding(gd, grid_view_x(gd, px), grid_view_y(gd, py));
+}
+
 /* Set cells. */
 void
 grid_view_set_cells(struct grid *gd, u_int px, u_int py,

grid.c

@@ -40,16 +40,22 @@ const struct grid_cell grid_default_cell = {
 	{ { ' ' }, 0, 1, 1 }, 0, 0, 8, 8, 0
 };
 
+/*
+ * Padding grid cell data. Padding cells are the only zero width cell that
+ * appears in the grid - because of this, they are always extended cells.
+ */
+static const struct grid_cell grid_padding_cell = {
+	{ { '!' }, 0, 0, 0 }, 0, GRID_FLAG_PADDING, 8, 8, 0
+};
+
 /* Cleared grid cell data. */
-const struct grid_cell grid_cleared_cell = {
+static const struct grid_cell grid_cleared_cell = {
 	{ { ' ' }, 0, 1, 1 }, 0, GRID_FLAG_CLEARED, 8, 8, 0
 };
 static const struct grid_cell_entry grid_cleared_entry = {
 	GRID_FLAG_CLEARED, { .data = { 0, 8, 8, ' ' } }
 };
 
-static void	grid_empty_line(struct grid *, u_int, u_int);
-
 /* Store cell in entry. */
 static void
 grid_store_cell(struct grid_cell_entry *gce, const struct grid_cell *gc,
@@ -102,12 +108,13 @@ grid_get_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce,
 }
 
 /* Set cell as extended. */
-static struct grid_cell *
+static struct grid_extd_entry *
 grid_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce,
     const struct grid_cell *gc)
 {
-	struct grid_cell	*gcp;
+	struct grid_extd_entry	*gee;
 	int			 flags = (gc->flags & ~GRID_FLAG_CLEARED);
+	utf8_char		 uc;
 
 	if (~gce->flags & GRID_FLAG_EXTENDED)
 		grid_get_extended_cell(gl, gce, flags);
@@ -115,10 +122,16 @@ grid_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce,
 		fatalx("offset too big");
 	gl->flags |= GRID_LINE_EXTENDED;
 
-	gcp = &gl->extddata[gce->offset];
+	utf8_from_data(&gc->data, &uc);
-	memcpy(gcp, gc, sizeof *gcp);
+
-	gcp->flags = flags;
+	gee = &gl->extddata[gce->offset];
-	return (gcp);
+	gee->data = uc;
+	gee->attr = gc->attr;
+	gee->flags = flags;
+	gee->fg = gc->fg;
+	gee->bg = gc->bg;
+	gee->us = gc->us;
+	return (gee);
 }
 
 /* Free up unused extended cells. */
@@ -126,9 +139,9 @@ static void
 grid_compact_line(struct grid_line *gl)
 {
 	int			 new_extdsize = 0;
-	struct grid_cell	*new_extddata;
+	struct grid_extd_entry	*new_extddata;
 	struct grid_cell_entry	*gce;
-	struct grid_cell	*gc;
+	struct grid_extd_entry	*gee;
 	u_int			 px, idx;
 
 	if (gl->extdsize == 0)
@@ -152,8 +165,8 @@ grid_compact_line(struct grid_line *gl)
 	for (px = 0; px < gl->cellsize; px++) {
 		gce = &gl->celldata[px];
 		if (gce->flags & GRID_FLAG_EXTENDED) {
-			gc = &gl->extddata[gce->offset];
+			gee = &gl->extddata[gce->offset];
-			memcpy(&new_extddata[idx], gc, sizeof *gc);
+			memcpy(&new_extddata[idx], gee, sizeof *gee);
 			gce->offset = idx++;
 		}
 	}
@@ -183,17 +196,14 @@ grid_clear_cell(struct grid *gd, u_int px, u_int py, u_int bg)
 {
 	struct grid_line	*gl = &gd->linedata[py];
 	struct grid_cell_entry	*gce = &gl->celldata[px];
-	struct grid_cell	*gc;
+	struct grid_extd_entry	*gee;
 
 	memcpy(gce, &grid_cleared_entry, sizeof *gce);
 	if (bg != 8) {
 		if (bg & COLOUR_FLAG_RGB) {
 			grid_get_extended_cell(gl, gce, gce->flags);
-			gl->flags |= GRID_LINE_EXTENDED;
+			gee = grid_extended_cell(gl, gce, &grid_cleared_cell);
-
+			gee->bg = bg;
-			gc = &gl->extddata[gce->offset];
-			memcpy(gc, &grid_cleared_cell, sizeof *gc);
-			gc->bg = bg;
 		} else {
 			if (bg & COLOUR_FLAG_256)
 				gce->flags |= GRID_FLAG_BG256;
@@ -213,19 +223,28 @@ grid_check_y(struct grid *gd, const char *from, u_int py)
 	return (0);
 }
 
+/* Check if two styles are (visibly) the same. */
+int
+grid_cells_look_equal(const struct grid_cell *gc1, const struct grid_cell *gc2)
+{
+	if (gc1->fg != gc2->fg || gc1->bg != gc2->bg)
+		return (0);
+	if (gc1->attr != gc2->attr || gc1->flags != gc2->flags)
+		return (0);
+	return (1);
+}
+
 /* Compare grid cells. Return 1 if equal, 0 if not. */
 int
-grid_cells_equal(const struct grid_cell *gca, const struct grid_cell *gcb)
+grid_cells_equal(const struct grid_cell *gc1, const struct grid_cell *gc2)
 {
-	if (gca->fg != gcb->fg || gca->bg != gcb->bg)
+	if (!grid_cells_look_equal(gc1, gc2))
 		return (0);
-	if (gca->attr != gcb->attr || gca->flags != gcb->flags)
+	if (gc1->data.width != gc2->data.width)
 		return (0);
-	if (gca->data.width != gcb->data.width)
+	if (gc1->data.size != gc2->data.size)
 		return (0);
-	if (gca->data.size != gcb->data.size)
+	return (memcmp(gc1->data.data, gc2->data.data, gc1->data.size) == 0);
-		return (0);
-	return (memcmp(gca->data.data, gcb->data.data, gca->data.size) == 0);
 }
 
 /* Free one line. */
@@ -258,7 +277,10 @@ grid_create(u_int sx, u_int sy, u_int hlimit)
 	gd->sx = sx;
 	gd->sy = sy;
 
-	gd->flags = GRID_HISTORY;
+	if (hlimit != 0)
+		gd->flags = GRID_HISTORY;
+	else
+		gd->flags = 0;
 
 	gd->hscrolled = 0;
 	gd->hsize = 0;
@@ -348,6 +370,19 @@ grid_collect_history(struct grid *gd)
 		gd->hscrolled = gd->hsize;
 }
 
+/* Remove lines from the bottom of the history. */
+void
+grid_remove_history(struct grid *gd, u_int ny)
+{
+	u_int	yy;
+
+	if (ny > gd->hsize)
+		return;
+	for (yy = 0; yy < ny; yy++)
+		grid_free_line(gd, gd->hsize + gd->sy - 1 - yy);
+	gd->hsize -= ny;
+}
+
 /*
  * Scroll the entire visible screen, moving one line into the history. Just
  * allocate a new line at the bottom and move the history size indicator.
@@ -428,7 +463,7 @@ grid_expand_line(struct grid *gd, u_int py, u_int sx, u_int bg)
 		sx = gd->sx / 4;
 	else if (sx < gd->sx / 2)
 		sx = gd->sx / 2;
-	else
+	else if (gd->sx > sx)
 		sx = gd->sx;
 
 	gl->celldata = xreallocarray(gl->celldata, sx, sizeof *gl->celldata);
@@ -438,7 +473,7 @@ grid_expand_line(struct grid *gd, u_int py, u_int sx, u_int bg)
 }
 
 /* Empty a line and set background colour if needed. */
-static void
+void
 grid_empty_line(struct grid *gd, u_int py, u_int bg)
 {
 	memset(&gd->linedata[py], 0, sizeof gd->linedata[py]);
@@ -460,12 +495,20 @@ static void
 grid_get_cell1(struct grid_line *gl, u_int px, struct grid_cell *gc)
 {
 	struct grid_cell_entry	*gce = &gl->celldata[px];
+	struct grid_extd_entry	*gee;
 
 	if (gce->flags & GRID_FLAG_EXTENDED) {
 		if (gce->offset >= gl->extdsize)
 			memcpy(gc, &grid_default_cell, sizeof *gc);
-		else
+		else {
-			memcpy(gc, &gl->extddata[gce->offset], sizeof *gc);
+			gee = &gl->extddata[gce->offset];
+			gc->flags = gee->flags;
+			gc->attr = gee->attr;
+			gc->fg = gee->fg;
+			gc->bg = gee->bg;
+			gc->us = gee->us;
+			utf8_to_data(gee->data, &gc->data);
+		}
 		return;
 	}
 
@@ -492,7 +535,7 @@ grid_get_cell(struct grid *gd, u_int px, u_int py, struct grid_cell *gc)
 		grid_get_cell1(&gd->linedata[py], px, gc);
 }
 
-/* Set cell at relative position. */
+/* Set cell at position. */
 void
 grid_set_cell(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc)
 {
@@ -515,14 +558,21 @@ grid_set_cell(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc)
 		grid_store_cell(gce, gc, gc->data.data[0]);
 }
 
-/* Set cells at relative position. */
+/* Set padding at position. */
+void
+grid_set_padding(struct grid *gd, u_int px, u_int py)
+{
+	grid_set_cell(gd, px, py, &grid_padding_cell);
+}
+
+/* Set cells at position. */
 void
 grid_set_cells(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc,
     const char *s, size_t slen)
 {
 	struct grid_line	*gl;
 	struct grid_cell_entry	*gce;
-	struct grid_cell	*gcp;
+	struct grid_extd_entry	*gee;
 	u_int			 i;
 
 	if (grid_check_y(gd, __func__, py) != 0)
@@ -537,8 +587,8 @@ grid_set_cells(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc,
 	for (i = 0; i < slen; i++) {
 		gce = &gl->celldata[px + i];
 		if (grid_need_extended_cell(gce, gc)) {
-			gcp = grid_extended_cell(gl, gce, gc);
+			gee = grid_extended_cell(gl, gce, gc);
-			utf8_set(&gcp->data, s[i]);
+			gee->data = utf8_build_one(s[i]);
 		} else
 			grid_store_cell(gce, gc, s[i]);
 	}
@@ -602,6 +652,8 @@ grid_clear_lines(struct grid *gd, u_int py, u_int ny, u_int bg)
 		grid_free_line(gd, yy);
 		grid_empty_line(gd, yy, bg);
 	}
+	if (py != 0)
+		gd->linedata[py - 1].flags &= ~GRID_LINE_WRAPPED;
 }
 
 /* Move a group of lines. */
@@ -628,6 +680,8 @@ grid_move_lines(struct grid *gd, u_int dy, u_int py, u_int ny, u_int bg)
 			continue;
 		grid_free_line(gd, yy);
 	}
+	if (dy != 0)
+		gd->linedata[dy - 1].flags &= ~GRID_LINE_WRAPPED;
 
 	memmove(&gd->linedata[dy], &gd->linedata[py],
 	    ny * (sizeof *gd->linedata));
@@ -640,6 +694,8 @@ grid_move_lines(struct grid *gd, u_int dy, u_int py, u_int ny, u_int bg)
 		if (yy < dy || yy >= dy + ny)
 			grid_empty_line(gd, yy, bg);
 	}
+	if (py != 0 && (py < dy || py >= dy + ny))
+		gd->linedata[py - 1].flags &= ~GRID_LINE_WRAPPED;
 }
 
 /* Move a group of cells. */
@@ -755,15 +811,15 @@ grid_string_cells_bg(const struct grid_cell *gc, int *values)
 		case 8:
 			values[n++] = 49;
 			break;
-		case 100:
+		case 90:
-		case 101:
+		case 91:
-		case 102:
+		case 92:
-		case 103:
+		case 93:
-		case 104:
+		case 94:
-		case 105:
+		case 95:
-		case 106:
+		case 96:
-		case 107:
+		case 97:
-			values[n++] = gc->bg - 10;
+			values[n++] = gc->bg + 10;
 			break;
 		}
 	}
@@ -989,14 +1045,14 @@ grid_duplicate_lines(struct grid *dst, u_int dy, struct grid *src, u_int sy,
 			    srcl->cellsize * sizeof *dstl->celldata);
 		} else
 			dstl->celldata = NULL;
-
 		if (srcl->extdsize != 0) {
 			dstl->extdsize = srcl->extdsize;
 			dstl->extddata = xreallocarray(NULL, dstl->extdsize,
 			    sizeof *dstl->extddata);
 			memcpy(dstl->extddata, srcl->extddata, dstl->extdsize *
 			    sizeof *dstl->extddata);
-		}
+		} else
+			dstl->extddata = NULL;
 
 		sy++;
 		dy++;
@@ -1220,7 +1276,7 @@ grid_reflow(struct grid *gd, u_int sx)
 	struct grid		*target;
 	struct grid_line	*gl;
 	struct grid_cell	 gc;
-	u_int			 yy, width, i, at, first;
+	u_int			 yy, width, i, at;
 
 	/*
 	 * Create a destination grid. This is just used as a container for the
@@ -1237,13 +1293,12 @@ grid_reflow(struct grid *gd, u_int sx)
 			continue;
 
 		/*
-		 * Work out the width of this line. first is the width of the
+		 * Work out the width of this line. at is the point at which
-		 * first character, at is the point at which the available
+		 * the available width is hit, and width is the full line
-		 * width is hit, and width is the full line width.
+		 * width.
 		 */
-		first = at = width = 0;
+		at = width = 0;
 		if (~gl->flags & GRID_LINE_EXTENDED) {
-			first = 1;
 			width = gl->cellused;
 			if (width > sx)
 				at = sx;
@@ -1252,8 +1307,6 @@ grid_reflow(struct grid *gd, u_int sx)
 		} else {
 			for (i = 0; i < gl->cellused; i++) {
 				grid_get_cell1(gl, i, &gc);
-				if (i == 0)
-					first = gc.data.width;
 				if (at == 0 && width + gc.data.width > sx)
 					at = i;
 				width += gc.data.width;
@@ -1261,10 +1314,10 @@ grid_reflow(struct grid *gd, u_int sx)
 		}
 
 		/*
-		 * If the line is exactly right or the first character is wider
+		 * If the line is exactly right, just move it across
-		 * than the targe width, just move it across unchanged.
+		 * unchanged.
 		 */
-		if (width == sx || first > sx) {
+		if (width == sx) {
 			grid_reflow_move(target, gl);
 			continue;
 		}
@@ -1327,17 +1380,13 @@ grid_wrap_position(struct grid *gd, u_int px, u_int py, u_int *wx, u_int *wy)
 void
 grid_unwrap_position(struct grid *gd, u_int *px, u_int *py, u_int wx, u_int wy)
 {
-	u_int	yy, ax = 0, ay = 0;
+	u_int	yy, ay = 0;
 
 	for (yy = 0; yy < gd->hsize + gd->sy - 1; yy++) {
 		if (ay == wy)
 			break;
-		if (gd->linedata[yy].flags & GRID_LINE_WRAPPED)
+		if (~gd->linedata[yy].flags & GRID_LINE_WRAPPED)
-			ax += gd->linedata[yy].cellused;
-		else {
-			ax = 0;
 			ay++;
-		}
 	}
 
 	/*
@@ -1372,7 +1421,9 @@ grid_line_length(struct grid *gd, u_int py)
 		px = gd->sx;
 	while (px > 0) {
 		grid_get_cell(gd, px - 1, py, &gc);
-		if (gc.data.size != 1 || *gc.data.data != ' ')
+		if ((gc.flags & GRID_FLAG_PADDING) ||
+		    gc.data.size != 1 ||
+		    *gc.data.data != ' ')
 			break;
 		px--;
 	}