/* $OpenBSD$ */

/*

 * Copyright (c) 2009 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 <sys/uio.h>

#include <errno.h>

#include <fcntl.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#include "tmux.h"

enum mouse_where {

  NOWHERE,

  PANE,

  STATUS,

  STATUS_LEFT,

  STATUS_RIGHT,

  STATUS_DEFAULT,

  BORDER,

  SCROLLBAR_UP,

  SCROLLBAR_SLIDER,

  SCROLLBAR_DOWN

};

static void server_client_free(int, short, void *);

static void server_client_check_pane_resize(struct window_pane *);

static void server_client_check_pane_buffer(struct window_pane *);

static void server_client_check_window_resize(struct window *);

static key_code server_client_check_mouse(struct client *, struct key_event *);

static void server_client_repeat_timer(int, short, void *);

static void server_client_click_timer(int, short, void *);

static void server_client_check_exit(struct client *);

static void server_client_check_redraw(struct client *);

static void server_client_check_modes(struct client *);

static void server_client_set_title(struct client *);

static void server_client_set_path(struct client *);

static void server_client_reset_state(struct client *);

static void server_client_update_latest(struct client *);

static void server_client_dispatch(struct imsg *, void *);

static int  server_client_dispatch_command(struct client *, struct imsg *);

static int  server_client_dispatch_identify(struct client *, struct imsg *);

static int  server_client_dispatch_shell(struct client *);

static void server_client_report_theme(struct client *, enum client_theme);

/* Compare client windows. */

static int

server_client_window_cmp(struct client_window *cw1,

    struct client_window *cw2)

{

  if (cw1->window < cw2->window)

    return (-1);

  if (cw1->window > cw2->window)

    return (1);

  return (0);

}

RB_GENERATE(client_windows, client_window, entry, server_client_window_cmp);

Unexecuted instantiation: client_windows_RB_REMOVE_COLOR

Unexecuted instantiation: client_windows_RB_REMOVE

Unexecuted instantiation: client_windows_RB_INSERT

Unexecuted instantiation: client_windows_RB_FIND

Unexecuted instantiation: client_windows_RB_NFIND

Unexecuted instantiation: client_windows_RB_MINMAX

/* Number of attached clients. */

u_int

server_client_how_many(void)

{

  struct client *c;

  u_int    n;

  n = 0;

  TAILQ_FOREACH(c, &clients, entry) {

    if (c->session != NULL && (~c->flags & CLIENT_UNATTACHEDFLAGS))

      n++;

  }

  return (n);

}

/* Overlay timer callback. */

static void

server_client_overlay_timer(__unused int fd, __unused short events, void *data)

{

  server_client_clear_overlay(data);

}

/* Set an overlay on client. */

void

server_client_set_overlay(struct client *c, u_int delay,

    overlay_check_cb checkcb, overlay_mode_cb modecb,

    overlay_draw_cb drawcb, overlay_key_cb keycb, overlay_free_cb freecb,

    overlay_resize_cb resizecb, void *data)

{

  struct timeval  tv;

  if (c->overlay_draw != NULL)

    server_client_clear_overlay(c);

  tv.tv_sec = delay / 1000;

  tv.tv_usec = (delay % 1000) * 1000L;

  if (event_initialized(&c->overlay_timer))

    evtimer_del(&c->overlay_timer);

  evtimer_set(&c->overlay_timer, server_client_overlay_timer, c);

  if (delay != 0)

    evtimer_add(&c->overlay_timer, &tv);

  c->overlay_check = checkcb;

  c->overlay_mode = modecb;

  c->overlay_draw = drawcb;

  c->overlay_key = keycb;

  c->overlay_free = freecb;

  c->overlay_resize = resizecb;

  c->overlay_data = data;

  if (c->overlay_check == NULL)

    c->tty.flags |= TTY_FREEZE;

  if (c->overlay_mode == NULL)

    c->tty.flags |= TTY_NOCURSOR;

  window_update_focus(c->session->curw->window);

  server_redraw_client(c);

}

/* Clear overlay mode on client. */

void

server_client_clear_overlay(struct client *c)

{

  if (c->overlay_draw == NULL)

    return;

  if (event_initialized(&c->overlay_timer))

    evtimer_del(&c->overlay_timer);

  if (c->overlay_free != NULL)

    c->overlay_free(c, c->overlay_data);

  c->overlay_check = NULL;

  c->overlay_mode = NULL;

  c->overlay_draw = NULL;

  c->overlay_key = NULL;

  c->overlay_free = NULL;

  c->overlay_resize = NULL;

  c->overlay_data = NULL;

  c->tty.flags &= ~(TTY_FREEZE|TTY_NOCURSOR);

  if (c->session != NULL)

    window_update_focus(c->session->curw->window);

  server_redraw_client(c);

}

/*

 * Given overlay position and dimensions, return parts of the input range which

 * are visible.

 */

void

server_client_overlay_range(u_int x, u_int y, u_int sx, u_int sy, u_int px,

    u_int py, u_int nx, struct overlay_ranges *r)

{

  u_int ox, onx;

  /* Return up to 2 ranges. */

  r->px[2] = 0;

  r->nx[2] = 0;

  /* Trivial case of no overlap in the y direction. */

  if (py < y || py > y + sy - 1) {

    r->px[0] = px;

    r->nx[0] = nx;

    r->px[1] = 0;

    r->nx[1] = 0;

    return;

  }

  /* Visible bit to the left of the popup. */

  if (px < x) {

    r->px[0] = px;

    r->nx[0] = x - px;

    if (r->nx[0] > nx)

      r->nx[0] = nx;

  } else {

    r->px[0] = 0;

    r->nx[0] = 0;

  }

  /* Visible bit to the right of the popup. */

  ox = x + sx;

  if (px > ox)

    ox = px;

  onx = px + nx;

  if (onx > ox) {

    r->px[1] = ox;

    r->nx[1] = onx - ox;

  } else {

    r->px[1] = 0;

    r->nx[1] = 0;

  }

}

/* Check if this client is inside this server. */

int

server_client_check_nested(struct client *c)

{

  struct environ_entry  *envent;

  struct window_pane  *wp;

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

  if (envent == NULL || *envent->value == '\0')

    return (0);

  RB_FOREACH(wp, window_pane_tree, &all_window_panes) {

    if (strcmp(wp->tty, c->ttyname) == 0)

      return (1);

  }

  return (0);

}

/* Set client key table. */

void

server_client_set_key_table(struct client *c, const char *name)

{

  if (name == NULL)

    name = server_client_get_key_table(c);

  key_bindings_unref_table(c->keytable);

  c->keytable = key_bindings_get_table(name, 1);

  c->keytable->references++;

  if (gettimeofday(&c->keytable->activity_time, NULL) != 0)

    fatal("gettimeofday failed");

}

static uint64_t

server_client_key_table_activity_diff(struct client *c)

{

  struct timeval  diff;

  timersub(&c->activity_time, &c->keytable->activity_time, &diff);

  return ((diff.tv_sec * 1000ULL) + (diff.tv_usec / 1000ULL));

}

/* Get default key table. */

const char *

server_client_get_key_table(struct client *c)

{

  struct session  *s = c->session;

  const char  *name;

  if (s == NULL)

    return ("root");

  name = options_get_string(s->options, "key-table");

  if (*name == '\0')

    return ("root");

  return (name);

}

/* Is this table the default key table? */

static int

server_client_is_default_key_table(struct client *c, struct key_table *table)

{

  return (strcmp(table->name, server_client_get_key_table(c)) == 0);

}

/* Create a new client. */

struct client *

server_client_create(int fd)

{

  struct client *c;

  setblocking(fd, 0);

  c = xcalloc(1, sizeof *c);

  c->references = 1;

  c->peer = proc_add_peer(server_proc, fd, server_client_dispatch, c);

  if (gettimeofday(&c->creation_time, NULL) != 0)

    fatal("gettimeofday failed");

  memcpy(&c->activity_time, &c->creation_time, sizeof c->activity_time);

  c->environ = environ_create();

  c->fd = -1;

  c->out_fd = -1;

  c->queue = cmdq_new();

  RB_INIT(&c->windows);

  RB_INIT(&c->files);

  c->tty.sx = 80;

  c->tty.sy = 24;

  c->theme = THEME_UNKNOWN;

  status_init(c);

  c->flags |= CLIENT_FOCUSED;

  c->keytable = key_bindings_get_table("root", 1);

  c->keytable->references++;

  evtimer_set(&c->repeat_timer, server_client_repeat_timer, c);

  evtimer_set(&c->click_timer, server_client_click_timer, c);

  TAILQ_INSERT_TAIL(&clients, c, entry);

  log_debug("new client %p", c);

  return (c);

}

/* Open client terminal if needed. */

int

server_client_open(struct client *c, char **cause)

{

  const char  *ttynam = _PATH_TTY;

  if (c->flags & CLIENT_CONTROL)

    return (0);

  if (strcmp(c->ttyname, ttynam) == 0||

      ((isatty(STDIN_FILENO) &&

      (ttynam = ttyname(STDIN_FILENO)) != NULL &&

      strcmp(c->ttyname, ttynam) == 0) ||

      (isatty(STDOUT_FILENO) &&

      (ttynam = ttyname(STDOUT_FILENO)) != NULL &&

      strcmp(c->ttyname, ttynam) == 0) ||

      (isatty(STDERR_FILENO) &&

      (ttynam = ttyname(STDERR_FILENO)) != NULL &&

      strcmp(c->ttyname, ttynam) == 0))) {

    xasprintf(cause, "can't use %s", c->ttyname);

    return (-1);

  }

  if (!(c->flags & CLIENT_TERMINAL)) {

    *cause = xstrdup("not a terminal");

    return (-1);

  }

  if (tty_open(&c->tty, cause) != 0)

    return (-1);

  return (0);

}

/* Lost an attached client. */

static void

server_client_attached_lost(struct client *c)

{

  struct session  *s;

  struct window *w;

  struct client *loop;

  struct client *found;

  log_debug("lost attached client %p", c);

  /*

   * By this point the session in the client has been cleared so walk all

   * windows to find any with this client as the latest.

   */

  RB_FOREACH(w, windows, &windows) {

    if (w->latest != c)

      continue;

    found = NULL;

    TAILQ_FOREACH(loop, &clients, entry) {

      s = loop->session;

      if (loop == c || s == NULL || s->curw->window != w)

        continue;

      if (found == NULL || timercmp(&loop->activity_time,

          &found->activity_time, >))

        found = loop;

    }

    if (found != NULL)

      server_client_update_latest(found);

  }

}

/* Set client session. */

void

server_client_set_session(struct client *c, struct session *s)

{

  struct session  *old = c->session;

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

    c->last_session = c->session;

  else if (s == NULL)

    c->last_session = NULL;

  c->session = s;

  c->flags |= CLIENT_FOCUSED;

  if (old != NULL && old->curw != NULL)

    window_update_focus(old->curw->window);

  if (s != NULL) {

    recalculate_sizes();

    window_update_focus(s->curw->window);

    session_update_activity(s, NULL);

    session_theme_changed(s);

    gettimeofday(&s->last_attached_time, NULL);

    s->curw->flags &= ~WINLINK_ALERTFLAGS;

    s->curw->window->latest = c;

    alerts_check_session(s);

    tty_update_client_offset(c);

    status_timer_start(c);

    notify_client("client-session-changed", c);

    server_redraw_client(c);

  }

  server_check_unattached();

  server_update_socket();

}

/* Lost a client. */

void

server_client_lost(struct client *c)

{

  struct client_file  *cf, *cf1;

  struct client_window  *cw, *cw1;

  c->flags |= CLIENT_DEAD;

  server_client_clear_overlay(c);

  status_prompt_clear(c);

  status_message_clear(c);

  RB_FOREACH_SAFE(cf, client_files, &c->files, cf1) {

    cf->error = EINTR;

    file_fire_done(cf);

  }

  RB_FOREACH_SAFE(cw, client_windows, &c->windows, cw1) {

    RB_REMOVE(client_windows, &c->windows, cw);

    free(cw);

  }

  TAILQ_REMOVE(&clients, c, entry);

  log_debug("lost client %p", c);

  if (c->flags & CLIENT_ATTACHED) {

    server_client_attached_lost(c);

    notify_client("client-detached", c);

  }

  if (c->flags & CLIENT_CONTROL)

    control_stop(c);

  if (c->flags & CLIENT_TERMINAL)

    tty_free(&c->tty);

  free(c->ttyname);

  free(c->clipboard_panes);

  free(c->term_name);

  free(c->term_type);

  tty_term_free_list(c->term_caps, c->term_ncaps);

  status_free(c);

  free(c->title);

  free((void *)c->cwd);

  evtimer_del(&c->repeat_timer);

  evtimer_del(&c->click_timer);

  key_bindings_unref_table(c->keytable);

  free(c->message_string);

  if (event_initialized(&c->message_timer))

    evtimer_del(&c->message_timer);

  free(c->prompt_saved);

  free(c->prompt_string);

  free(c->prompt_buffer);

  format_lost_client(c);

  environ_free(c->environ);

  proc_remove_peer(c->peer);

  c->peer = NULL;

  if (c->out_fd != -1)

    close(c->out_fd);

  if (c->fd != -1) {

    close(c->fd);

    c->fd = -1;

  }

  server_client_unref(c);

  server_add_accept(0); /* may be more file descriptors now */

  recalculate_sizes();

  server_check_unattached();

  server_update_socket();

}

/* Remove reference from a client. */

void

server_client_unref(struct client *c)

{

  log_debug("unref client %p (%d references)", c, c->references);

  c->references--;

  if (c->references == 0)

    event_once(-1, EV_TIMEOUT, server_client_free, c, NULL);

}

/* Free dead client. */

static void

server_client_free(__unused int fd, __unused short events, void *arg)

{

  struct client *c = arg;

  log_debug("free client %p (%d references)", c, c->references);

  cmdq_free(c->queue);

  if (c->references == 0) {

    free((void *)c->name);

    free(c);

  }

}

/* Suspend a client. */

void

server_client_suspend(struct client *c)

{

  struct session  *s = c->session;

  if (s == NULL || (c->flags & CLIENT_UNATTACHEDFLAGS))

    return;

  tty_stop_tty(&c->tty);

  c->flags |= CLIENT_SUSPENDED;

  proc_send(c->peer, MSG_SUSPEND, -1, NULL, 0);

}

/* Detach a client. */

void

server_client_detach(struct client *c, enum msgtype msgtype)

{

  struct session  *s = c->session;

  if (s == NULL || (c->flags & CLIENT_NODETACHFLAGS))

    return;

  c->flags |= CLIENT_EXIT;

  c->exit_type = CLIENT_EXIT_DETACH;

  c->exit_msgtype = msgtype;

  c->exit_session = xstrdup(s->name);

}

/* Execute command to replace a client. */

void

server_client_exec(struct client *c, const char *cmd)

{

  struct session  *s = c->session;

  char    *msg;

  const char  *shell;

  size_t     cmdsize, shellsize;

  if (*cmd == '\0')

    return;

  cmdsize = strlen(cmd) + 1;

  if (s != NULL)

    shell = options_get_string(s->options, "default-shell");

  else

    shell = options_get_string(global_s_options, "default-shell");

  if (!checkshell(shell))

    shell = _PATH_BSHELL;

  shellsize = strlen(shell) + 1;

  msg = xmalloc(cmdsize + shellsize);

  memcpy(msg, cmd, cmdsize);

  memcpy(msg + cmdsize, shell, shellsize);

  proc_send(c->peer, MSG_EXEC, -1, msg, cmdsize + shellsize);

  free(msg);

}

static enum mouse_where

server_client_check_mouse_in_pane(struct window_pane *wp, u_int px, u_int py,

    u_int *sl_mpos)

{

  struct window   *w = wp->window;

  struct options    *wo = w->options;

  struct window_pane  *fwp;

  int      pane_status, sb, sb_pos, sb_w, sb_pad;

  u_int      line, sl_top, sl_bottom;

  sb = options_get_number(wo, "pane-scrollbars");

  sb_pos = options_get_number(wo, "pane-scrollbars-position");

  pane_status = options_get_number(wo, "pane-border-status");

  if (window_pane_show_scrollbar(wp, sb)) {

    sb_w = wp->scrollbar_style.width;

    sb_pad = wp->scrollbar_style.pad;

  } else {

    sb_w = 0;

    sb_pad = 0;

  }

  if (pane_status == PANE_STATUS_TOP)

    line = wp->yoff - 1;

  else if (pane_status == PANE_STATUS_BOTTOM)

    line = wp->yoff + wp->sy;

  /* Check if point is within the pane or scrollbar. */

  if (((pane_status != PANE_STATUS_OFF && py != line) ||

      (wp->yoff == 0 && py < wp->sy) ||

      (py >= wp->yoff && py < wp->yoff + wp->sy)) &&

      ((sb_pos == PANE_SCROLLBARS_RIGHT &&

      px < wp->xoff + wp->sx + sb_pad + sb_w) ||

      (sb_pos == PANE_SCROLLBARS_LEFT &&

      px < wp->xoff + wp->sx - sb_pad - sb_w))) {

    /* Check if in the scrollbar. */

    if ((sb_pos == PANE_SCROLLBARS_RIGHT &&

        (px >= wp->xoff + wp->sx + sb_pad &&

        px < wp->xoff + wp->sx + sb_pad + sb_w)) ||

        (sb_pos == PANE_SCROLLBARS_LEFT &&

        (px >= wp->xoff - sb_pad - sb_w &&

        px < wp->xoff - sb_pad))) {

      /* Check where inside the scrollbar. */

      sl_top = wp->yoff + wp->sb_slider_y;

      sl_bottom = (wp->yoff + wp->sb_slider_y +

          wp->sb_slider_h - 1);

      if (py < sl_top)

        return (SCROLLBAR_UP);

      else if (py >= sl_top &&

         py <= sl_bottom) {

        *sl_mpos = (py - wp->sb_slider_y - wp->yoff);

        return (SCROLLBAR_SLIDER);

      } else /* py > sl_bottom */

        return (SCROLLBAR_DOWN);

    } else {

      /* Must be inside the pane. */

      return (PANE);

    }

  } else if (~w->flags & WINDOW_ZOOMED) {

    /* Try the pane borders if not zoomed. */

    TAILQ_FOREACH(fwp, &w->panes, entry) {

      if ((((sb_pos == PANE_SCROLLBARS_RIGHT &&

          fwp->xoff + fwp->sx + sb_pad + sb_w == px) ||

          (sb_pos == PANE_SCROLLBARS_LEFT &&

          fwp->xoff + fwp->sx == px)) &&

          fwp->yoff <= 1 + py &&

          fwp->yoff + fwp->sy >= py) ||

          (fwp->yoff + fwp->sy == py &&

          fwp->xoff <= 1 + px &&

          fwp->xoff + fwp->sx >= px))

        break;

    }

    if (fwp != NULL)

      return (BORDER);

  }

  return (NOWHERE);

}

/* Check for mouse keys. */

static key_code

server_client_check_mouse(struct client *c, struct key_event *event)

