/* $OpenBSD$ */

/*

* Copyright (c) 2015 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 <fnmatch.h>

#include <limits.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "tmux.h"

static int cmd_find_session_better(struct session *, struct session *,

int);

static struct session *cmd_find_best_session(struct session **, u_int, int);

static int cmd_find_best_session_with_window(struct cmd_find_state *);

static int cmd_find_best_winlink_with_window(struct cmd_find_state *);

static const char *cmd_find_map_table(const char *[][2], const char *);

static void cmd_find_log_state(const char *, struct cmd_find_state *);

static int cmd_find_get_session(struct cmd_find_state *, const char *);

static int cmd_find_get_window(struct cmd_find_state *, const char *, int);

static int cmd_find_get_window_with_session(struct cmd_find_state *,

const char *);

static int cmd_find_get_pane(struct cmd_find_state *, const char *, int);

static int cmd_find_get_pane_with_session(struct cmd_find_state *,

const char *);

static int cmd_find_get_pane_with_window(struct cmd_find_state *,

const char *);

static const char *cmd_find_session_table[][2] = {

{ NULL, NULL }

};

static const char *cmd_find_window_table[][2] = {

{ "{start}", "^" },

{ "{last}", "!" },

{ "{end}", "$" },

{ "{next}", "+" },

{ "{previous}", "-" },

{ NULL, NULL }

};

static const char *cmd_find_pane_table[][2] = {

{ "{last}", "!" },

{ "{next}", "+" },

{ "{previous}", "-" },

{ "{top}", "top" },

{ "{bottom}", "bottom" },

{ "{left}", "left" },

{ "{right}", "right" },

{ "{top-left}", "top-left" },

{ "{top-right}", "top-right" },

{ "{bottom-left}", "bottom-left" },

{ "{bottom-right}", "bottom-right" },

{ "{up-of}", "{up-of}" },

{ "{down-of}", "{down-of}" },

{ "{left-of}", "{left-of}" },

{ "{right-of}", "{right-of}" },

{ NULL, NULL }

};

/* Find pane containing client if any. */

static struct window_pane *

cmd_find_inside_pane(struct client *c)

{

struct window_pane *wp;

struct environ_entry *envent;

if (c == NULL)

return (NULL);

RB_FOREACH(wp, window_pane_tree, &all_window_panes) {

if (wp->fd != -1 && strcmp(wp->tty, c->ttyname) == 0)

break;

}

if (wp == NULL) {

envent = environ_find(c->environ, "TMUX_PANE");

if (envent != NULL)

wp = window_pane_find_by_id_str(envent->value);

}

if (wp != NULL)

log_debug("%s: got pane %%%u (%s)", __func__, wp->id, wp->tty);

return (wp);

}

/* Is this client better? */

static int

cmd_find_client_better(struct client *c, struct client *than)

{

if (than == NULL)

return (1);

return (timercmp(&c->activity_time, &than->activity_time, >));

}

/* Find best client for session. */

struct client *

cmd_find_best_client(struct session *s)

{

struct client *c_loop, *c;

if (s->attached == 0)

s = NULL;

c = NULL;

TAILQ_FOREACH(c_loop, &clients, entry) {

if (c_loop->session == NULL)

continue;

if (s != NULL && c_loop->session != s)

continue;

if (cmd_find_client_better(c_loop, c))

c = c_loop;

}

return (c);

}

/* Is this session better? */

static int

cmd_find_session_better(struct session *s, struct session *than, int flags)

{

int attached;

if (than == NULL)

return (1);

if (flags & CMD_FIND_PREFER_UNATTACHED) {

attached = (than->attached != 0);

if (attached && s->attached == 0)

return (1);

else if (!attached && s->attached != 0)

return (0);

}

return (timercmp(&s->activity_time, &than->activity_time, >));

}

/* Find best session from a list, or all if list is NULL. */

static struct session *

cmd_find_best_session(struct session **slist, u_int ssize, int flags)

{

struct session *s_loop, *s;

u_int i;

log_debug("%s: %u sessions to try", __func__, ssize);

s = NULL;

if (slist != NULL) {

for (i = 0; i < ssize; i++) {

if (cmd_find_session_better(slist[i], s, flags))

s = slist[i];

}

} else {

RB_FOREACH(s_loop, sessions, &sessions) {

if (cmd_find_session_better(s_loop, s, flags))

s = s_loop;

}

}

return (s);

}

/* Find best session and winlink for window. */

static int

cmd_find_best_session_with_window(struct cmd_find_state *fs)

{

struct session **slist = NULL;

u_int ssize;

struct session *s;

log_debug("%s: window is @%u", __func__, fs->w->id);

ssize = 0;

RB_FOREACH(s, sessions, &sessions) {

if (!session_has(s, fs->w))

continue;

slist = xreallocarray(slist, ssize + 1, sizeof *slist);

slist[ssize++] = s;

}

if (ssize == 0)

goto fail;

fs->s = cmd_find_best_session(slist, ssize, fs->flags);

if (fs->s == NULL)

goto fail;

free(slist);

return (cmd_find_best_winlink_with_window(fs));

fail:

free(slist);

return (-1);

}

/*

* Find the best winlink for a window (the current if it contains the window,

* otherwise the first).

*/

static int

cmd_find_best_winlink_with_window(struct cmd_find_state *fs)

{

struct winlink *wl, *wl_loop;

log_debug("%s: window is @%u", __func__, fs->w->id);

wl = NULL;

if (fs->s->curw != NULL && fs->s->curw->window == fs->w)

wl = fs->s->curw;

else {

RB_FOREACH(wl_loop, winlinks, &fs->s->windows) {

if (wl_loop->window == fs->w) {

wl = wl_loop;

break;

}

}

}

if (wl == NULL)

return (-1);

fs->wl = wl;

fs->idx = fs->wl->idx;

return (0);

}

/* Maps string in table. */

static const char *

cmd_find_map_table(const char *table[][2], const char *s)

{

u_int i;

for (i = 0; table[i][0] != NULL; i++) {

if (strcmp(s, table[i][0]) == 0)

return (table[i][1]);

}

return (s);

}

/* Find session from string. Fills in s. */

static int

cmd_find_get_session(struct cmd_find_state *fs, const char *session)

{

struct session *s, *s_loop;

struct client *c;

log_debug("%s: %s", __func__, session);

/* Check for session ids starting with $. */

if (*session == '$') {

fs->s = session_find_by_id_str(session);

if (fs->s == NULL)

return (-1);

return (0);

}

/* Look for exactly this session. */

fs->s = session_find(session);

if (fs->s != NULL)

return (0);

/* Look for as a client. */

c = cmd_find_client(NULL, session, 1);

if (c != NULL && c->session != NULL) {

fs->s = c->session;

return (0);

}

/* Stop now if exact only. */

if (fs->flags & CMD_FIND_EXACT_SESSION)

return (-1);

/* Otherwise look for prefix. */

s = NULL;

RB_FOREACH(s_loop, sessions, &sessions) {

if (strncmp(session, s_loop->name, strlen(session)) == 0) {

if (s != NULL)

return (-1);

s = s_loop;

}

}

if (s != NULL) {

fs->s = s;

return (0);

}

/* Then as a pattern. */

s = NULL;

RB_FOREACH(s_loop, sessions, &sessions) {

if (fnmatch(session, s_loop->name, 0) == 0) {

if (s != NULL)

return (-1);

s = s_loop;

}

}

if (s != NULL) {

fs->s = s;

return (0);

}

return (-1);

}

/* Find window from string. Fills in s, wl, w. */

static int

cmd_find_get_window(struct cmd_find_state *fs, const char *window, int only)

{

log_debug("%s: %s", __func__, window);

/* Check for window ids starting with @. */

if (*window == '@') {

fs->w = window_find_by_id_str(window);

if (fs->w == NULL)

return (-1);

return (cmd_find_best_session_with_window(fs));

}

/* Not a window id, so use the current session. */

fs->s = fs->current->s;

/* We now only need to find the winlink in this session. */

if (cmd_find_get_window_with_session(fs, window) == 0)

return (0);

/* Otherwise try as a session itself. */

if (!only && cmd_find_get_session(fs, window) == 0) {

fs->wl = fs->s->curw;

fs->w = fs->wl->window;

if (~fs->flags & CMD_FIND_WINDOW_INDEX)

fs->idx = fs->wl->idx;

return (0);

}

return (-1);

}

/*

* Find window from string, assuming it is in given session. Needs s, fills in

* wl and w.

*/

static int

cmd_find_get_window_with_session(struct cmd_find_state *fs, const char *window)

{

struct winlink *wl;

const char *errstr;

int idx, n, exact;

struct session *s;

log_debug("%s: %s", __func__, window);

exact = (fs->flags & CMD_FIND_EXACT_WINDOW);

/*

* Start with the current window as the default. So if only an index is

* found, the window will be the current.

*/

fs->wl = fs->s->curw;

fs->w = fs->wl->window;

/* Check for window ids starting with @. */

if (*window == '@') {

fs->w = window_find_by_id_str(window);

if (fs->w == NULL || !session_has(fs->s, fs->w))

return (-1);

return (cmd_find_best_winlink_with_window(fs));

}

/* Try as an offset. */

if (!exact && (window[0] == '+' || window[0] == '-')) {

if (window[1] != '\0')

n = strtonum(window + 1, 1, INT_MAX, NULL);

else

n = 1;

s = fs->s;

if (fs->flags & CMD_FIND_WINDOW_INDEX) {

if (window[0] == '+') {

if (INT_MAX - s->curw->idx < n)

return (-1);

fs->idx = s->curw->idx + n;

} else {

if (n > s->curw->idx)

return (-1);

fs->idx = s->curw->idx - n;

}

return (0);

}

if (window[0] == '+')

fs->wl = winlink_next_by_number(s->curw, s, n);

else

fs->wl = winlink_previous_by_number(s->curw, s, n);

if (fs->wl != NULL) {

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

return (0);

}

}

/* Try special characters. */

if (!exact) {

if (strcmp(window, "!") == 0) {

fs->wl = TAILQ_FIRST(&fs->s->lastw);

if (fs->wl == NULL)

return (-1);

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

return (0);

} else if (strcmp(window, "^") == 0) {

fs->wl = RB_MIN(winlinks, &fs->s->windows);

if (fs->wl == NULL)

return (-1);

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

return (0);

} else if (strcmp(window, "$") == 0) {

fs->wl = RB_MAX(winlinks, &fs->s->windows);

if (fs->wl == NULL)

return (-1);

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

return (0);

}

}

/* First see if this is a valid window index in this session. */

if (window[0] != '+' && window[0] != '-') {

idx = strtonum(window, 0, INT_MAX, &errstr);

if (errstr == NULL) {

fs->wl = winlink_find_by_index(&fs->s->windows, idx);

if (fs->wl != NULL) {

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

return (0);

}

if (fs->flags & CMD_FIND_WINDOW_INDEX) {

fs->idx = idx;

return (0);

}

}

}

/* Look for exact matches, error if more than one. */

fs->wl = NULL;

RB_FOREACH(wl, winlinks, &fs->s->windows) {

if (strcmp(window, wl->window->name) == 0) {

if (fs->wl != NULL)

return (-1);

fs->wl = wl;

}

}

if (fs->wl != NULL) {

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

return (0);

}

/* Stop now if exact only. */

if (exact)

return (-1);

/* Try as the start of a window name, error if multiple. */

fs->wl = NULL;

RB_FOREACH(wl, winlinks, &fs->s->windows) {

if (strncmp(window, wl->window->name, strlen(window)) == 0) {

if (fs->wl != NULL)

return (-1);

fs->wl = wl;

}

}

if (fs->wl != NULL) {

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

return (0);

}

/* Now look for pattern matches, again error if multiple. */

fs->wl = NULL;

RB_FOREACH(wl, winlinks, &fs->s->windows) {

if (fnmatch(window, wl->window->name, 0) == 0) {

if (fs->wl != NULL)

return (-1);

fs->wl = wl;

}

}

if (fs->wl != NULL) {

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

return (0);

}

return (-1);

}

/* Find pane from string. Fills in s, wl, w, wp. */

static int

cmd_find_get_pane(struct cmd_find_state *fs, const char *pane, int only)

{

log_debug("%s: %s", __func__, pane);

/* Check for pane ids starting with %. */

if (*pane == '%') {

fs->wp = window_pane_find_by_id_str(pane);

if (fs->wp == NULL)

return (-1);

fs->w = fs->wp->window;

return (cmd_find_best_session_with_window(fs));

}

/* Not a pane id, so try the current session and window. */

fs->s = fs->current->s;

fs->wl = fs->current->wl;

fs->idx = fs->current->idx;

fs->w = fs->current->w;

/* We now only need to find the pane in this window. */

if (cmd_find_get_pane_with_window(fs, pane) == 0)

return (0);

/* Otherwise try as a window itself (this will also try as session). */

if (!only && cmd_find_get_window(fs, pane, 0) == 0) {

fs->wp = fs->w->active;

return (0);

}

return (-1);

}

/*

* Find pane from string, assuming it is in given session. Needs s, fills in wl

* and w and wp.

*/

static int

cmd_find_get_pane_with_session(struct cmd_find_state *fs, const char *pane)

{

log_debug("%s: %s", __func__, pane);

/* Check for pane ids starting with %. */

if (*pane == '%') {

fs->wp = window_pane_find_by_id_str(pane);

if (fs->wp == NULL)

return (-1);

fs->w = fs->wp->window;

return (cmd_find_best_winlink_with_window(fs));

}

/* Otherwise use the current window. */

fs->wl = fs->s->curw;

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

/* Now we just need to look up the pane. */

return (cmd_find_get_pane_with_window(fs, pane));

}

/*

* Find pane from string, assuming it is in the given window. Needs w, fills in

* wp.

*/

static int

cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)

{

const char *errstr;

int idx;

struct window_pane *wp;

u_int n;

log_debug("%s: %s", __func__, pane);

/* Check for pane ids starting with %. */

if (*pane == '%') {

fs->wp = window_pane_find_by_id_str(pane);

if (fs->wp == NULL)

return (-1);

if (fs->wp->window != fs->w)

return (-1);

return (0);

}

/* Try special characters. */

if (strcmp(pane, "!") == 0) {

fs->wp = TAILQ_FIRST(&fs->w->last_panes);

if (fs->wp == NULL)

return (-1);

return (0);

} else if (strcmp(pane, "{up-of}") == 0) {

fs->wp = window_pane_find_up(fs->w->active);

if (fs->wp == NULL)

return (-1);

return (0);

} else if (strcmp(pane, "{down-of}") == 0) {

fs->wp = window_pane_find_down(fs->w->active);

if (fs->wp == NULL)

return (-1);

return (0);

} else if (strcmp(pane, "{left-of}") == 0) {

fs->wp = window_pane_find_left(fs->w->active);

if (fs->wp == NULL)

return (-1);

return (0);

} else if (strcmp(pane, "{right-of}") == 0) {

fs->wp = window_pane_find_right(fs->w->active);

if (fs->wp == NULL)

return (-1);

return (0);

}

/* Try as an offset. */

if (pane[0] == '+' || pane[0] == '-') {

if (pane[1] != '\0')

n = strtonum(pane + 1, 1, INT_MAX, NULL);

else

n = 1;

wp = fs->w->active;

if (pane[0] == '+')

fs->wp = window_pane_next_by_number(fs->w, wp, n);

else

fs->wp = window_pane_previous_by_number(fs->w, wp, n);

if (fs->wp != NULL)

return (0);

}

/* Get pane by index. */

idx = strtonum(pane, 0, INT_MAX, &errstr);

if (errstr == NULL) {

fs->wp = window_pane_at_index(fs->w, idx);

if (fs->wp != NULL)

return (0);

}

/* Try as a description. */

fs->wp = window_find_string(fs->w, pane);

if (fs->wp != NULL)

return (0);

return (-1);

}

/* Clear state. */

void

cmd_find_clear_state(struct cmd_find_state *fs, int flags)

{

memset(fs, 0, sizeof *fs);

fs->flags = flags;

fs->idx = -1;

}

/* Check if state is empty. */

int

cmd_find_empty_state(struct cmd_find_state *fs)

{

if (fs->s == NULL && fs->wl == NULL && fs->w == NULL && fs->wp == NULL)

return (1);

return (0);

}

/* Check if a state if valid. */

int

cmd_find_valid_state(struct cmd_find_state *fs)

{

struct winlink *wl;

if (fs->s == NULL || fs->wl == NULL || fs->w == NULL || fs->wp == NULL)

return (0);

if (!session_alive(fs->s))

return (0);

RB_FOREACH(wl, winlinks, &fs->s->windows) {

if (wl->window == fs->w && wl == fs->wl)

break;

}

if (wl == NULL)

return (0);

if (fs->w != fs->wl->window)

return (0);

return (window_has_pane(fs->w, fs->wp));

}

/* Copy a state. */

void

cmd_find_copy_state(struct cmd_find_state *dst, struct cmd_find_state *src)

{

dst->s = src->s;

dst->wl = src->wl;

dst->idx = src->idx;

dst->w = src->w;

dst->wp = src->wp;

}

/* Log the result. */

static void

cmd_find_log_state(const char *prefix, struct cmd_find_state *fs)

{

if (fs->s != NULL)

log_debug("%s: s=$%u %s", prefix, fs->s->id, fs->s->name);

else

log_debug("%s: s=none", prefix);

if (fs->wl != NULL) {

log_debug("%s: wl=%u %d w=@%u %s", prefix, fs->wl->idx,

fs->wl->window == fs->w, fs->w->id, fs->w->name);

} else

log_debug("%s: wl=none", prefix);

if (fs->wp != NULL)

log_debug("%s: wp=%%%u", prefix, fs->wp->id);

else

log_debug("%s: wp=none", prefix);

if (fs->idx != -1)

log_debug("%s: idx=%d", prefix, fs->idx);

else

log_debug("%s: idx=none", prefix);

}

/* Find state from a session. */

void

cmd_find_from_session(struct cmd_find_state *fs, struct session *s, int flags)

{

cmd_find_clear_state(fs, flags);

fs->s = s;

fs->wl = fs->s->curw;

fs->w = fs->wl->window;

fs->wp = fs->w->active;

cmd_find_log_state(__func__, fs);

}

/* Find state from a winlink. */

void

cmd_find_from_winlink(struct cmd_find_state *fs, struct winlink *wl, int flags)

{

cmd_find_clear_state(fs, flags);

fs->s = wl->session;

fs->wl = wl;

fs->w = wl->window;

fs->wp = wl->window->active;

cmd_find_log_state(__func__, fs);

}

/* Find state from a session and window. */

int

cmd_find_from_session_window(struct cmd_find_state *fs, struct session *s,

struct window *w, int flags)

{

cmd_find_clear_state(fs, flags);

fs->s = s;

fs->w = w;

if (cmd_find_best_winlink_with_window(fs) != 0) {

cmd_find_clear_state(fs, flags);

return (-1);

}

fs->wp = fs->w->active;

cmd_find_log_state(__func__, fs);

return (0);

}

/* Find state from a window. */

int

cmd_find_from_window(struct cmd_find_state *fs, struct window *w, int flags)

{

cmd_find_clear_state(fs, flags);

fs->w = w;

if (cmd_find_best_session_with_window(fs) != 0) {

cmd_find_clear_state(fs, flags);

return (-1);

}

if (cmd_find_best_winlink_with_window(fs) != 0) {

cmd_find_clear_state(fs, flags);

return (-1);

}

fs->wp = fs->w->active;

cmd_find_log_state(__func__, fs);

return (0);

}

/* Find state from a winlink and pane. */

void

cmd_find_from_winlink_pane(struct cmd_find_state *fs, struct winlink *wl,

struct window_pane *wp, int flags)

{

cmd_find_clear_state(fs, flags);

fs->s = wl->session;

fs->wl = wl;

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

fs->wp = wp;

cmd_find_log_state(__func__, fs);

}

/* Find state from a pane. */

int

cmd_find_from_pane(struct cmd_find_state *fs, struct window_pane *wp, int flags)

{

if (cmd_find_from_window(fs, wp->window, flags) != 0)

return (-1);

fs->wp = wp;

cmd_find_log_state(__func__, fs);

return (0);

}

/* Find state from nothing. */

int

cmd_find_from_nothing(struct cmd_find_state *fs, int flags)

{

cmd_find_clear_state(fs, flags);

fs->s = cmd_find_best_session(NULL, 0, flags);

if (fs->s == NULL) {

cmd_find_clear_state(fs, flags);

return (-1);

}

fs->wl = fs->s->curw;

fs->idx = fs->wl->idx;

fs->w = fs->wl->window;

fs->wp = fs->w->active;

cmd_find_log_state(__func__, fs);

return (0);

}

/* Find state from mouse. */

int

cmd_find_from_mouse(struct cmd_find_state *fs, struct mouse_event *m, int flags)

