tmux/window.c

332 lines
7.2 KiB
C
Raw Normal View History

2007-10-04 20:33:16 +00:00
/* $Id: window.c,v 1.19 2007-10-04 20:33:16 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
*
* 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 <paths.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <util.h>
#include "tmux.h"
/*
* Each window is attached to a pty. This file contains code to handle them.
*
* A window has two buffers attached, these are filled and emptied by the main
2007-08-27 10:08:44 +00:00
* server poll loop. Output data is received from pty's in screen format,
* translated and returned as a series of escape sequences and strings.
* Input data is received in screen format and written directly to the pty
* (translation is done in the client).
*
* Each window also has a "virtual" screen (screen.c) which contains the
* current state and is redisplayed when the window is reattached to a client.
*
* A global list of windows is maintained, and a window may also be a member
* of any number of sessions. A reference count is maintained and a window
* removed from the global list and destroyed when it reaches zero.
*/
/* Global window list. */
struct windows windows;
/* Create a new window. */
struct window *
2007-10-03 23:32:26 +00:00
window_create(
const char *name, const char *cmd, const char **environ, u_int sx, u_int sy)
{
struct window *w;
struct winsize ws;
struct termios tio;
int fd, mode;
2007-10-03 23:32:26 +00:00
char *ptr, *copy;
const char **entry;
memset(&ws, 0, sizeof ws);
ws.ws_col = sx;
ws.ws_row = sy;
memset(&tio, 0, sizeof tio);
tio.c_iflag = TTYDEF_IFLAG;
tio.c_oflag = TTYDEF_OFLAG;
tio.c_lflag = TTYDEF_LFLAG;
tio.c_cflag = TTYDEF_CFLAG;
memcpy(&tio.c_cc, ttydefchars, sizeof tio.c_cc);
cfsetspeed(&tio, TTYDEF_SPEED);
switch (forkpty(&fd, NULL, &tio, &ws)) {
case -1:
return (NULL);
case 0:
for (entry = environ; *entry != NULL; entry++) {
if (putenv(*entry) != 0)
fatal("putenv failed");
}
sigreset();
log_close();
execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL);
2007-07-25 23:13:18 +00:00
fatal("execl failed");
}
if ((mode = fcntl(fd, F_GETFL)) == -1)
2007-07-25 23:13:18 +00:00
fatal("fcntl failed");
if (fcntl(fd, F_SETFL, mode|O_NONBLOCK) == -1)
2007-07-25 23:13:18 +00:00
fatal("fcntl failed");
mode = 1;
if (ioctl(fd, TIOCPKT, &mode) == -1)
2007-07-25 23:13:18 +00:00
fatal("ioctl failed");
w = xmalloc(sizeof *w);
w->fd = fd;
w->in = buffer_create(BUFSIZ);
w->out = buffer_create(BUFSIZ);
screen_create(&w->screen, sx, sy);
2007-09-28 22:47:22 +00:00
input_init(&w->ictx, &w->screen);
2007-10-03 23:32:26 +00:00
if (name == NULL) {
/* XXX */
if (strncmp(cmd, "exec ", (sizeof "exec ") - 1) == 0)
2007-10-04 20:33:16 +00:00
copy = xstrdup(cmd + (sizeof "exec ") - 1);
2007-10-03 23:32:26 +00:00
else
copy = xstrdup(cmd);
if ((ptr = strchr(copy, ' ')) != NULL) {
if (ptr != copy && ptr[-1] != '\\')
*ptr = '\0';
else {
while ((ptr = strchr(ptr + 1, ' ')) != NULL) {
if (ptr[-1] != '\\') {
*ptr = '\0';
break;
}
}
}
}
2007-10-03 23:32:26 +00:00
w->name = xstrdup(xbasename(copy));
xfree(copy);
} else
w->name = xstrdup(name);
window_add(&windows, w);
w->references = 1;
return (w);
}
/* Find window index in list. */
int
window_index(struct windows *ww, struct window *w, u_int *i)
{
for (*i = 0; *i < ARRAY_LENGTH(ww); (*i)++) {
if (w == ARRAY_ITEM(ww, *i))
return (0);
}
return (-1);
}
/* Add a window to a list. */
void
window_add(struct windows *ww, struct window *w)
{
u_int i;
if (window_index(ww, NULL, &i) != 0)
ARRAY_ADD(ww, w);
else
ARRAY_SET(ww, i, w);
w->references++;
}
/* Remove a window from a list. */
void
window_remove(struct windows *ww, struct window *w)
{
u_int i;
if (window_index(ww, w, &i) != 0)
2007-07-25 23:13:18 +00:00
fatalx("window not found");
2007-09-21 20:45:06 +00:00
ARRAY_SET(ww, i, NULL);
while (!ARRAY_EMPTY(ww) && ARRAY_LAST(ww) == NULL)
ARRAY_TRUNC(ww, 1);
w->references--;
if (w->references == 0)
2007-08-27 11:41:00 +00:00
window_destroy(w);
2007-09-21 18:20:44 +00:00
if (w->references == 1)
window_remove(&windows, w);
}
/* Destroy a window. */
void
window_destroy(struct window *w)
{
close(w->fd);
2007-09-28 22:47:22 +00:00
input_free(&w->ictx);
2007-10-01 14:15:48 +00:00
screen_destroy(&w->screen);
buffer_destroy(w->in);
buffer_destroy(w->out);
2007-10-03 23:32:26 +00:00
xfree(w->name);
xfree(w);
}
/* Locate next window in list. */
struct window *
window_next(struct windows *ww, struct window *w)
{
u_int i;
if (window_index(ww, w, &i) != 0)
2007-07-25 23:13:18 +00:00
fatalx("window not found");
if (i == ARRAY_LENGTH(ww) - 1)
return (NULL);
do {
i++;
w = window_at(ww, i);
if (w != NULL)
return (w);
} while (i != ARRAY_LENGTH(ww) - 1);
return (NULL);
}
/* Locate previous window in list. */
struct window *
window_previous(struct windows *ww, struct window *w)
{
u_int i;
if (window_index(ww, w, &i) != 0)
2007-07-25 23:13:18 +00:00
fatalx("window not found");
if (i == 0)
return (NULL);
do {
i--;
w = window_at(ww, i);
if (w != NULL)
return (w);
} while (i != 0);
return (NULL);
}
/* Locate window at specific position in list. */
struct window *
window_at(struct windows *ww, u_int i)
{
if (i >= ARRAY_LENGTH(ww))
return (NULL);
return (ARRAY_ITEM(ww, i));
}
/* Resize a window. */
int
window_resize(struct window *w, u_int sx, u_int sy)
{
struct winsize ws;
if (sx == w->screen.sx && sy == w->screen.sy)
return (-1);
memset(&ws, 0, sizeof ws);
ws.ws_col = sx;
ws.ws_row = sy;
screen_resize(&w->screen, sx, sy);
if (ioctl(w->fd, TIOCSWINSZ, &ws) == -1)
2007-07-25 23:13:18 +00:00
fatal("ioctl failed");
return (0);
}
/* Handle window poll results. This is special because of TIOCPKT. */
int
window_poll(struct window *w, struct pollfd *pfd)
{
struct termios tio;
size_t size;
u_char *ptr;
size = BUFFER_USED(w->in);
if (buffer_poll(pfd, w->in, w->out) != 0)
return (-1);
if (BUFFER_USED(w->in) == size)
return (0);
ptr = BUFFER_IN(w->in) - (BUFFER_USED(w->in) - size);
log_debug("window packet: %hhu", *ptr);
switch (*ptr) {
case TIOCPKT_DATA:
case TIOCPKT_FLUSHREAD:
case TIOCPKT_FLUSHWRITE:
case TIOCPKT_STOP:
case TIOCPKT_START:
case TIOCPKT_DOSTOP:
case TIOCPKT_NOSTOP:
buffer_delete_range(w->in, size, 1);
break;
case TIOCPKT_IOCTL:
buffer_delete_range(w->in, size, 1 + sizeof tio);
break;
}
return (0);
}
/* Process window key. */
void
window_key(struct window *w, int key)
{
input_translate_key(w->out, key);
}
/*
2007-08-27 10:08:44 +00:00
* Process window output. Output is translated into a series of escape
* sequences and strings and returned.
*/
void
window_data(struct window *w, struct buffer *b)
{
FILE *f;
2007-09-29 09:15:49 +00:00
if (BUFFER_USED(w->in) == 0)
return;
if (debug_level > 2) {
f = fopen("tmux-in.log", "a+");
fwrite(BUFFER_OUT(w->in), BUFFER_USED(w->in), 1, f);
fclose(f);
}
2007-09-29 09:15:49 +00:00
input_parse(&w->ictx, BUFFER_OUT(w->in), BUFFER_USED(w->in), b);
buffer_remove(w->in, BUFFER_USED(w->in));
if (INPUT_FLAGS(&w->ictx) & INPUT_BELL)
w->flags |= WINDOW_BELL;
}