{

  struct mouse_event  *m = &event->m;

  struct session    *s = c->session, *fs;

  struct window   *w = s->curw->window;

  struct winlink    *fwl;

  struct window_pane  *wp, *fwp;

  u_int      x, y, b, sx, sy, px, py, sl_mpos = 0;

  int      ignore = 0;

  key_code     key;

  struct timeval     tv;

  struct style_range  *sr;

  enum { NOTYPE,

         MOVE,

         DOWN,

         UP,

         DRAG,

         WHEEL,

         SECOND,

         DOUBLE,

         TRIPLE } type = NOTYPE;

  enum mouse_where where = NOWHERE;

  log_debug("%s mouse %02x at %u,%u (last %u,%u) (%d)", c->name, m->b,

      m->x, m->y, m->lx, m->ly, c->tty.mouse_drag_flag);

  /* What type of event is this? */

  if (event->key == KEYC_DOUBLECLICK) {

    type = DOUBLE;

    x = m->x, y = m->y, b = m->b;

    ignore = 1;

    log_debug("double-click at %u,%u", x, y);

  } else if ((m->sgr_type != ' ' &&

      MOUSE_DRAG(m->sgr_b) &&

      MOUSE_RELEASE(m->sgr_b)) ||

      (m->sgr_type == ' ' &&

      MOUSE_DRAG(m->b) &&

      MOUSE_RELEASE(m->b) &&

      MOUSE_RELEASE(m->lb))) {

    type = MOVE;

    x = m->x, y = m->y, b = 0;

    log_debug("move at %u,%u", x, y);

  } else if (MOUSE_DRAG(m->b)) {

    type = DRAG;

    if (c->tty.mouse_drag_flag) {

      x = m->x, y = m->y, b = m->b;

      if (x == m->lx && y == m->ly)

        return (KEYC_UNKNOWN);

      log_debug("drag update at %u,%u", x, y);

    } else {

      x = m->lx, y = m->ly, b = m->lb;

      log_debug("drag start at %u,%u", x, y);

    }

  } else if (MOUSE_WHEEL(m->b)) {

    type = WHEEL;

    x = m->x, y = m->y, b = m->b;

    log_debug("wheel at %u,%u", x, y);

  } else if (MOUSE_RELEASE(m->b)) {

    type = UP;

    x = m->x, y = m->y, b = m->lb;

    if (m->sgr_type == 'm')

      b = m->sgr_b;

    log_debug("up at %u,%u", x, y);

  } else {

    if (c->flags & CLIENT_DOUBLECLICK) {

      evtimer_del(&c->click_timer);

      c->flags &= ~CLIENT_DOUBLECLICK;

      if (m->b == c->click_button) {

        type = SECOND;

        x = m->x, y = m->y, b = m->b;

        log_debug("second-click at %u,%u", x, y);

        c->flags |= CLIENT_TRIPLECLICK;

      }

    } else if (c->flags & CLIENT_TRIPLECLICK) {

      evtimer_del(&c->click_timer);

      c->flags &= ~CLIENT_TRIPLECLICK;

      if (m->b == c->click_button) {

        type = TRIPLE;

        x = m->x, y = m->y, b = m->b;

        log_debug("triple-click at %u,%u", x, y);

        goto have_event;

      }

    }

    /* DOWN is the only remaining event type. */

    if (type == NOTYPE) {

      type = DOWN;

      x = m->x, y = m->y, b = m->b;

      log_debug("down at %u,%u", x, y);

      c->flags |= CLIENT_DOUBLECLICK;

    }

    if (KEYC_CLICK_TIMEOUT != 0) {

      memcpy(&c->click_event, m, sizeof c->click_event);

      c->click_button = m->b;

      log_debug("click timer started");

      tv.tv_sec = KEYC_CLICK_TIMEOUT / 1000;

      tv.tv_usec = (KEYC_CLICK_TIMEOUT % 1000) * 1000L;

      evtimer_del(&c->click_timer);

      evtimer_add(&c->click_timer, &tv);

    }

  }

have_event:

  if (type == NOTYPE)

    return (KEYC_UNKNOWN);

  /* Save the session. */

  m->s = s->id;

  m->w = -1;

  m->wp = -1;

  m->ignore = ignore;

  /* Is this on the status line? */

  m->statusat = status_at_line(c);

  m->statuslines = status_line_size(c);

  if (m->statusat != -1 &&

      y >= (u_int)m->statusat &&

      y < m->statusat + m->statuslines) {

    sr = status_get_range(c, x, y - m->statusat);

    if (sr == NULL) {

      where = STATUS_DEFAULT;

    } else {

      switch (sr->type) {

      case STYLE_RANGE_NONE:

        return (KEYC_UNKNOWN);

      case STYLE_RANGE_LEFT:

        log_debug("mouse range: left");

        where = STATUS_LEFT;

        break;

      case STYLE_RANGE_RIGHT:

        log_debug("mouse range: right");

        where = STATUS_RIGHT;

        break;

      case STYLE_RANGE_PANE:

        fwp = window_pane_find_by_id(sr->argument);

        if (fwp == NULL)

          return (KEYC_UNKNOWN);

        m->wp = sr->argument;

        log_debug("mouse range: pane %%%u", m->wp);

        where = STATUS;

        break;

      case STYLE_RANGE_WINDOW:

        fwl = winlink_find_by_index(&s->windows,

            sr->argument);

        if (fwl == NULL)

          return (KEYC_UNKNOWN);

        m->w = fwl->window->id;

        log_debug("mouse range: window @%u", m->w);

        where = STATUS;

        break;

      case STYLE_RANGE_SESSION:

        fs = session_find_by_id(sr->argument);

        if (fs == NULL)

          return (KEYC_UNKNOWN);

        m->s = sr->argument;

        log_debug("mouse range: session $%u", m->s);

        where = STATUS;

        break;

      case STYLE_RANGE_USER:

        where = STATUS;

        break;

      }

    }

  }

  /*

   * Not on status line. Adjust position and check for border, pane, or

   * scrollbar.

   */

  if (where == NOWHERE) {

    if (c->tty.mouse_scrolling_flag)

      where = SCROLLBAR_SLIDER;

    else {

      px = x;

      if (m->statusat == 0 && y >= m->statuslines)

        py = y - m->statuslines;

      else if (m->statusat > 0 && y >= (u_int)m->statusat)

        py = m->statusat - 1;

      else

        py = y;

      tty_window_offset(&c->tty, &m->ox, &m->oy, &sx, &sy);

      log_debug("mouse window @%u at %u,%u (%ux%u)",

          w->id, m->ox, m->oy, sx, sy);

      if (px > sx || py > sy)

        return (KEYC_UNKNOWN);

      px = px + m->ox;

      py = py + m->oy;

      /* Try inside the pane. */

      wp = window_get_active_at(w, px, py);

      if (wp == NULL)

        return (KEYC_UNKNOWN);

      where = server_client_check_mouse_in_pane(wp, px, py,

          &sl_mpos);