{

cmd_find_clear_state(fs, flags);

if (!m->valid)

return (-1);

fs->wp = cmd_mouse_pane(m, &fs->s, &fs->wl);

if (fs->wp == NULL) {

cmd_find_clear_state(fs, flags);

return (-1);

}

fs->w = fs->wl->window;

cmd_find_log_state(__func__, fs);

return (0);

}

/* Find state from client. */

int

cmd_find_from_client(struct cmd_find_state *fs, struct client *c, int flags)

{

struct window_pane *wp;

/* If no client, treat as from nothing. */

if (c == NULL)

return (cmd_find_from_nothing(fs, flags));

/* If this is an attached client, all done. */

if (c->session != NULL) {

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);

/*

* If this is an unattached client running in a pane, we can use that

* to limit the list of sessions to those containing that pane.

*/

wp = cmd_find_inside_pane(c);

if (wp == NULL)

goto unknown_pane;

/*

* Don't have a session, or it doesn't have this pane. Try all

* sessions.

*/

fs->w = wp->window;

if (cmd_find_best_session_with_window(fs) != 0) {

/*

* The window may have been destroyed but the pane

* still on all_window_panes due to something else

* holding a reference.

*/

goto unknown_pane;

}

fs->wl = fs->s->curw;

fs->w = fs->wl->window;

fs->wp = fs->w->active; /* use active pane */

cmd_find_log_state(__func__, fs);

return (0);

unknown_pane:

/* We can't find the pane so need to guess. */

return (cmd_find_from_nothing(fs, flags));

}

/*

* Split target into pieces and resolve for the given type. Fills in the given

* state. Returns 0 on success or -1 on error.

*/

int

cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,

const char *target, enum cmd_find_type type, int flags)

{

struct mouse_event *m;

struct client *c;

struct cmd_find_state current;

char *colon, *period, *copy = NULL, tmp[256];

const char *session, *window, *pane, *s;

int window_only = 0, pane_only = 0;

/* Can fail flag implies quiet. */

if (flags & CMD_FIND_CANFAIL)

flags |= CMD_FIND_QUIET;

/* Log the arguments. */

if (type == CMD_FIND_PANE)

s = "pane";

else if (type == CMD_FIND_WINDOW)

s = "window";

else if (type == CMD_FIND_SESSION)

s = "session";

else

s = "unknown";

*tmp = '\0';

if (flags & CMD_FIND_PREFER_UNATTACHED)

strlcat(tmp, "PREFER_UNATTACHED,", sizeof tmp);

if (flags & CMD_FIND_QUIET)

strlcat(tmp, "QUIET,", sizeof tmp);

if (flags & CMD_FIND_WINDOW_INDEX)

strlcat(tmp, "WINDOW_INDEX,", sizeof tmp);

if (flags & CMD_FIND_DEFAULT_MARKED)

strlcat(tmp, "DEFAULT_MARKED,", sizeof tmp);

if (flags & CMD_FIND_EXACT_SESSION)

strlcat(tmp, "EXACT_SESSION,", sizeof tmp);

if (flags & CMD_FIND_EXACT_WINDOW)

strlcat(tmp, "EXACT_WINDOW,", sizeof tmp);

if (flags & CMD_FIND_CANFAIL)

strlcat(tmp, "CANFAIL,", sizeof tmp);

if (*tmp != '\0')

tmp[strlen(tmp) - 1] = '\0';

else

strlcat(tmp, "NONE", sizeof tmp);

log_debug("%s: target %s, type %s, item %p, flags %s", __func__,

target == NULL ? "none" : target, s, item, tmp);

/* Clear new state. */

cmd_find_clear_state(fs, flags);

/* Find current state. */

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(cmdq_get_current(item))) {

fs->current = cmdq_get_current(item);

log_debug("%s: current is from queue", __func__);

} 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 {

if (~flags & CMD_FIND_QUIET)

cmdq_error(item, "no current target");

goto error;

}

if (!cmd_find_valid_state(fs->current))

fatalx("invalid current find state");

/* An empty or NULL target is the current. */

if (target == NULL || *target == '\0')

goto current;

if (strcmp(target, "@") == 0 ||

strcmp(target, "{active}") == 0 ||

strcmp(target, "{current}") == 0) {

c = cmdq_get_client(item);

if (c == NULL) {

cmdq_error(item, "no current client");

goto error;