nortti
/
sortix-mirror
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
sortix-mirror/terminal/terminal.c

1293 lines
29 KiB
C
Raw Blame History

/*
* Copyright (c) 2017, 2022 Jonas 'Sortie' Termansen.
*
* 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 OF7
* 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 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.
*
* terminal.c
* Terminal emulator.
*/
#include <sys/ioctl.h>
#include <sys/keycodes.h>
#include <sys/wait.h>
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <limits.h>
#include <poll.h>
#include <pthread.h>
#include <pty.h>
#include <pwd.h>
#include <signal.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <wchar.h>
#if !defined(TTY_NAME_MAX)
#include <sortix/limits.h>
#endif
#include <display.h>
#include <framebuffer.h>
#include <pixel.h>
#include <vgafont.h>
#include "palette.h"
struct kbkey_sequence
{
const char* sequence;
int kbkey;
int flags;
};
#define MODIFIER_ALT (1 << 0)
#define MODIFIER_LSHIFT (1 << 1)
#define MODIFIER_RSHIFT (1 << 2)
#define MODIFIER_LCONTROL (1 << 3)
#define MODIFIER_RCONTROL (1 << 4)
#define SEQUENCE_1IFMOD (1 << 0)
#define SEQUENCE_OSHORT (1 << 1)
static const struct kbkey_sequence kbkey_sequences[] =
{
{ "\e[A", KBKEY_UP, SEQUENCE_1IFMOD },
{ "\e[B", KBKEY_DOWN, SEQUENCE_1IFMOD},
{ "\e[C", KBKEY_RIGHT, SEQUENCE_1IFMOD },
{ "\e[D", KBKEY_LEFT, SEQUENCE_1IFMOD },
{ "\e[F", KBKEY_END, SEQUENCE_1IFMOD },
{ "\e[H", KBKEY_HOME, SEQUENCE_1IFMOD },
{ "\e[2~", KBKEY_INSERT, 0 },
{ "\e[3~", KBKEY_DELETE, 0 },
{ "\e[5~", KBKEY_PGUP, 0 },
{ "\e[6~", KBKEY_PGDOWN, 0 },
{ "\e[1P", KBKEY_F1, SEQUENCE_OSHORT },
{ "\e[1Q", KBKEY_F2, SEQUENCE_OSHORT },
{ "\e[1R", KBKEY_F3, SEQUENCE_OSHORT },
{ "\e[1S", KBKEY_F4, SEQUENCE_OSHORT },
{ "\e[15~", KBKEY_F5, 0 },
{ "\e[17~", KBKEY_F6, 0 },
{ "\e[18~", KBKEY_F7, 0 },
{ "\e[19~", KBKEY_F8, 0 },
{ "\e[20~", KBKEY_F9, 0 },
{ "\e[21~", KBKEY_F10, 0 },
{ "\e[23~", KBKEY_F11, 0 },
{ "\e[24~", KBKEY_F12, 0 },
};
static inline const struct kbkey_sequence* lookup_keystroke_sequence(int kbkey)
{
size_t count = sizeof(kbkey_sequences) / sizeof(kbkey_sequences[0]);
for ( size_t i = 0; i < count; i++ )
if ( kbkey_sequences[i].kbkey == kbkey )
return &kbkey_sequences[i];
return NULL;
}
static uint32_t WINDOW_ID = 0;
static uint32_t WINDOW_WIDTH = 0;
static uint32_t WINDOW_HEIGHT = 0;
static bool need_redraw = true;
static bool need_show = true;
static bool need_exit = false;
static bool redraw_pipe_written = false;
static int redraw_pipe[2];
struct entry
{
uint32_t attr;
uint32_t fgcolor;
uint32_t bgcolor;
wchar_t wc;
};
#define ATTR_INVERSE (1 << 0)
#define ATTR_BOLD (1 << 1)
#define ATTR_UNDERLINE (1 << 2)
static struct entry* scrollback;
static size_t column = 0;
static size_t row = 0;
static size_t columns = 0;
static size_t rows = 0;
static int modifiers = 0;
static mbstate_t in_ps;
static mbstate_t out_ps;
static uint32_t default_fgcolor;
static uint32_t default_bgcolor;
static uint32_t current_fgcolor;
static uint32_t current_bgcolor;
static uint32_t attr;
static uint32_t next_attr;
static unsigned ansisavedposx;
static unsigned ansisavedposy;
static enum { NONE = 0, CSI, CHARSET, COMMAND, GREATERTHAN, } ansimode;
#define ANSI_NUM_PARAMS 16
static unsigned ansiusedparams;
static unsigned ansiparams[ANSI_NUM_PARAMS];
static bool ignore_sequence;
static bool draw_cursor = true;
static void scrollback_resize(size_t new_rows, size_t new_columns)
{
// TODO: Recover gracefully if the scrollback fails.
// TODO: Overflow.
struct entry* new_scrollback =
calloc(sizeof(struct entry), new_rows * new_columns);
if ( !new_scrollback )
err(1, "malloc");
size_t src_y_after_cursor = rows ? row + 1 : 0;
size_t src_y_count =
new_rows < src_y_after_cursor ? new_rows : src_y_after_cursor;
size_t src_y_from = src_y_after_cursor - src_y_count;
size_t new_row = row;
size_t new_column = column;
new_row += src_y_from;
for ( size_t dst_y = 0; dst_y < new_rows; dst_y++ )
{
size_t src_y = src_y_from + dst_y;
for ( size_t dst_x = 0; dst_x < new_columns; dst_x++ )
{
size_t src_x = dst_x;
struct entry tc;
if ( src_x < columns && src_y < rows )
tc = scrollback[src_y * columns + src_x];
else if ( columns && rows )
{
size_t templ_x = src_y < columns ? src_y : src_x - 1;
size_t templ_y = src_y < rows ? src_y : rows - 1;
tc = scrollback[templ_y * columns + templ_x];
tc.wc = 0;
tc.attr = 0;
}
else
tc = (struct entry) { 0 };
new_scrollback[dst_y * new_columns + dst_x] = tc;
if ( src_x == column && src_y == row )
{
new_row = dst_y;
new_column = dst_x;
}
}
}
if ( new_columns <= new_column )
new_column = new_columns ? new_column - 1 : 0;
if ( new_rows <= new_row )
new_row = new_rows ? new_row - 1 : 0;
free(scrollback);
scrollback = new_scrollback;
rows = new_rows;
columns = new_columns;
row = new_row;
column = new_column;
}
static void fill(size_t from_x, size_t from_y, size_t to_x, size_t to_y,
struct entry with)
{
// TODO: Assert within bounds?
size_t from = from_y * columns + from_x;
size_t to = to_y * columns + to_x;
for ( size_t i = from; i <= to; i++ )
scrollback[i] = with;
}
static void scroll(ssize_t offsigned, struct entry with)
{
if ( 0 < offsigned )
{
size_t off = offsigned;
if ( rows < off )
off = rows;
size_t dist = off * columns;
size_t end = rows * columns - dist;
for ( size_t i = 0; i < end; i++ )
scrollback[i] = scrollback[i + dist];
for ( size_t i = end; i < end + dist; i++ )
scrollback[i] = with;
}
else if ( offsigned < 0 )
{
size_t off = -offsigned; // TODO: Negation overflow.
if ( rows < off )
off = rows;
size_t dist = off * columns;
size_t end = rows * columns;
for ( size_t i = end-1; dist <= i; i-- )
scrollback[i] = scrollback[i - dist];
for ( size_t i = 0; i < dist; i++ )
scrollback[i] = with;
}
}
static void newline(void)
{
if ( row + 1 < rows )
{
row++;
return;
}
struct entry entry;
entry.attr = 0;
entry.fgcolor = current_fgcolor;
entry.bgcolor = current_bgcolor;
entry.wc = 0;
scroll(1, entry);
}
static void run_ansi_command(char c)
{
switch ( c )
{
case 'A': // Cursor up
{
unsigned dist = 0 < ansiusedparams ? ansiparams[0] : 1;
if ( row < dist )
row = 0;
else
row -= dist;
} break;
case 'B': // Cursor down
{
unsigned dist = 0 < ansiusedparams ? ansiparams[0] : 1;
if ( rows <= row + dist )
row = rows-1;
else
row += dist;
} break;
case 'C': // Cursor forward
{
unsigned dist = 0 < ansiusedparams ? ansiparams[0] : 1;
if ( columns <= column + dist )
column = columns-1;
else
column += dist;
} break;
case 'D': // Cursor backward
{
unsigned dist = 0 < ansiusedparams ? ansiparams[0] : 1;
if ( column < dist )
column = 0;
else
column -= dist;
} break;
case 'E': // Move to beginning of line N lines down.
{
column = 0;
unsigned dist = 0 < ansiusedparams ? ansiparams[0] : 1;
if ( rows <= row + dist )
row = rows-1;
else
row += dist;
} break;
case 'F': // Move to beginning of line N lines up.
{
column = 0;
unsigned dist = 0 < ansiusedparams ? ansiparams[0] : 1;
if ( row < dist )
row = 0;
else
row -= dist;
} break;
case 'G': // Move the cursor to column N.
{
unsigned pos = 0 < ansiusedparams ? ansiparams[0]-1 : 0;
if ( columns <= pos )
pos = columns-1;
column = pos;
} break;
case 'H': // Move the cursor to line Y, column X.
case 'f':
{
unsigned posy = 0 < ansiusedparams ? ansiparams[0]-1 : 0;
unsigned posx = 1 < ansiusedparams ? ansiparams[1]-1 : 0;
if ( columns <= posx )
posx = columns-1;
if ( rows <= posy )
posy = rows-1;
column = posx;
row = posy;
} break;
case 'J': // Erase parts of the screen.
{
unsigned mode = 0 < ansiusedparams ? ansiparams[0] : 0;
size_t from_x = 0, from_y = 0;
size_t to_x = 0, to_y = 0;
if ( mode == 0 ) // From cursor to end.
{
from_x = column;
from_y = row;
// TODO: Ensure the number of rows and columns are always non-zero.
to_x = columns - 1;
to_y = rows - 1;
}
if ( mode == 1 ) // From start to cursor.
{
from_x = 0;
from_y = 0;
to_x = columns - 1;
to_y = rows - 1;
}
if ( mode == 2 ) // Everything.
{
from_x = 0;
from_y = 0;
to_x = columns - 1;
to_y = rows - 1;
}
struct entry with;
with.attr = 0;
with.fgcolor = attr & ATTR_INVERSE ? current_bgcolor : current_fgcolor;
with.bgcolor = attr & ATTR_INVERSE ? current_fgcolor : current_bgcolor;
with.wc = 0;
fill(from_x, from_y, to_x, to_y, with);
} break;
case 'K': // Erase parts of the current line.
{
unsigned mode = 0 < ansiusedparams ? ansiparams[0] : 0;
size_t from_x = 0, from_y = row;
size_t to_x = 0, to_y = row;
if ( mode == 0 ) // From cursor to end.
{
from_x = column;
to_x = columns - 1;
}
if ( mode == 1 ) // From start to cursor.
{
from_x = 0;
to_x = column;
}
if ( mode == 2 ) // Everything.
{
from_x = 0;
to_x = columns - 1;
}
struct entry with;
with.attr = 0;
with.fgcolor = attr & ATTR_INVERSE ? current_bgcolor : current_fgcolor;
with.bgcolor = attr & ATTR_INVERSE ? current_fgcolor : current_bgcolor;
with.wc = 0;
fill(from_x, from_y, to_x, to_y, with);
} break;
// TODO: CSI Ps M Delete Ps Line(s) (default = 1) (DL).
// (delete those lines and move the rest of the lines upwards).
// TODO: CSI Ps P Delete Ps Character(s) (default = 1) (DCH).
// (delete those characters and move the rest of the line leftward).
case 'S': // Scroll a line up and place a new line at the buttom.
{
struct entry with;
with.attr = 0;
with.fgcolor = attr & ATTR_INVERSE ? current_bgcolor : current_fgcolor;
with.bgcolor = attr & ATTR_INVERSE ? current_fgcolor : current_bgcolor;
with.wc = 0;
scroll(1, with);
row = rows - 1;
} break;
case 'T': // Scroll a line up and place a new line at the top.
{
struct entry with;
with.attr = 0;
with.fgcolor = attr & ATTR_INVERSE ? current_bgcolor : current_fgcolor;
with.bgcolor = attr & ATTR_INVERSE ? current_fgcolor : current_bgcolor;
with.wc = 0;
scroll(-1, with);
row = 0;
} break;
case 'd': // Move the cursor to line N.
{
unsigned posy = 0 < ansiusedparams ? ansiparams[0]-1 : 0;
if ( rows <= posy )
posy = rows-1;
row = posy;
} break;
case 'm': // Change how the text is rendered.
{
if ( ansiusedparams == 0 )
{
ansiparams[0] = 0;
ansiusedparams++;
}
for ( size_t i = 0; i < ansiusedparams; i++ )
{
unsigned cmd = ansiparams[i];
// Turn all attributes off.
if ( cmd == 0 )
{
attr = 0;
current_fgcolor = default_fgcolor;
current_bgcolor = default_bgcolor;
}
// Boldness.
else if ( cmd == 1 )
attr |= ATTR_BOLD;
// TODO: 2, Faint
// TODO: 3, Italicized
// Underline.
else if ( cmd == 4 )
attr |= ATTR_UNDERLINE;
// TODO: 5, Blink (appears as Bold)
// Inverse.
else if ( cmd == 7 )
attr |= ATTR_INVERSE;
// TODO: 8, Invisible
// TODO: 9, Crossed-out
// TODO: 21, Doubly-underlined
// Normal (neither bold nor faint).
else if ( cmd == 22 )
attr &= ~ATTR_BOLD;
// TODO: 23, Not italicized
// Not underlined.
else if ( cmd == 24 )
attr &= ~ATTR_UNDERLINE;
// TODO: 25, Steady (not blinking)
// Positive (not inverse).
else if ( cmd == 27 )
attr &= ~ATTR_INVERSE;
// TODO: 28, Visible (not hidden)
// Set text color.
else if ( 30 <= cmd && cmd <= 37 )
{
unsigned val = cmd - 30;
current_fgcolor = palette[val] | 0xFF000000;
}
// Set text color.
else if ( cmd == 38 )
{
if ( 5 <= ansiusedparams - i && ansiparams[i+1] == 2 )
{
uint8_t r = ansiparams[i+2];
uint8_t g = ansiparams[i+3];
uint8_t b = ansiparams[i+4];
i += 5 - 1;
current_fgcolor = make_color(r, g, b);
}
else if ( 3 <= ansiusedparams - i && ansiparams[i+1] == 5 )
{
uint8_t index = ansiparams[i+2];
i += 3 - 1;
current_fgcolor = palette[index] | 0xFF000000;
}
}
// Set default text color.
else if ( cmd == 39 )
{
current_fgcolor = default_fgcolor;
}
// Set background color.
else if ( 40 <= cmd && cmd <= 47 )
{
unsigned val = cmd - 40;
current_bgcolor = palette[val] | 0xFF000000;
}
// Set background color.
else if ( cmd == 48 )
{
if ( 5 <= ansiusedparams - i && ansiparams[i+1] == 2 )
{
uint8_t r = ansiparams[i+2];
uint8_t g = ansiparams[i+3];
uint8_t b = ansiparams[i+4];
i += 5 - 1;
current_bgcolor = make_color(r, g, b);
}
else if ( 3 <= ansiusedparams - i && ansiparams[i+1] == 5 )
{
uint8_t index = ansiparams[i+2];
i += 3 - 1;
current_bgcolor = palette[index] | 0xFF000000;
}
}
// Set default background color.
else if ( cmd == 49 )
{
current_bgcolor = default_bgcolor;
}
// Set text color.
else if ( 90 <= cmd && cmd <= 97 )
{
unsigned val = cmd - 90 + 8;
current_fgcolor = palette[val] | 0xFF000000;
}
// Set background color.
else if ( 100 <= cmd && cmd <= 107 )
{
unsigned val = cmd - 100 + 8;
current_bgcolor = palette[val] | 0xFF000000;
}
else
{
ansimode = NONE;
}
}
} break;
case 'n': // Request special information from terminal.
{
ansimode = NONE;
// TODO: Handle this code.
} break;
case 's': // Save cursor position.
{
ansisavedposx = column;
ansisavedposy = row;
} break;
case 'u': // Restore cursor position.
{
column = ansisavedposx;
row = ansisavedposy;
if ( columns <= column )
column = columns-1;
if ( rows <= row )
row = rows-1;
} break;
case 'l': // Hide cursor.
{
// TODO: This is somehow related to the special char '?'.
if ( 0 < ansiusedparams && ansiparams[0] == 25 )
draw_cursor = false;
if ( 0 < ansiusedparams && ansiparams[0] == 1049 )
{}; // TODO: Save scrollback.
} break;
case 'h': // Show cursor.
{
// TODO: This is somehow related to the special char '?'.
if ( 0 < ansiusedparams && ansiparams[0] == 25 )
draw_cursor = true;
if ( 0 < ansiusedparams && ansiparams[0] == 1049 )
{}; // TODO: Restore scrollback.
} break;
default:
{
ansimode = NONE;
}
// TODO: Handle other cases.
}
ansimode = NONE;
}
static void put_ansi_escaped(char c)
{
// Check the proper prefixes are used.
if ( ansimode == CSI )
{
if ( c == '[' )
ansimode = COMMAND;
else if ( c == '(' || c == ')' || c == '*' || c == '+' ||
c == '-' || c == '.' || c == '/' )
ansimode = CHARSET;
// TODO: Enter and exit alternatve keypad mode.
else if ( c == '=' || c == '>' )
ansimode = NONE;
else
{
ansimode = NONE;
}
return;
}
if ( ansimode == CHARSET )
{
ansimode = NONE;
return;
}
// Read part of a parameter.
if ( '0' <= c && c <= '9' )
{
if ( ansiusedparams == 0 )
ansiusedparams++;
unsigned val = c - '0';
ansiparams[ansiusedparams-1] *= 10;
ansiparams[ansiusedparams-1] += val;
}
// Parameter delimiter.
else if ( c == ';' )
{
if ( ansiusedparams == ANSI_NUM_PARAMS )
{
ansimode = NONE;
return;
}
ansiparams[ansiusedparams++] = 0;
}
// Left for future standardization, so discard this sequence.
else if ( c == ':' )
{
ignore_sequence = true;
}
else if ( c == '>' )
{
ansimode = GREATERTHAN;
}
// Run a command.
else if ( 64 <= c && c <= 126 )
{
if ( !ignore_sequence )
{
if ( ansimode == COMMAND )
run_ansi_command(c);
else if ( ansimode == GREATERTHAN )
{
// Send Device Attributes
if ( c == 'c' )
{
// TODO: Send an appropriate response through the terminal.
}
else
{
ansimode = NONE;
return;
}
ansimode = NONE;
}
}
else
ansimode = NONE;
}
// Something I don't understand, and ignore intentionally.
else if ( c == '?' )
{
//ansimode = NONE;
}
// TODO: There are some rare things that should be supported here.
// Ignore unknown input.
else
{
ansimode = NONE;
}
}
static uint32_t boldify(uint32_t color)
{
int b = color >> 0 & 0xFF;
int g = color >> 8 & 0xFF;
int r = color >> 16 & 0xFF;
int a = color >> 24 & 0xFF;
b += 63;
if ( 255 < b )
b = 255;
g += 63;
if ( 255 < g )
g = 255;
r += 63;
if ( 255 < r )
r = 255;
return make_color_a(r, g, b, a);
}
static void outwc(wchar_t wc)
{
if ( wc == L'\a' )
{
}
else if ( wc == L'\n' )
{
newline();
}
else if ( wc == L'\r' )
{
column = 0;
}
else if ( wc == L'\b' )
{
if ( column )
{
column--;
struct entry* entry = &scrollback[row * columns + column];
next_attr = entry->attr & (ATTR_BOLD | ATTR_UNDERLINE);
if ( entry->wc == L'_' )
next_attr |= ATTR_UNDERLINE;
else if ( entry->wc == L' ' )
next_attr &= ~ATTR_BOLD;
else
next_attr |= ATTR_BOLD;
}
}
else if ( wc == L'\t' )
{
if ( column == columns )
{
newline();
column = 0;
}
column++;
column = -(-column & ~((size_t)0x7));
if ( columns <= column )
column = columns;
}
else if ( wc == L'\e' )
{
next_attr = 0;
ansiusedparams = 0;
ansiparams[0] = 0;
ignore_sequence = false;
ansimode = CSI;
}
else
{
if ( column == columns )
{
newline();
column = 0;
}
struct entry* entry = &scrollback[row * columns + column++];
entry->attr = attr | next_attr;
if ( !(entry->attr & ATTR_INVERSE) )
{
entry->fgcolor = current_fgcolor;
entry->bgcolor = current_bgcolor;
}
else
{
entry->fgcolor = current_bgcolor;
entry->bgcolor = current_fgcolor;
}
if ( entry->attr & ATTR_BOLD )
entry->fgcolor = boldify(entry->fgcolor);
entry->wc = wc;
next_attr = 0;
}
}
static void outc(char c)
{
if ( ansimode != NONE )
{
put_ansi_escaped(c);
return;
}
wchar_t wc;
size_t amount = mbrtowc(&wc, &c, 1, &out_ps);
if ( amount == (size_t) -2 )
return;
if ( amount == (size_t) -1 )
{
memset(&out_ps, 0, sizeof(out_ps));
wc = 0xFFFD; /* REPLACEMENT CHARACTER */;
}
if ( amount == (size_t) 0 )
wc = L' ';
outwc(wc);
}
static pthread_mutex_t scrollback_mutex = PTHREAD_MUTEX_INITIALIZER;
static int master_fd;
static void* outgoing_thread(void* ctx)
{
(void) ctx;
const char* getcursor = "\e[6n";
size_t i = 0;
char c;
ssize_t amount = 0;
while ( 0 < (amount = read(master_fd, &c, 1)) )
{
// TODO: Do escape code handling in the escape code parsing.
if ( c == getcursor[i] )
{
i++;
if ( !getcursor[i] )
{
i = 0;
char buf[64];
snprintf(buf, sizeof(buf), "\e[%zu;%zuR",
(size_t) (row + 1), (size_t) (column + 1));
for ( size_t n = 0; buf[n]; n++ )
{
if ( write(master_fd, &buf[n], 1) <= 0 )
{
warn("incoming write");
break; // TODO: This break is incorrect.
}
}
}
continue;
}
pthread_mutex_lock(&scrollback_mutex);
for ( size_t j = 0; j < i; j++ )
outc(getcursor[j]);
i = 0;
outc(c);
if ( !redraw_pipe_written )
{
char c = 'X';
if ( write(redraw_pipe[1], &c, 1) < 0 )
warn("write: redraw_pipe");
else
redraw_pipe_written = true;
}
pthread_mutex_unlock(&scrollback_mutex);
}
if ( amount < 0 )
warn("outgoing read");
return NULL;
}
void on_disconnect(void* ctx)
{
(void) ctx;
need_exit = true;
}
void on_quit(void* ctx, uint32_t window_id)
{
(void) ctx;
if ( window_id != WINDOW_ID )
return;
need_exit = true;
}
void on_resize(void* ctx, uint32_t window_id, uint32_t width, uint32_t height)
{
(void) ctx;
if ( window_id != WINDOW_ID )
return;
// TODO: The resolution 0x0 gets sent for newly created windows that hasn't
// been shown yet, fix the compositor to not do this.
if ( width == 0 && height == 0 )
return;
pthread_mutex_lock(&scrollback_mutex);
size_t new_rows = height / FONT_HEIGHT;
size_t new_columns = width / FONT_WIDTH;
scrollback_resize(new_rows, new_columns);
struct winsize ws;
ws.ws_row = rows;
ws.ws_col = columns;
if ( ioctl(master_fd, TIOCSWINSZ, &ws) < 0 )
warn("TIOCSWINSZ");
pthread_mutex_unlock(&scrollback_mutex);
need_redraw = true;
WINDOW_WIDTH = width;
WINDOW_HEIGHT = height;
}
void inuc(unsigned char uc)
{
write(master_fd, &uc, 1);
}
void on_keycode(int kbkey)
{
if ( kbkey < 0 )
return;
if ( kbkey == KBKEY_ESC )
{
inuc('\e');
return;
}
const struct kbkey_sequence* seq = lookup_keystroke_sequence(kbkey);
if ( !seq )
return;
const char* str = seq->sequence;
size_t len = strlen(str);
int mods = 0;
if ( modifiers & (MODIFIER_LSHIFT | MODIFIER_RSHIFT) )
mods |= 1;
if ( modifiers & MODIFIER_ALT )
mods |= 2;
if ( modifiers & (MODIFIER_LCONTROL | MODIFIER_RCONTROL) )
mods |= 4;
if ( (seq->flags & SEQUENCE_OSHORT) && mods == 0 )
{
inuc('\e');
inuc('O');
inuc((unsigned char) str[len-1]);
return;
}
for ( size_t i = 0; i < len - 1; i++ )
inuc((unsigned char) str[i]);
if ( seq->flags & SEQUENCE_1IFMOD && mods != 0 )
inuc('1');
if ( mods )
{
inuc(';');
inuc('1' + mods);
}
inuc(str[len-1]);
}
void on_keyboard(void* ctx, uint32_t window_id, uint32_t codepoint)
{
(void) ctx;
if ( window_id != WINDOW_ID )
return;
int kbkey = KBKEY_DECODE(codepoint);
if ( kbkey != 0 )
{
// TODO: Don't do this here, let the compositor do this.
if ( kbkey == KBKEY_LALT )
modifiers |= MODIFIER_ALT;
else if ( kbkey == -KBKEY_LALT )
modifiers &= ~MODIFIER_ALT;
else if ( kbkey == KBKEY_LSHIFT )
modifiers |= MODIFIER_LSHIFT;
else if ( kbkey == -KBKEY_LSHIFT )
modifiers &= ~MODIFIER_LSHIFT;
else if ( kbkey == KBKEY_RSHIFT )
modifiers |= MODIFIER_RSHIFT;
else if ( kbkey == -KBKEY_RSHIFT )
modifiers &= ~MODIFIER_RSHIFT;
else if ( kbkey == KBKEY_LCTRL )
modifiers |= MODIFIER_LCONTROL;
else if ( kbkey == -KBKEY_LCTRL )
modifiers &= ~MODIFIER_LCONTROL;
else if ( kbkey == KBKEY_RCTRL )
modifiers |= MODIFIER_RCONTROL;
else if ( kbkey == -KBKEY_RCTRL )
modifiers &= ~MODIFIER_RCONTROL;
on_keycode(kbkey);
return;
}
if ( codepoint == '\n' )
codepoint = '\r';
bool control = modifiers & (MODIFIER_LCONTROL | MODIFIER_RCONTROL);
if ( codepoint == '\b' )
codepoint = 127;
if ( modifiers & MODIFIER_ALT )
inuc('\e');
if ( control && codepoint == L' ' )
inuc(0);
else if ( control && (L'`' <= codepoint && codepoint <= L'}') )
inuc(codepoint - L'`');
else if ( control && (L'@' <= codepoint && codepoint <= L'_') )
inuc(codepoint - L'@');
else if ( control && codepoint == L'?' )
inuc(127);
else
{
wchar_t wc = codepoint;
char mb[MB_CUR_MAX];
size_t amount = wcrtomb(mb, wc, &in_ps);
if ( amount == (size_t) -1 )
memset(&in_ps, 0, sizeof(in_ps));
else
{
for ( size_t i = 0; i < amount; i++ )
inuc((unsigned char) mb[i]);
}
}
}
void draw(struct display_connection* connection)
{
uint32_t* framebuffer = (uint32_t*)
calloc(sizeof(uint32_t), WINDOW_WIDTH * WINDOW_HEIGHT);
assert(framebuffer);
struct framebuffer fb;
fb.pitch = WINDOW_WIDTH;
fb.buffer = framebuffer;
fb.xres = WINDOW_WIDTH;
fb.yres = WINDOW_HEIGHT;
pthread_mutex_lock(&scrollback_mutex);
size_t draw_rows = WINDOW_HEIGHT / FONT_HEIGHT;
size_t draw_columns = WINDOW_WIDTH / FONT_WIDTH;
if ( rows < draw_rows )
draw_rows = rows;
if ( columns < draw_columns )
draw_rows = columns;
for ( size_t y = 0; y < rows; y++ )
{
size_t yoff = FONT_HEIGHT * y;
for ( size_t x = 0; x < columns; x++ )
{
size_t xoff = FONT_WIDTH * x;
size_t cell_width = FONT_WIDTH;
size_t cell_height = FONT_HEIGHT;
if ( x + 1 == columns )
cell_width = WINDOW_WIDTH - xoff;
if ( y + 1 == rows )
cell_height = WINDOW_HEIGHT - yoff;
struct framebuffer charfb =
framebuffer_crop(fb, xoff, yoff, cell_width, cell_height);
struct entry* entry = &scrollback[y * columns + x];
for ( size_t py = 0; py < charfb.yres; py++ )
{
uint32_t* line = charfb.buffer + py * charfb.pitch;
for ( size_t px = 0; px < charfb.xres; px++ )
line[px] = entry->bgcolor;
}
render_char(charfb, entry->wc, entry->fgcolor);
size_t entry_width = FONT_WIDTH;
size_t entry_height = FONT_HEIGHT;
if ( charfb.xres < entry_width )
entry_width = charfb.xres;
if ( charfb.yres < entry_height )
entry_height = charfb.yres;
size_t underlines = 0;
if ( draw_cursor && y == row && x == column )
underlines = 2;
else if ( entry->attr & ATTR_UNDERLINE )
underlines = 1;
size_t start_underlines = FONT_HEIGHT - underlines;
for ( size_t py = start_underlines; py < entry_height; py++ )
{
uint32_t* line = charfb.buffer + py * charfb.pitch;
for ( size_t x = 0; x < entry_width; x++ )
line[x] = blend_pixel(line[x], entry->fgcolor);
}
}
}
pthread_mutex_unlock(&scrollback_mutex);
display_render_window(connection, WINDOW_ID, 0, 0, WINDOW_WIDTH,
WINDOW_HEIGHT, framebuffer);
free(framebuffer);
}
static void signal_handler(int signum)
{
(void) signum;
}
int main(int argc, char* argv[])
{
struct display_connection* connection = display_connect_default();
if ( !connection && errno == ECONNREFUSED )
display_spawn(argc, argv);
if ( !connection )
err(1, "Could not connect to display server");
int opt;
while ( (opt = getopt(argc, argv, "")) != -1 )
{
switch ( opt )
{
default: return 1;
}
}
load_font();
if ( pipe(redraw_pipe) < 0 )
err(1, "pipe");
rows = 25;
columns = 80;
// TODO: Overflow.
scrollback = calloc(sizeof(struct entry), rows * columns);
if ( !scrollback )
err(1, "malloc");
WINDOW_WIDTH = columns * FONT_WIDTH;
WINDOW_HEIGHT = rows * FONT_HEIGHT;
default_bgcolor = make_color_a(0, 0, 0, 220);
default_fgcolor = palette[7] | 0xFF000000;
current_bgcolor = default_bgcolor;
current_fgcolor = default_fgcolor;
for ( size_t y = 0; y < rows; y++ )
{
for ( size_t x = 0; x < columns; x++ )
{
struct entry* entry = &scrollback[y * columns + x];
entry->attr = 0;
entry->fgcolor = current_fgcolor;
entry->bgcolor = current_bgcolor;
entry->wc = 0;
}
}
display_create_window(connection, WINDOW_ID);
display_resize_window(connection, WINDOW_ID, WINDOW_WIDTH, WINDOW_HEIGHT);
display_title_window(connection, WINDOW_ID, "Terminal");
struct winsize ws;
ws.ws_row = rows;
ws.ws_col = columns;
char path[TTY_NAME_MAX + 1];
int slave_fd;
if ( openpty(&master_fd, &slave_fd, path, NULL, &ws) < 0 )
err(1, "openpty");
sigset_t saved_mask, sigchld_mask;
sigemptyset(&sigchld_mask);
sigaddset(&sigchld_mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &sigchld_mask, &saved_mask);
struct sigaction sa = { .sa_handler = signal_handler };
struct sigaction old_sa;
sigaction(SIGCHLD, &sa, &old_sa);
pid_t child_pid = fork();
if ( child_pid < 0 )
err(1, "fork");
if ( !child_pid )
{
sigprocmask(SIG_SETMASK, &saved_mask, NULL);
if ( setsid() < 0 )
{
warn("setsid");
_exit(1);
}
if ( ioctl(slave_fd, TIOCSCTTY) < 0 )
{
warn("ioctl: TIOCSCTTY");
_exit(1);
}
if ( close(0) < 0 || close(1) < 0 || close(2) < 0 )
{
warn("close");
_exit(1);
}
if ( dup2(slave_fd, 0) != 0 ||
dup2(slave_fd, 1) != 1 ||
dup2(slave_fd, 2) != 2 )
{
warn("dup");
_exit(1);
}
if ( closefrom(3) < 0 )
{
warn("closefrom");
_exit(1);
}
const char* program;
if ( argc <= optind )
{
program = "sh";
uid_t uid = getuid();
struct passwd* pwd = getpwuid(uid);
if ( !pwd )
warn("getpwuid: %ju", (uintmax_t) uid);
else
program = pwd->pw_shell;
char* login_program;
if ( asprintf(&login_program, "-%s", program) < 0 )
{
warn("malloc");
_exit(1);
}
execlp(program, login_program, (const char*) NULL);
}
else
{
// Support explicit login shells using a leading dash.
program = argv[optind];
if ( program[0] == '-' )
program++;
execvp(program, argv + optind);
}
warn("%s", program);
_exit(127);
}
int errnum;
pthread_t outthread;
if ( (errnum = pthread_create(&outthread, NULL, outgoing_thread, NULL)) )
{
errno = errnum;
err(1, "pthread_create");
}
struct display_event_handlers handlers;
memset(&handlers, 0, sizeof(handlers));
handlers.disconnect_handler = on_disconnect;
handlers.quit_handler = on_quit;
handlers.resize_handler = on_resize;
handlers.keyboard_handler = on_keyboard;
const nfds_t nfds = 2;
struct pollfd pfds[nfds];
pfds[0].fd = redraw_pipe[0];
pfds[0].events = POLLIN;
pfds[0].revents = 0;
pfds[1].fd = display_connection_fd(connection);
pfds[1].events = POLLIN;
pfds[1].revents = 0;
while ( !need_exit )
{
int status;
if ( 0 < waitpid(child_pid, &status, WNOHANG) )
break;
if ( need_redraw )
{
draw(connection);
need_redraw = false;
}
if ( need_show )
{
display_show_window(connection, WINDOW_ID);
need_show = false;
}
if ( ppoll(pfds, nfds, NULL, &saved_mask) < 0 )
{
if ( errno == EINTR )
continue;
err(1, "poll");
}
if ( pfds[0].revents )
{
pthread_mutex_lock(&scrollback_mutex);
char c;
ssize_t amount = read(redraw_pipe[0], &c, 1);
if ( amount < 0 )
err(1, "read: redraw_pipe");
if ( 0 < amount )
{
redraw_pipe_written = false;
need_redraw = true;
}
pthread_mutex_unlock(&scrollback_mutex);
}
if ( pfds[1].revents )
{
while ( display_poll_event(connection, &handlers) == 0 );
}
}
display_disconnect(connection);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink